Olumlu bir tamsayı verilen n, aşağıdakileri yapın (ve her aşamada çıktı):

1. nkopyalarını içeren bir liste ile başlayın n.
2. aşağıdakileri yapın n:
3. En iinci adımda yavaş yavaş azaltma ivarıncaya kadar listenin inci girişii

Verilirse Yani, örneğin, nbir 4, o zaman başlamak [4,4,4,4]sahip ilk adımda daha sonra, ve [3,4,4,4], [2,4,4,4], [1,4,4,4]. İkinci adımda, var [1,3,4,4], [1,2,4,4]. Üçüncü adımda var [1,2,3,4]. Dördüncü adımda hiçbir şey yapılmaz.

Yani çıktınız [[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]].

Herhangi bir makul giriş / çıkış formatına izin verilir.

Standart boşluklar uygulanır. Bu kod-golf : En küçük byte-count ile cevap kazanır.

Kontrol amaçlı Python uygulaması .

Jöle , 9 bayt

r€⁸Œp»\QṚ

Çevrimiçi deneyin!

Nasıl?

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

* Yukarıda kullanılan kartezyen ürünü ile farklı bir girdiyle neler olup bittiğini görmek daha kolay olabilir:

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 bayt

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

Çevrimiçi deneyin!

Bir çift for döngüsü yerine, whileburada bir döngü yeterlidir: listenin indeksten daha büyük olduğu ilk dizini buluruz ve burada azalır.

Kher TRUEyerde N[i]>i, which(K)gerçek endeksleri döndürür ve ilkini birlikte alırız [1].

Jöle , 12 bayt

R‘®¦<³S©$пṚ

Çevrimiçi deneyin!

JavaScript (ES6), 75 bayt

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

Çevrimiçi deneyin!

APL + WIN, 54 bayt

Tamsayının ekran girişi için bilgi istemi

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

4 için her adımın sonucunu temsil eden her satırlı bir matris çıktılar:

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

Jöle , 11 bayt

x`’Jḟḣ1Ʋ¦ÐĿ

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

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)

Çevrimiçi deneyin!

Java (OpenJDK 8) , 135 bayt

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)));}

Çevrimiçi deneyin!

Açıklama:

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

Kredi:

-8 byte Jonathan Frech sayesinde !

Kevin Cruijssen sayesinde -16 bayt !

Okx sayesinde -1 bayt !

Haskell, 69 67 65 63 bayt

Özyinelemeli tanım:

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

2 bayt için Laikoni'ye teşekkürler!

PHP, 153 Bayt

Çevrimiçi deneyin!

kod

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

Baytları düşürmeye çalışacağım veya özyinelemeli işlevi tamamlayacağım

açıklama

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 bayt

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

Çevrimiçi deneyin!

İki printifadeye sahip olmak biraz acı ama şu anda daha iyi bir yol düşünemiyorum.

Python 2,70 bayt

@LeakyNun sayesinde -2 bayt @JonathanFrech
sayesinde -2 bayt

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

Çevrimiçi deneyin!

Java (JDK 10) , 112 bayt

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

Çevrimiçi deneyin!

J , 17 15 bayt

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

Çevrimiçi deneyin!

açıklama

+/\@,(#=)@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 bayt

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

Çevrimiçi deneyin! Açıklama:

.+
*

Girişi unary'ye dönüştürün.

_
$`_,$= 

Kopyanın indeksinin i,nbulunduğu n kopyaların bir listesini oluşturun i.

.

Hiçbir şey yazdırmayın (döngü bittiğinde).

{

Desen değişene kadar döngü.

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

S'yi geçici olarak silin ve is'yi nondalık basamağa ve çıkışa dönüştürün .

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

Değeri dizini aşan ilk liste girişini yapın ve düşürün.

Python 3 , 70 67 65 bayt

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

Çevrimiçi deneyin!

• (67) Fonksiyona dönüştürme: -3 bayt
• (65) Gereksiz parantezleri çıkarma: -2 bayt

Ungolfed versiyonu:

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 (clang) , 131 141 bayt

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

Çevrimiçi deneyin!

Bu, n99'a kadar olan herkes için işe yarayacak . TIO çıkışı keser. Bellek izin verdiği nölçüde dizinin boyutunu değiştirerek isteğe bağlı olarak daha büyük destekleyebilir m.

Aşağıdakiler n = 1..9 ile sınırlıdır ancak önemli ölçüde daha kısadır

C (clang) , 89 92 bayt

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));}

Çevrimiçi deneyin!

Güncelleme: Statik başlatmaya bağımlı olmamak için değiştirildi

Clojure, 132 bayt

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

Bunun daha kısa olmasını umuyordum ...

Daha az durumlu ancak daha uzun 141 bayt:

#(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 bayt

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)

Muhtemelen baskı ile daha çok golf oynardım, ama bilgisayarımdan uzaktayım ve python 2'nin yazdırmak için bir değişken ayarlama kurallarından tam olarak emin değilim. Bir bilgisayara ulaştığımda veya yorumlarda biri açıklığa kavuşursa daha sonra güncellenirim.

K (ngn / k) ' , 34 , 32 bayt

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

Çevrimiçi deneyin!