Escreva uma função f (n, k) que exibe a contagem regressiva dimensional k de n.

Uma contagem regressiva unidimensional de 5 parece

 54321

Uma contagem regressiva bidimensional de 5 parece

 54321
 4321
 321
 21
 1

Finalmente, uma contagem regressiva tridimensional de 5 parece

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

Definição formal

A contagem regressiva unidimensional de qualquer n é uma única linha com os dígitos n, n-1, ..., 1 concatenados (seguidos por uma nova linha).

Para qualquer k, a contagem regressiva da dimensão k de 1 é a única linha

 1

Para n> 1 e k> 1, uma contagem regressiva dimensional k de n é uma contagem regressiva dimensional (k-1) de n seguida por uma contagem regressiva dimensional k de n-1.

Entrada

Dois números inteiros positivos k e n <= 9, em qualquer formato que você escolher.

Resultado

A contagem regressiva k-dimensional de n, com uma nova linha após cada contagem regressiva unidimensional. Novas linhas extras são permitidas na saída.

Pontuação

Pontuação de golfe padrão.

Exemplo de bônus

Aqui está um exemplo com k> n, uma contagem regressiva 4-dimensional de 3 (com comentários extras que não devem ser incluídos nas soluções reais):

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

Esclarecimentos:

Os dígitos em uma linha não precisam ser adjacentes, mas devem ser espaçados igualmente.

Você pode escrever um programa completo em vez de apenas uma função, se preferir.

Python, 60 bytes

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

Teste em Ideone .

Como funciona

A contagem regressiva k- dimensional de n pode ser definida com um único caso base:

Se n = 1 ou k = 1 , a saída é n || n-1 || ... || 1 || Where , onde || indica concatenação.

Utilizando a definição recursiva a partir da pergunta, f(n,k)retornos f(n,k-1)+f(n-1,k), se n> 1 e k> 1 ; caso contrário, ele retornará os últimos n + 1 caracteres de '987654321\n'.

Gelatina , 8 bytes

R¡UḌFṚp⁷

Este é um programa completo que espera n e k como argumentos da linha de comando.

Experimente online!

Como 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

Economizou 1 bytes graças a @ edc65:

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

Respostas anteriores

38 bytes graças 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 graças a @ Sp3000

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

Executa o procedimento conforme descrito no OP: une os nresultados decrescentes k-1em novas linhas com uma base da recursão da 'n...1'string quando ké 1( knão maior do que 1desde que recebemos kentrada positiva garantida ).

Casos de teste em ideone

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

dé o número de dimensões, né o número da contagem regressiva.

Postará uma explicação em breve.

EDIT # 1: Alterado para lambda.

EDIT # 2: salvou 1 byte graças a @DestructibleWatermelon.

Haskell, 57 bytes

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

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

Uma implementação direta da definição.

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

Teste:

(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 é uma função que leva k no LHS e n no RHS.

Guardou 5 bytes com ideias 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

Explicação

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 e depois k .

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

~∘'0'⍤1remova ( ~) os ( ∘) zeros ( '0') das linhas ( ⍤1) (preenchimento com espaços conforme necessário) de

⍕ a representação de caracteres de

(⌽⍳)⍤0⍣⎕a ⌽contagem reversa ( ) até ( ⍳) cada escalar ( ⍤0), repetida ( ⍣) entrada ( ⎕) vezes

⊢ em

⎕ entrada numérica

TryAPL online!

C 93 bytes

Implementação 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

Implementação 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

Resposta em Python do Porto de Dennis ♦.

Ruby, 56 bytes

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

Uso

Ao exibir qualquer solução, você deve usar "Kernel # puts".

Exemplo:

puts f[9,3]