N girişi verilen bir program yazın, doğal sayıları kullanarak tüm olası n-tupler üretecektir.

n=1
(1),(2),(3),(4),(5),(6)...

n=2
(1,1),(1,2),(2,1),(2,2),(1,3),(3,1),(2,3),(3,2),(3,3)...

n=6
(1,1,1,1,1,1) (1,1,1,1,2,1) (1,1,1,2,1,1)... 

• Çıktı, diğer kuralları ihlal etmeyen herhangi bir sırada olabilir.
• Programın sonsuza dek sürmesi ve geçerli tüm delilleri bir kez teorik olarak listelemesi için yazılmalıdır.
  • Gerçekte, programınız tamsayı tipinizin sınırına ve çökmesine ulaşacaktır. Yalnızca tamsayı türünüz sınırsız olsaydı , program sonsuz uzun sürerse bu kabul edilebilir .
  • Her geçerli bölüm, yalnızca programın bu kadar uzun süre çalışmasına izin verildiyse, sınırlı bir süre içinde listelenmelidir.
• Çıktı, isteğe bağlı olarak, doğal sayılara ek olarak sıfır içerebilir.
• Her bir tuple içindeki tupler ve sayılar arasındaki ayrım açık ve tutarlı olduğu sürece, programınızın çıkış formatını rahatınız için seçebilirsiniz. (Örneğin, her satıra bir demet.)
• Giriş (n) 1-6 arasında bir tam sayıdır. Bu aralığın dışındaki girdiler için gerekli davranış tanımsız.
• Code-golf kuralları geçerlidir, en kısa program kazanır.

Kum havuzu aşamasında geri bildirim için "Artemis Fowl" teşekkürler.

Kabuğu , 2 bayt

πN

Çevrimiçi deneyin!

açıklama

NDoğal sayıların sonsuz listesidir [1,2,3,4,... πKartezyen gücüdür. Sonuç, sonsuz bir liste listesidir. İstenilen uzunluktaki her liste tam olarak bir kez meydana gelir π, çünkü böyle soğuktur. Giriş ve çıkış örtük.

Haskell , 62 bayt

([1..]>>=).(!)
0!s=[[]|s<1]
n!s=[a:p|a<-[1..s],p<-(n-1)!(s-a)]

Çevrimiçi deneyin!

n!snToplanan tüm -tupl'leri oluşturur s.

O zaman cevap ([1..]>>=).(!)yani \n -> [t | s<-[1..], t<-n!s].

Bu, bir tamsayıyı nsonsuz tembel tuples listesine (tamsayı listeleri) eşleyen bir fonksiyondur .

Haskell , 50 bayt

f n=[l|k<-[0..],l<-mapM([0..k]<$f)[0..n],sum l==k]

Çevrimiçi deneyin!

n-Toplar toplamına göre sıralanmış olarak listeler . 0'dan k'ye kadar olan mapMtüm nsayıları üretmek için ağır kaldırma işlemini yapar . İşin <$fpüf noktası burada açıklanmaktadır .

Haskell , 51 bayt

f 1=pure<$>[0..]
f n=[a-k:k:t|a:t<-f$n-1,k<-[0..a]]

Çevrimiçi deneyin!

Ardışık tüm uzanıyor n-1tüm içine -tuples nbölerek ilk sayı -tuples aher n-1iki sayı içine -tuple a-k,kmümkün olan her şekilde ona toplamı, o.

Pyth - 9 bayt

@FryAmTheEggman'a golf için teşekkürler

Tüm x boyunca döngüler ve [1..x] ^ n. Bu, kopyaları yapar, bu yüzden sadece o x için yeni olanları tutar, aka, içinde x içerir. Biçimlendirme biraz garip, ancak bir bayt ile standart hale getirilebilir,.V1j}#b^Sb

.V1}#b^Sb

Çevrimiçi deneyin .

Brachylog (v2), 9 bayt

~l.ℕᵐ+≜∧≜

Çevrimiçi deneyin!

Bu, olası tüm delilleri üreten sonsuz bir jeneratördür. TIO bağlantısı, 1000 eleman üretmek için jeneratörü kullanan ve bunları basan bir başlığa sahiptir (ancak bunun yerine sorduğumda jeneratör sürekli devam edebilir; Brachylog'un tam sayıları sınırsızdır).

Endişeli bir yol olması gerektiğini hissediyor, ancak çok fazla kısıtlama var ve bu onları tek bir programa sığdırabileceğim en korkunç şey.

açıklama

~l.ℕᵐ+≜∧≜
  .        Generate
        ≜  all explicit
~l         lists whose length is {the input}
    ᵐ      for which every element
   ℕ       is non-negative
     +     and whose sum
      ≜    is used to order the lists (closest to zero first)
       ∧   [remove unwanted implicit constraint]

Bu arada, ≜Brachylog'un bakış açısıyla aynı şeyi yapmasına rağmen , ikisinin açıklamalarımın ne kadar farklı olduğunu ilginç buluyor. Birincisi ≜programdaki ilk kararsız belirleyicidir, bu nedenle sonuçların sırasını belirler; Bu durumda, listenin toplamı için olası tüm açık değerleri 0, 1, 2, 3… sırayla hesaplar ve listelerin toplam sırasına göre çıkarılmasını sağlamak için kullanılır (bu her birinin mümkün olmasını sağlar) sonlu miktarda çıktıdan sonra liste görüntülenir). İkincisi ≜, listenin tüm açık olasılıklarını hesaplamak için kullanılır (listedeki öğelerin birbirleriyle nasıl ilişkili olduğunu belirten bir formül çıkarmak yerine).

Perl 6 , 37 bayt

{$++.polymod(1+$++ xx $_-1).say xx *}

Çevrimiçi deneyin!

Temel polymodolarak, gerektiği kadar çok girdiyle çalışır , burada modulo her zaman girdiden daha büyüktür, yani 0.polymod (1,1,1), 1.polymod (2,2,2) vb. menzil. Perl6 beni modulo sonsuzluğa izin vermiyor ...

Wolfram Dili (Mathematica) , 62 bayt

Do[Print/@Permutations@#&/@n~IntegerPartitions~{#},{n,#,∞}]&

Çevrimiçi deneyin!

Tutarsız ayırma ile -3 bayt (sil @#&)

Çevrimiçi deneyin!

C # (Visual C # Etkileşimli Derleyici) , 148 bayt

n=>{var a=new int[n];int j=0;void g(int k){if(k<n)for(int i=0;i++<j;g(k+1))a[k]=i;else if(a.Sum()==j)WriteLine(string.Join(' ',a));}for(;;j++)g(0);}

Çevrimiçi deneyin!

@ASCIIOnly sayesinde -3 bayt!

// n: size of tuples to generate
n=>{
  // a: current tuple workspace
  var a=new int[n];
  // j: target sum value
  int j=0;
  // recursive function that works on slot k
  void g(int k){

    // tuple is not fully generated,
    if(k<n)

      // try all values from (0,j]
      for(int i=0;i++<j;
        // recursive call - generates all
        // values from (0,j] in the next slot
        g(k+1)
      )
        // update the kth slot
        a[k]=i;

    // tuple is fully generated, however
    // we should only display if the sum
    // is equal to the target sum. tuples
    // are generated many times, this
    // let's us enforce that they are only
    // displayed once.
    else if(a.Sum()==j)
      WriteLine(string.Join(' ',a));
  }
  // increment the high value forever
  // while continually starting the
  // recursive function at slot 0
  for(;;j++)
    g(0);
}

Jöle , 10 (9) bayt

^{9 Tutarlı olmayan ayırma kullanarak çıktı verebilirsek (sordum) - kaldırılması €.}

‘ɼṗ³ċƇ®Ṅ€ß

Çevrimiçi deneyin!

Nasıl?

‘ɼṗ³ċƇ®Ṅ€ß - Main Link: some argument, x (initially equal to n, but unused)
 ɼ         - recall v from the register (initially 0), then set register to, and yield, f(v)
‘          -   f = increment
           - (i.e. v=v+1)
   ³       - program's third command line argument (1st program argument) = n
  ṗ        - (implicit range of [1..v]) Cartesian power (n)
           - (i.e. all tuples of length n with items in [1..v])
     Ƈ     - filter keep those for which:
    ċ      -   count
      ®    -   recall from register
           - (i.e. keep only those containing v)
       Ṅ€  - print €ach
         ß - call this Link with the same arity
           - (i.e. call Main(theFilteredList), again the argument is not actually used)

05AB1E , 15 11 bayt

[¼¾LIãvy¾å—

-4 baytlık bir bağlantı noktası oluşturarak @Maltysen'in Pyth cevabını içeren.

Çevrimiçi deneyin.

Açıklama:

[             # Start an infinite loop:
 ¼            #  Increase the counter_variable by 1 (0 by default)
  ¾L          #  Create a list in the range [1, counter_variable]
    Iã        #  Take the cartesian power of this list with the input
      v       #  Loop over each list `y` in this list of lists:
       y¾å    #   If list `y` contains the counter_variable:
          —   #    Print list `y` with trailing newline

MATL , 16 bayt

`@:GZ^t!Xs@=Y)DT

Tupl'lar toplamı artırarak, belirli bir miktar içinde sözlükbilimsel olarak sıralanırlar.

Çevrimiçi deneyin!

Python 2 , 126 112 106 101 100 83 bayt

n=input()
i=1
while 1:
 b=map(len,bin(i)[3:].split('0'));i+=1
 if len(b)==n:print b

Çevrimiçi deneyin!

Mypetlion için 5 bayt thx ; ArBo'nun kartal gözünden 1 bayt ; Xnor'dan 17 bayt !

Sıralı bölümleri Construct miçine niçin, kutuları m = 0,1,2,3,...ile ikili sayılar için seçerek n-1 0s ve m 1s.

C # (.NET Core) , 608 570 567 bayt

using C=System.Console;using L=System.Collections.Generic.List<int[]>;class A{static void Main(){L x=new L(),y=new L(),z=new L();int i=int.Parse(C.ReadLine()),j=0,k,l,m;x.Add(new int[i]);while(i>0){j++;for(m=0;m++<i;){foreach(var a in y)x.Add(a);y=new L();foreach(var a in x){for(k=0;k<i;){int[] t=new int[i];System.Array.Copy(a,t,i);t[k++]=j;var b=true;z.AddRange(x);z.AddRange(y);foreach(var c in z){for(l=0;l<i;l++)if(c[l]!=t[l])break;if(l==i)b=false;}if(b)y.Add(t);}}}}for(k=0;k<x.Count;k++){C.Write("[ ");for(l=0;l<i;l++)C.Write(x[k][l]+" ");C.WriteLine("]");}}}

Çevrimiçi deneyin!

aman tanrım ne yaptım (çok fazla döngü, yaptığım şey bu)

Yine de çalışması gerekir!

Baskı döngüsünü bir braketten geriye doğru hareket ettirirseniz, her döngüye girdiğinde size listeyi oluştururken gösterir. (Bunu yaparsanız her döngüyü ayırt etmek için yeni bir satır veya başka bir şey eklemenizi öneririz.)

Dürüst olmak gerekirse, çok zamanımı hiçbir diziler, == ait çeşitli davranışları oldukça-baskı ... dil ile savaşarak geçirdim edildi ...

Umarım bu sürüm okumak kolaydır.

using C=System.Console;
using L=System.Collections.Generic.List<int[]>;
class A{
    static void Main(){
        L x=new L(),y=new L(),z=new L();
        int i=int.Parse(C.ReadLine()),j=0,k,l,m;
        x.Add(new int[i]);
        while(i>0){
            j++;
            for(m=0;m++<i;){
                foreach(var a in y) x.Add(a);
                y=new L();
                foreach(var a in x){
                    for(k=0;k<i;){
                        int[] t=new int[i];
                        System.Array.Copy(a,t,i);
                        t[k++]=j;
                        var b=true;
                        z.AddRange(x);
                        z.AddRange(y);
                        foreach(var c in z){
                            for(l=0;l<i;l++) if(c[l]!=t[l])break;
                            if(l==i)b=false;
                        }
                        if(b)y.Add(t);
                    }
                }
            }
        }
        for(k=0;k<x.Count;k++){
            C.Write("[ ");
            for(l=0;l<i;l++)C.Write(x[k][l]+" ");
            C.WriteLine("]");
        }
    }
}

Perl 6 , 50 bayt

{grep $_,{S/.//.split(0)>>.chars}($++.base(2))xx*}

Çevrimiçi deneyin!

Tembel bir sonsuz liste döndüren adsız kod bloğu. Bu Chas Brown'un cevabıyla aynı stratejiyi kullanıyor .

Açıklama:

{grep $_,{S/.//.split(0)>>.chars}($++.base(2))xx*}
{                                                } # Anonymous code block
                                              xx*  # Repeat indefinitely
                                 ($++        )     # From the current index
                                     .base(2)      # Get the binary form
         {S/.//                 }   # Remove the first digit
               .split(0)            # And split by zeroes
                        >>.chars    # And get the length of each section
 grep   ,   # From this infinite list, filter:
      $_      # The groups with length the same as the input

VDM-SL , 51 bayt

g(i)==if i=0then{}else{[x]^y|x:nat,y in set g(i-1)}

Dizi birleştirme ile özyinelemeli küme anlayışı ..

TIO'da değil, bir programda çalıştırılabilir (nat türü için sınırları açarsanız veya sonlandırmazsanız):

functions 
g:nat->set of ?
g(i)==if i=0then{}else{[x]^y|x:nat,y in set g(i-1)}

Opsiyonel 0'ları cevabına dahil eder, aksi takdirde nat1'e bağlayan 52 byte

Wolfram Dili (Mathematica) , 131 bayt

While[0<1,If[a~FreeQ~#,Print@#]&/@(b=Table[Select[Range@t~Tuples~{s},Tr@#==k&],{k,t,t(s=#)}]~Flatten~1);a={a}~Join~b;t++]&
t=1
a={}

Çevrimiçi deneyin!

perl -M5.010 122 bayt

$n=shift;
$s.="for\$x$_(1..\$m){"for 1..$n;
$t.="\$x$_ "for 1..$n;
$u.='}'x$n;
eval"{\$m++;$s\$_=qq' $t';/ \$m /&&say$u;redo}"

Okunabilirlik uğruna bazı yeni satırlar eklendi (bayt sayımında sayılmaz)

Python 2 , 120 bayt

from random import*
m=n=input()
a=()
while 1:
 m+=len(a)==m**n;t=[randint(1,m)for _ in[1]*n]
 if(t in a)<1:a+=t,;print t

Çevrimiçi deneyin!

Diğer cevapların çoğundan biraz daha uzun, ama arkasındaki fikri sevdim.

Stax , 6 bayt

£ƒ$↔┬ï

Koş ve hata ayıkla

Giriş niçin prosedür kabaca

for i in [0..infinity]:
    get all the distinct n length arrays of positive integers that sum to i
    for each
        join with spaces
        implicitly output

JavaScript (V8) , 98 bayt

n=>{for(a=[],b=[j=1];;b.push(++j))(g=k=>k<n?b.map(i=>(a[k]=i)|g(k+1)):a.includes(j)&&print(a))(0)}

Çevrimiçi deneyin!

Yaşasın! Sonunda 100 altında aldım :) Temelde benim C # cevabımın bir liman .

// n: length of tuples to generate
n=>{
  // a: workspace for current tuple
  // b: range of numbers that grows
  //     - iteration 1: [1]
  //     - iteration 2: [1,2]
  //     - iteration 3: [1,2,3]
  // j: largest number in b
  for(a=[],b=[j=1];;b.push(++j))
    // g: recursive function to build tuples
    // k: index of slot for current recursive call
    (g=k=>
       // current slot less than the tuple size? 
       k<n?
         // tuple generation not complete
         // try all values in current slot and
         // recurse to the next slot
         b.map(i=>(a[k]=i)|g(k+1)):
         // tuple generation complete
         // print tuple if it contains the
         // current high value
         a.includes(j)&&print(a)
    // start recursive function at slot 0
    )(0)
}