Schreiben Sie eine Funktion f (n, k), die den k-dimensionalen Countdown von n anzeigt.

Ein 1-dimensionaler Countdown von 5 sieht aus wie

 54321

Ein 2-dimensionaler Countdown von 5 sieht so aus

 54321
 4321
 321
 21
 1

Schließlich sieht ein dreidimensionaler Countdown von 5 aus

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

Formale Definition

Der eindimensionale Countdown von jedem n ist eine einzelne Zeile, in der die Ziffern n, n-1, ..., 1 verkettet sind (gefolgt von einer neuen Zeile).

Für jedes k ist der k-dimensionale Countdown von 1 die einzelne Zeile

 1

Für n> 1 und k> 1 ist ein k-dimensionaler Countdown von n ein (k-1) -dimensionaler Countdown von n, gefolgt von einem k-dimensionalen Countdown von n-1.

Eingang

Zwei positive ganze Zahlen k und n <= 9 in einem beliebigen Format.

Ausgabe

Der k-dimensionale Countdown von n mit einer neuen Zeile nach jedem eindimensionalen Countdown. Zusätzliche Zeilenumbrüche sind in der Ausgabe zulässig.

Wertung

Standard Golf Scoring.

Bonus Beispiel

Hier ist ein Beispiel mit k> n, einem 4-dimensionalen Countdown von 3 (mit zusätzlichen Kommentaren, die in tatsächlichen Lösungen nicht enthalten sein sollen):

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

Klarstellungen:

Ziffern in einer Zeile müssen nicht benachbart sein, aber sie müssen gleichmäßig verteilt sein.

Sie können ein vollständiges Programm schreiben, anstatt nur eine Funktion.

Python, 60 Bytes

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

Teste es auf Ideone .

Wie es funktioniert

Der k- dimensionale Countdown von n kann mit einem einzigen Basisfall definiert werden:

Wenn n = 1 oder k = 1 ist , ist die Ausgabe n || n-1 || ... || 1 || ¶ , wo || zeigt Verkettung an.

Gibt unter Verwendung der rekursiven Definition aus der Frage f(n,k)zurück, f(n,k-1)+f(n-1,k)wenn n> 1 und k> 1 sind ; Andernfalls werden die letzten n + 1 Zeichen von zurückgegeben '987654321\n'.

Gelee , 8 Bytes

R¡UḌFṚp⁷

Dies ist ein vollständiges Programm, das n und k als Befehlszeilenargumente erwartet .

Probieren Sie es online!

Wie es funktioniert

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

Dank @ edc65 1 Byte gespart:

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

Vorherige Antworten

38 Bytes dank @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 dank @ Sp3000

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

Caries aus dem Verfahren , wie im OP beschrieben schließt sich die abnehmenden nErgebnisse für k-1auf newlines mit einer Base der Rekursion der 'n...1'Zeichenfolge , wenn kist 1( knicht mehr als 1da wir positiven garantiert kEingang).

Testfälle auf 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)])

dist die Anzahl der Dimensionen, nist die Countdown-Nummer.

Werde bald eine Erklärung posten.

EDIT # 1: Es wurde in Lambda geändert.

EDIT # 2: 1 Byte dank @DestructibleWatermelon gespeichert.

Haskell, 57 Bytes

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

Anwendungsbeispiel: 5 # 3-> "\n54321\n4321\n321\n21\n1\n4321\n321\n21\n1\n321\n21\n1\n21\n1\n1".

Eine direkte Umsetzung der Definition.

Schläger 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))))

Testen:

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

Dies ist eine Funktion, die k auf dem LHS und übernimmt n auf der rechten Seite .

5 Bytes mit Ideen von @ Adám gespeichert.

Verwendung

   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

Erläuterung

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

Fordert zur Eingabe von n und dann von k auf .

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

~∘'0'⍤1entferne ( ~) die ( ∘) Nullen ( '0') aus den Zeilen (⍤1 ) (nach Bedarf mit Leerzeichen auffüllen) von

⍕ die Charakterdarstellung von

(⌽⍳)⍤0⍣⎕Die umgekehrten ( ⌽) zählen bis ( ⍳) jedes skalaren ( ⍤0), wiederholten ( ⍣) Eingabe ( ⎕) Male

⊢ auf

⎕ numerische Eingabe

TryAPL online!

C 93 Bytes

Iterative Implementierung.

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

Rekursive Implementierung

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

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

Port of Dennis ♦ 's Python-Antwort.

Ruby, 56 Bytes

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

Verwendung

Wenn Sie Lösungen anzeigen, sollten Sie "Kernel # puts" verwenden.

Beispiel:

puts f[9,3]