Scrivi una funzione f (n, k) che visualizza il conto alla rovescia k-dimensionale da n.

Sembra un conto alla rovescia monodimensionale da 5

 54321

Sembra un conto alla rovescia bidimensionale da 5

 54321
 4321
 321
 21
 1

Infine, appare un conto alla rovescia tridimensionale da 5

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

Definizione formale

Il conto alla rovescia monodimensionale da qualsiasi n è una riga singola con le cifre n, n-1, ..., 1 concatenate (seguite da una nuova riga).

Per ogni k, il conto alla rovescia k-dimensionale da 1 è la riga singola

 1

Per n> 1 e k> 1, un conto alla rovescia dimensionale k da n è un conto alla rovescia dimensionale (k-1) da n seguito da un conto alla rovescia k-dimensionale da n-1.

Ingresso

Due numeri interi positivi k e n <= 9, in qualsiasi formato tu scelga.

Produzione

Il conto alla rovescia k-dimensionale da n, con una nuova riga dopo ogni conto alla rovescia monodimensionale. Newline extra sono consentite nell'output.

punteggio

Punteggio golf standard.

Esempio di bonus

Ecco un esempio con k> n, un conto alla rovescia a 4 dimensioni da 3 (con commenti extra che non devono essere inclusi nelle soluzioni effettive):

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

chiarimenti:

Le cifre su una linea non devono necessariamente essere adiacenti, ma devono essere equidistanti.

Puoi scrivere un programma completo invece di una sola funzione, se preferisci.

Python, 60 byte

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

Provalo su Ideone .

Come funziona

Il k countdown dimensionale da n può essere definita con un singolo caso base:

Se n = 1 o k = 1 , l'uscita è n || n-1 || ... || 1 || ¶ , dove || indica la concatenazione.

Utilizzando la definizione ricorsiva dalla domanda, f(n,k)restituisce f(n,k-1)+f(n-1,k)se n> 1 e k> 1 ; altrimenti restituisce gli ultimi n + 1 caratteri da '987654321\n'.

Gelatina , 8 byte

R¡UḌFṚp⁷

Questo è un programma completo che prevede n e k come argomenti della riga di comando.

Provalo online!

Come funziona

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 byte

Salvato 1 byte grazie a @ edc65:

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

Risposte precedenti

38 byte grazie a @Neil:

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

40 byte:

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

Python, 76 75 byte

-1 byte grazie a @ Sp3000

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

Esegue la procedura come descritto nel PO: unisce i nrisultati decrescenti per k-1su newline con una base della ricorsione della 'n...1'stringa quando kè 1( knon maggiore di da 1quando ci viene garantito un kinput positivo ).

Casi di prova su ideone

Python, 86 81 80 byte

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

dè il numero di dimensioni, nè il numero del conto alla rovescia.

Pubblicherà presto una spiegazione.

EDIT # 1: cambiato in lambda.

EDIT # 2: salvato 1 byte grazie a @DestructibleWatermelon.

Haskell, 57 byte

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

Esempio di utilizzo: 5 # 3-> "\n54321\n4321\n321\n21\n1\n4321\n321\n21\n1\n321\n21\n1\n21\n1\n1".

Un'attuazione diretta della definizione.

Racchetta 215 byte

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

test:

(f 54321 3)

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

J, 38 37 32 byte

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

Questa è una funzione che accetta k su LHS e n su RHS.

5 byte salvati con idee da @ 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

Spiegazione

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 byte

Richiede n , quindi k .

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

~∘'0'⍤1rimuovere ( ~) gli ( ∘) zeri ( '0') dalle righe ( ⍤1) (riempimento con spazi necessari) di

⍕ la rappresentazione del personaggio di

(⌽⍳)⍤0⍣⎕il ⌽conteggio invertito ( ) fino a ( ⍳) ogni volta scalare ( ⍤0), ripetuto ( ⍣) input ( ⎕) volte

⊢ su

⎕ input numerico

ProvaAPL online!

C 93 byte

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

Implementazione ricorsiva

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

Lotto, 117 byte

@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

Port of Dennis - La risposta di Python.

Rubino, 56 byte

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

uso

Quando si visualizzano soluzioni, è necessario utilizzare "Kernel # put".

Esempio:

puts f[9,3]