Führen Sie bei einer positiven Ganzzahl ndie folgenden Schritte aus (und geben Sie jede Stufe aus):

1. Beginnen Sie mit einer Liste mit nKopien von n.
2. mache die folgenden nZeiten:
3. im iten Schritt verringert allmählich den ite Eintrag in der Liste , bis es erreichti

So zum Beispiel , wenn die angegebenen nist 4, dann mit Sie beginnen [4,4,4,4]und dann im ersten Schritt haben Sie [3,4,4,4], [2,4,4,4], [1,4,4,4]. Im zweiten Schritt haben Sie [1,3,4,4], [1,2,4,4]. Im dritten Schritt haben Sie [1,2,3,4]. Beim vierten Schritt wird nichts unternommen.

Ihre Ausgabe ist also [[4,4,4,4],[3,4,4,4],[2,4,4,4],[1,4,4,4],[1,3,4,4],[1,2,4,4],[1,2,3,4]].

Jedes sinnvolle Eingabe- / Ausgabeformat ist zulässig.

Es gelten Standardlücken . Das ist Code-Golf : Die Antwort mit der geringsten Anzahl an Bytes gewinnt.

Python-Implementierung zu Überprüfungszwecken .

Gelee , 9 Bytes

r€⁸Œp»\QṚ

Probieren Sie es online!

Wie?

r€⁸Œp»\QṚ - Link: integer, N    e.g. 4
 €        - for €ach of implicit range of N (i.e. for i in [1,2,3,...N])
  ⁸       -   with the chain's left argument, N on the right:
r         -     inclusive range (for i<=N this yields [i, i+1, ..., N]
          - ...leaving us with a list of lists like the post-fixes of [1,2,3,....,N]
          -                     e.g. [[1,2,3,4],[2,3,4],[3,4],[4]]
   Œp     - Cartesian product* of these N lists
          -                     e.g. [[1,2,3,4],[1,2,4,4],[1,3,3,4],[1,3,4,4],[1,4,3,4],[1,4,4,4],[2,2,3,4],[2,2,4,4],[2,3,3,4],[2,3,4,4],[2,4,3,4],[2,4,4,4],[3,2,3,4],[3,2,4,4],[3,3,3,4],[3,3,4,4],[3,4,3,4],[3,4,4,4],[4,2,3,4],[4,2,4,4],[4,3,3,4],[4,3,4,4],[4,4,3,4],[4,4,4,4]]
      \   - cumulative reduce with:
     »    -   maximum (vectorises)
          -                     e.g. [[1,2,3,4],[1,2,4,4],[1,3,4,4],[1,3,4,4],[1,4,4,4],[1,4,4,4],[2,4,4,4],[2,4,4,4],[2,4,4,4],[2,4,4,4],[2,4,4,4],[2,4,4,4],[3,4,4,4],[3,4,4,4],[3,4,4,4],[3,4,4,4],[3,4,4,4],[3,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]]
       Q  - de-duplicate        e.g. [[1,2,3,4],[1,2,4,4],[1,3,4,4],[1,4,4,4],[2,4,4,4],[3,4,4,4],[4,4,4,4]]
        Ṛ - reverse             e.g. [[4,4,4,4],[3,4,4,4],[2,4,4,4],[1,4,4,4],[1,3,4,4],[1,2,4,4],[1,2,3,4]]

* Es ist möglicherweise einfacher zu sehen, was mit dem oben verwendeten kartesischen Produkt mit einer anderen Eingabe passiert:

the Cartesian product of [[0,1,2],[3,4],[5]]
is [[0,3,5],[0,4,5],[1,3,5],[1,4,5],[2,3,5],[2,4,5]]

R , 83 82 74 Bytes

N=rep(n<-scan(),n);while({print(N);any(K<-N>1:n)})N[x]=N[x<-which(K)[1]]-1

Probieren Sie es online!

Anstelle einer doppelten for-Schleife whilegenügt hier eine Schleife: Wir finden den ersten Index, bei dem die Liste größer als der Index ist, und dekrementieren dort.

Khat TRUEwo auch immer N[i]>i, which(K)gibt die wahren Indizes zurück, und wir nehmen die ersten mit [1].

Gelee , 12 Bytes

R‘®¦<³S©$пṚ

Probieren Sie es online!

JavaScript (ES6), 75 Byte

f=(n,a=Array(n).fill(n))=>[[...a],...a.some(v=>v>++j,j=0)?f(a[j-1]--,a):[]]

Probieren Sie es online!

APL + WIN, 54 Bytes

Fordert zur Eingabe einer Ganzzahl auf

((⍴m)⍴n)-+⍀m←0⍪(-0,+\⌽⍳n-1)⊖((+/+/m),n)↑m←⊖(⍳n)∘.>⍳n←⎕

Gibt eine Matrix aus, wobei jede Zeile das Ergebnis jedes Schritts darstellt, z. B. für 4:

4 4 4 4
3 4 4 4
2 4 4 4
1 4 4 4
1 3 4 4
1 2 4 4
1 2 3 4

Jelly , 11 Bytes

x`’Jḟḣ1Ʋ¦ÐĿ

Probieren Sie es online!

Wie es funktioniert

x`’Jḟḣ1Ʋ¦ÐĿ  Main link. Argument: n

x`           Repeat self; yield an array of n copies of n.
         ÐĿ  While the results are unique, repeatedly call the link to the left.
             Return the array of all unique results, including the initial value.
  ’     ¦      Decrement the return value at all indices specified by the chain
               in between.
       Ʋ         Combine the four links to the left into a monadic chain.
   J               Indices; yield [1, ..., n].
    ḟ              Filterfalse; remove all indices that belong to the return value.
     ḣ1            Head 1; truncate the result to length 1.

Python 3 , 91 Bytes

n=int(input())
x=[n]*n;print(x)
for i in range(n):
    for j in[0]*(n-i-1):x[i]-=1;print(x)

Probieren Sie es online!

Java (OpenJDK 8) , 135 Byte

a->{int r[]=new int[a],i=0;java.util.Arrays x=null;x.fill(r,a);for(r[0]++;i<a;r[i++]++)for(;--r[i]>i;System.out.print(x.toString(r)));}

Probieren Sie es online!

Erläuterung:

int r[]=new int[a],i=0;    //Initialize array and loop counter
java.util.Arrays x=null;    //reduces the number of of “Arrays” needed from 3 to 1
x.fill(r,a);    //Sets each value in array length n to int n
for(r[0]++;i<a;r[i++]++)    //Increment everything!
  for(;--r[i]>i;    //If decremented array element is larger than element number:
     System.out.print(x.toString(r)));}    //Print the array

Kredit:

-8 Bytes dank Jonathan Frech !

-16 Bytes dank Kevin Cruijssen !

-1 Byte danke an Okx !

Haskell, 69 67 65 63 Bytes

Rekursive Definition:

f 0=[[]]
f a=map(:(a<$[2..a]))[a,a-1..2]++[1:map(+1)x|x<-f$a-1]

Danke an Laikoni für 2 Bytes!

PHP, 153 Bytes

Probieren Sie es online!

Code

function f($n){
$a=array_fill(0,$n,$n);$r=json_encode($a)."\n";$p=0;while($p<$n)
{if($a[$p]!=$p+1){$a[$p]--;$r.=json_encode($a)."\n";}else{$p++;}}echo$r;}

Ich werde versuchen, die Bytes zu verringern oder die rekursive Funktion zu beenden

Erläuterung

function f($n){
  $a=array_fill(0,$n,$n);          #start with $nlength array filled with $n
  $r=json_encode($a)."\n";         #pushed to the string to output
  $p=0;                            #first position
  while($p<$n){                    #on position $n ($n-1) we do nothing
    if($a[$p]!=$p+1){              #comparing the position+1 to the value
     $a[$p]--;                     #it gets decreased by 1
     $r.= json_encode($a)."\n";    #and pushed
   } else {
     $p++;                       #when position+1 = the value,
   }                               #position is changed ++
  }
   echo $r;
  }

Python 2 , 80 76 Bytes

i=input();l=[i]*i;print l
for x in range(i):
 while l[x]>x+1:l[x]-=1;print l

Probieren Sie es online!

Etwas verschwenderisch, wenn man zwei printAussagen hat, aber ich kann mir im Moment keinen besseren Weg vorstellen.

Python 2 , 70 Bytes

-2 Bytes dank @LeakyNun
-2 Bytes dank @JonathanFrech

i=I=input()
l=[I]*I
exec"exec'print l;l[-i]-=1;'*max(~-i,2);i-=1;"*~-I

Probieren Sie es online!

Java (JDK 10) , 112 Byte

n->{var s="";for(int i=1,k=n,j;i<=n;k=--k>i?k:n-++i+i)for(j=0;j++<n;)s+=(j<i?j:j>i?n:k)+(j<n?",":";");return s;}

Probieren Sie es online!

J , 17-15 Bytes

+/\@,(#=)@i.&.-

Probieren Sie es online!

Erläuterung

+/\@,(#=)@i.&.-  Input: n
              -  Negate n
          i.     Reverse of range [0, n)
       =           Identity matrix of order n
      #            Copy each row by the reverse range
              -  Negate
    ,            Prepend n
+/\              Cumulative sum of rows

Retina , 49 Bytes

.+
*
_
$`_,$= 
.{*\`_+,(_+)
$.1
0`(\b(_+),\2)_
$1

Probieren Sie es online! Erläuterung:

.+
*

Konvertieren Sie die Eingabe in Unary.

_
$`_,$= 

Erstellen Sie eine Liste von n Kopien, von i,ndenen ider Index der Kopie ist.

.

Drucken Sie nichts (wenn die Schleife beendet ist).

{

Schleife, bis sich das Muster nicht mehr ändert.

*\`_+,(_+)
$.1

Löschen Sie vorübergehend das is und konvertieren Sie das ns in dezimal und geben Sie es aus.

0`(\b(_+),\2)_
$1

Nehmen Sie den ersten Listeneintrag, dessen Wert den Index überschreitet, und dekrementieren Sie ihn.

Python 3 , 70 67 65 Bytes

def f(n):
 k=0;a=[n]*n
 while k<n-1:print(a);k+=a[k]==k+1;a[k]-=1

Probieren Sie es online!

• (67) Umwandlung in Funktion: -3 Bytes
• (65) Entfernen nicht benötigter Klammern: -2 Byte

Ungolfed-Version:

def f(n):
    k = 0
    a = [n] * n             # create n-item list with all n's
    while k < n - 1:        # iterate through columns 0..n-1
        print(a)            # print whole list
        if a[k] == k + 1:   # move to the next column when current item reaches k+1
            k += 1
        a[k] -= 1           # decrement current item

C (Klirren) , 131 141 Bytes

i,j,k,m[99];p(){for(k=0;m[k];printf("%d ",m[k++]));puts("");}f(n){for(j=k=m[n]=0;k<n;m[k++]=n);p();for(;j<n;j++)for(i=1;i++<n-j;m[j]--,p());}

Probieren Sie es online!

Dies funktioniert für alle nbis zu 99. TIO schneidet die Ausgabe ab. Es kann beliebig größer unterstützt werden, nindem die Größe des Arrays geändert wird, mwenn der Speicher dies zulässt.

Das Folgende ist auf n = 1..9 begrenzt, aber wesentlich kürzer

C (Klirren) , 89 92 Bytes

i,j;char m[12];f(n){j=!puts(memset(m,n+48,n));for(;j<n;j++)for(i=1;i++<n-j;m[j]--,puts(m));}

Probieren Sie es online!

Aktualisiert: Geändert, um Abhängigkeit von statischer Initialisierung zu vermeiden

Clojure, 132 Bytes

#(loop[R[(vec(repeat % %))]j(- % 2)i 0](if(> i j)R(recur(conj R(update(last R)i dec))(if(= i j)(- % 2)(dec j))(if(= i j)(inc i)i))))

Ich hatte gehofft, dass es kürzer wird ...

Weniger statusbehaftet, aber länger bei 141 Bytes:

#(apply map list(for[i(range %)](concat(repeat(nth(cons 0(reductions +(reverse(range %))))i)%)(range % i -1)(if(>(dec %)i)(repeat(inc i))))))

Python 3, 101 Bytes

def f(n):
 p=print;m=[n for_ in range(n)];p(m)
 for i in range(n):
    while m[i]>1+i:m[i]-=1;p(m)

Wahrscheinlich könnte ich mit dem Ausdruck mehr Golf spielen, aber ich bin nicht auf meinem Computer und bin mir nicht ganz sicher, welche Regeln Python 2 für das Festlegen einer zu druckenden Variablen anwendet. Ich werde später aktualisieren, wenn ich an einen Computer komme oder wenn jemand in den Kommentaren klarstellt.

K (ngn / k) , 34 32 Bytes

{{x[y]-:1;x}\(,x#x),,/(|!x)#'!x}

Probieren Sie es online!