Écrivez une fonction f (n, k) qui affiche le compte à rebours en k à partir de n.

Un compte à rebours unidimensionnel à partir de 5 ressemble à

 54321

Un compte à rebours en 2 dimensions à partir de 5 ressemble à

 54321
 4321
 321
 21
 1

Enfin, un compte à rebours en 3 dimensions à partir de 5 ressemble à

 54321
 4321
 321
 21
 1
 4321
 321
 21
 1
 321
 21
 1
 21
 1
 1

Définition formelle

Le compte à rebours unidimensionnel de n'importe quel n est une seule ligne avec les chiffres n, n-1, ..., 1 concaténés (suivi d'une nouvelle ligne).

Pour tout k, le compte à rebours k-dimensionnel de 1 est la ligne unique

 1

Pour n> 1 et k> 1, un compte à rebours k-dimensionnel à partir de n est un compte à rebours (k-1)-dimensionnel à partir de n suivi d'un compte à rebours k-dimensionnel à partir de n-1.

Contribution

Deux entiers positifs k et n <= 9, dans le format de votre choix.

Production

Le compte à rebours en k à partir de n, avec une nouvelle ligne après chaque compte à rebours en 1 dimension. Des sauts de ligne supplémentaires sont autorisés dans la sortie.

Notation

Score de golf standard.

Exemple de bonus

Voici un exemple avec k> n, un compte à rebours en 4 dimensions à partir de 3 (avec des commentaires supplémentaires qui ne doivent pas être inclus dans les solutions réelles):

 -- 3-dimensional countdown from 3
 321
 21
 1
 21
 1
 1
 -- 4-dimensional countdown from 2:
 ---- 3-dimensional countdown from 2:
 21
 1
 1
 ---- 4-dimensional countdown from 1:
 1  

Précisions:

Les chiffres sur une ligne ne doivent pas nécessairement être adjacents, mais ils doivent être régulièrement espacés.

Vous pouvez écrire un programme complet au lieu d'une simple fonction, si vous préférez.

Python, 60 octets

f=lambda n,k:n>1<k and f(n,k-1)+f(n-1,k)or'987654321\n'[~n:]

Testez-le sur Ideone .

Comment ça fonctionne

Le compte à rebours en k à partir de n peut être défini avec un seul cas de base:

Si n = 1 ou k = 1 , la sortie est n || n-1 || ... || 1 || ¶ , où || indique une concaténation.

En utilisant la définition récursive de la question, f(n,k)retourne f(n,k-1)+f(n-1,k)si n> 1 et k> 1 ; sinon, il renvoie les n + 1 derniers caractères de '987654321\n'.

Gelée , 8 octets

R¡UḌFṚp⁷

Il s'agit d'un programme complet qui attend n et k comme arguments de ligne de commande.

Essayez-le en ligne!

Comment ça fonctionne

R¡UḌFṚp⁷  Main link. Left argument: n. Right argument: k

 ¡        Repeat the link to the left k times.
R           Range; map each integer j in the previous return value to [1, ..., j].
  U       Upend; reverse each 1-dimensional array in the result.
   Ḍ      Undecimal; convert each 1-dimensional array from base 10 to integer.
    F     Flatten the resulting array.
     Ṛ    Reverse the result.
      p⁷  Cartesian product with '\n'. (Join is weird for singleton arrays.)

Javascript, 40 38 37 octets

1 octets enregistrés grâce à @ edc65:

f=(n,k)=>k*n?f(n,k-1)+f(n-1,k):n||`
`

Réponses précédentes

38 octets grâce à @Neil:

f=(n,k)=>k&&n?f(n,k-1)+f(n-1,k):n||`
`

40 octets:

f=(n,k)=>k&&n?f(n,k-1)+f(n-1,k):n?n:'\n'

Python, 76 75 octets

-1 octet grâce à @ Sp3000

c=lambda n,k:k>1and'\n'.join(c(n-i,k-1)for i in range(n))or'987654321'[-n:]

Exécute la procédure telle que décrite dans l'OP: joint les nrésultats décroissants pour k-1les sauts de ligne avec une base de récursivité de la 'n...1'chaîne quand kest1 ( kpas plus grand que 1puisque nous sommes garantis une kentrée positive ).

Cas de test sur ideone

Python, 86 81 80 octets

o=lambda d,n:"987654321"[-n:]if d<2else"\n".join([o(d-1,n-x) for x in range(n)])

d est le nombre de dimensions, n est le nombre de compte à rebours.

Publiera bientôt une explication.

EDIT # 1: changé en lambda.

EDIT # 2: 1 octet enregistré grâce à @DestructibleWatermelon.

Haskell, 57 octets

n#1='\n':(show=<<[n,n-1..1])
1#_=1#1
n#k=n#(k-1)++(n-1)#k

Exemple d'utilisation: 5 # 3-> "\n54321\n4321\n321\n21\n1\n4321\n321\n21\n1\n321\n21\n1\n21\n1\n1".

Une mise en œuvre directe de la définition.

Raquette 215 octets

(define(g n k(s(number->string n)))(cond [(< k 2) n]
[else(define o(for/list((i(string-length s)))
(string->number(substring s i))))(for/list((x o))(g x(- k 1)))])) 
(define(f n k)(for-each println(flatten(g n k))))

Essai:

(f 54321 3)

54321
4321
321
21
1
4321
321
21
1
321
21
1
21
1
1

J, 38 37 32 octets

a:":@>@-.~&,0<@-."1~0&(](-i.)"0)

C'est une fonction qui prend k sur le LHS et n sur le RHS.

5 octets enregistrés avec des idées de @ Adám.

Usage

   f =: a:":@>@-.~&,0<@-."1~0&(](-i.)"0)
   3 f 5
5 4 3 2 1
4 3 2 1  
3 2 1    
2 1      
1        
4 3 2 1  
3 2 1    
2 1      
1        
3 2 1    
2 1      
1        
2 1      
1        
1

Explication

a:":@>@-.~&,0<@-."1~0&(](-i.)"0)  Input: k on LHS, n on RHS
                    0&(        )  Repeat k times on initial value n
                        (   )"0   For each value x
                          i.        Make the range [0, x)
                         -          Subtract x from each to make the range [x, 1]
                       ]            Return the array of ranges
            0  -."1~              Remove the zeros from each row
             <@                   Box each row
          &,                      Flatten the array of boxes
a:     -.~                        Remove the empty boxes
     >@                           Unbox each
  ":@                             Convert it into a string and return

Dyalog APL , 18 octets

Demande n , puis k .

~∘'0'⍤1⍕(⌽⍳)⍤0⍣⎕⊢⎕

~∘'0'⍤1supprimer ( ~) le (∘ ) zéros ( '0') des lignes ( ⍤1) (remplissage avec des espaces au besoin) de

⍕ la représentation des caractères de

(⌽⍳)⍤0⍣⎕le nombre inversé ( ⌽) jusqu'à ( ⍳) chaque scalaire ( ⍤0), répété (⍣ ) fois entrée ( ⎕)

⊢ sur

⎕ entrée numérique

TryAPL en ligne!

C 93 octets

Mise en œuvre itérative.

m,i,j;f(n,k){for(;m<k+2;m++)for(j=0;j<n;j++){for(i=m;i<n-j;i++)printf("%d",n-j-i);puts("");}}

C 67 65 61 56 52 octets

Implémentation récursive

f(n,k){n*k?f(n,k-1)+f(n-1,k):puts("987654321"+9-n);}

Lot, 117 octets

@setlocal
@set/an=%1-1,k=%2-1,p=n*k,s=987654321
@if %p%==0 (call echo %%s:~-%1%%)else call %0 %1 %k%&call %0 %n% %2

Réponse de Python de Port of Dennis ♦.

Rubis, 56 octets

f=->n,k{n>1&&k>1?[f[n,k-1],f[n-1,k]]:[*1..n].reverse*""}

Usage

Lorsque vous affichez des solutions, vous devez utiliser "Kernel # put".

Exemple:

puts f[9,3]