Escriba una función f (n, k) que muestre la cuenta regresiva k-dimensional de n.

Parece una cuenta regresiva unidimensional de 5

 54321

Parece una cuenta regresiva bidimensional de 5

 54321
 4321
 321
 21
 1

Finalmente, una cuenta regresiva tridimensional de 5 parece

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

Definicion formal

La cuenta regresiva unidimensional de cualquier n es una sola línea con los dígitos n, n-1, ..., 1 concatenados (seguidos de una nueva línea).

Para cualquier k, la cuenta regresiva k-dimensional de 1 es la línea única

 1

Para n> 1 yk> 1, una cuenta regresiva k-dimensional de n es una cuenta regresiva dimensional (k-1) de n seguida de una cuenta regresiva k-dimensional de n-1.

Entrada

Dos enteros positivos k y n <= 9, en cualquier formato que elija.

Salida

La cuenta regresiva k-dimensional de n, con una nueva línea después de cada cuenta regresiva unidimensional. Se permiten nuevas líneas adicionales en la salida.

Puntuación

Puntaje de golf estándar.

Ejemplo de bonificación

Aquí hay un ejemplo con k> n, una cuenta regresiva de 4 dimensiones desde 3 (con comentarios adicionales que no se incluirán en las soluciones reales):

 -- 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  

Aclaraciones:

Los dígitos en una línea no necesitan ser adyacentes, pero deben estar espaciados uniformemente.

Si lo prefiere, puede escribir un programa completo en lugar de solo una función.

Python, 60 bytes

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

Pruébalo en Ideone .

Cómo funciona

La cuenta regresiva dimensional k desde n se puede definir con un solo caso base:

Si n = 1 o k = 1 , la salida es n || n-1 || ... || 1 || ¶ , donde || indica concatenación.

Usando la definición recursiva de la pregunta, f(n,k)devuelve f(n,k-1)+f(n-1,k)si n> 1 y k> 1 ; de lo contrario, devuelve los últimos n + 1 caracteres de '987654321\n'.

Jalea , 8 bytes

R¡UḌFṚp⁷

Este es un programa completo que espera n y k como argumentos de línea de comandos.

Pruébalo en línea!

Cómo funciona

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 bytes

Guardado 1 bytes gracias a @ edc65:

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

Respuestas anteriores

38 bytes gracias a @Neil:

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

40 bytes:

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

Python, 76 75 bytes

-1 byte gracias a @ Sp3000

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

Realiza el procedimiento como se describe en el OP: une los nresultados decrecientes para las k-1nuevas líneas con una base de la recursión de la 'n...1'cadena cuando kes 1( kno mayor que 1ya que estamos garantizados como positivosk entrada ).

Casos de prueba sobre ideona

Python, 86 81 80 bytes

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

des el número de dimensiones, nes el número de cuenta regresiva.

Publicaremos una explicación pronto.

EDITAR # 1: lo cambió a lambda.

EDITAR # 2: guardado 1 byte gracias a @DestructibleWatermelon.

Haskell, 57 bytes

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

Ejemplo de uso: 5 # 3-> "\n54321\n4321\n321\n21\n1\n4321\n321\n21\n1\n321\n21\n1\n21\n1\n1".

Una implementación directa de la definición.

Raqueta 215 bytes

(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))))

Pruebas:

(f 54321 3)

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

J, 38 37 32 bytes

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

Esta es una función que toma k en el LHS y yn en el RHS.

Guardado 5 bytes con ideas de @ Adám.

Uso

   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

Explicación

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 bytes

Solicita n , luego k .

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

~∘'0'⍤1elimine ( ~) los ( ∘) ceros ( '0') de las filas ( ⍤1) (relleno con espacios según sea necesario) de

⍕ la representación del personaje de

(⌽⍳)⍤0⍣⎕el ⌽recuento invertido ( ) hasta ( ⍳) cada escalar ( ⍤0), ⍣entrada repetida ( ⎕) veces

⊢ en

⎕ entrada numérica

TryAPL en línea!

C 93 Bytes

Implementación iterativa.

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 Bytes

Implementación recursiva

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

Lote, 117 bytes

@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

La respuesta Python de Port of Dennis ♦.

Ruby, 56 bytes

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

Uso

Cuando muestres cualquier solución, debes usar "Kernel # Puts".

Ejemplo:

puts f[9,3]