เขียนโปรแกรมรับอินพุตnจะสร้าง n-tuples ที่เป็นไปได้ทั้งหมดโดยใช้ตัวเลขธรรมชาติ

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

• ผลลัพธ์อาจอยู่ในลำดับใด ๆ ที่ไม่ทำลายกฎอื่น ๆ
• โปรแกรมจะต้องเขียนให้ทำงานตลอดไปและทำรายการสิ่งอันดับที่ใช้ได้ทั้งหมดในทางทฤษฎี
  • ในความเป็นจริงโปรแกรมของคุณจะถึงขีด จำกัด และประเภทของจำนวนเต็ม นี่เป็นที่ยอมรับได้ตราบใดที่โปรแกรมจะรันนานอย่างไม่ จำกัด หากมีเพียงจำนวนเต็มชนิดไม่ จำกัด
  • tuple ที่ถูกต้องแต่ละรายการจะต้องแสดงรายการภายในระยะเวลาที่ จำกัด หากมีเพียงโปรแกรมที่ได้รับอนุญาตให้รันในระยะเวลานั้น
• เอาท์พุทอาจรวมถึงศูนย์นอกเหนือจากจำนวนธรรมชาติ
• คุณสามารถเลือกรูปแบบการแสดงผลของโปรแกรมเพื่อความสะดวกของคุณตราบใดที่การแยกระหว่างทูเปิลและตัวเลขภายในแต่ละทูเปิลนั้นชัดเจนและสอดคล้องกัน (ตัวอย่างเช่นหนึ่ง tuple ต่อบรรทัด)
• อินพุต (n) เป็นจำนวนเต็มตั้งแต่หนึ่งถึงหก พฤติกรรมที่ต้องการไม่ได้กำหนดไว้สำหรับอินพุตภายนอกช่วงนี้
• บังคับใช้กฎของรหัสกอล์ฟโปรแกรมที่สั้นที่สุดชนะ

ขอบคุณ "Artemis Fowl" สำหรับคำติชมในช่วงระยะเวลา Sandbox

Husk , 2 ไบต์

πN

ลองออนไลน์!

คำอธิบาย

N[1,2,3,4,..เป็นรายการที่ไม่มีที่สิ้นสุดของตัวเลขธรรมชาติ πคือพลังคาร์ทีเซียน ผลลัพธ์คือรายการที่ไม่สิ้นสุด แต่ละรายการของความยาวที่ต้องการเกิดขึ้นเพียงครั้งเดียวเพราะπเท่อย่างนั้น อินพุตและเอาต์พุตเป็นค่าปริยาย

Haskell , 62 ไบต์

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

ลองออนไลน์!

n!sสร้างทั้งหมดn-tuples sว่าผลรวมจะ

แล้วคำตอบคือคือ([1..]>>=).(!)\n -> [t | s<-[1..], t<-n!s]

นี่คือฟังก์ชั่นการทำแผนที่จำนวนเต็มnกับรายการขี้เกียจอนันต์ของ tuples (รายการจำนวนเต็ม)

Haskell , 50 ไบต์

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

ลองออนไลน์!

รายการn-tuples เรียงตามผลรวม mapMการยกของหนักเพื่อสร้างnตัวเลขทั้งหมดจาก 0 ถึง k <$fเคล็ดลับคือการอธิบายที่นี่

Haskell , 51 ไบต์

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

ลองออนไลน์!

ซ้ำยืดทั้งหมดn-1-tuples เป็น -tuples ทั้งหมดnโดยแยกหมายเลขแรกaของแต่ละn-1-tuple เป็นตัวเลขสองตัวa-k,kที่รวมเข้าด้วยกันในทุกวิถีทางที่เป็นไปได้

Pyth - 9 ไบต์

ขอบคุณ @FryAmTheEggman สำหรับการเล่นกอล์ฟ

วนซ้ำ x ทั้งหมดและรับ [1..x] ^ n สิ่งนี้ทำซ้ำดังนั้นควรเก็บเฉพาะสิ่งที่ใหม่กับ x นั้นเท่านั้น aka มี x อยู่ในนั้น การจัดรูปแบบนั้นแปลกเล็กน้อย แต่ก็สามารถสร้างมาตรฐานที่มีไบต์ได้อีกหนึ่งอัน.V1j}#b^Sb

.V1}#b^Sb

ลองมันออนไลน์

Brachylog (v2), 9 ไบต์

~l.ℕᵐ+≜∧≜

ลองออนไลน์!

นี่คือตัวสร้างที่ไม่มีที่สิ้นสุดที่สร้างสิ่งอันดับที่เป็นไปได้ทั้งหมด ลิงก์ TIO มีส่วนหัวที่ใช้ตัวสร้างเพื่อสร้างองค์ประกอบ 1000 รายการและพิมพ์ออกมา (แต่ตัวสร้างสามารถดำเนินต่อไปเรื่อย ๆ หากฉันขอสิ่งนั้นแทน;

รู้สึกเหมือนว่ามันควรจะเป็นทางที่แย่กว่า แต่ก็มีข้อ จำกัด มากมายและนี่คือสิ่งที่ยากที่สุดที่ฉันสามารถนำไปใช้ในโปรแกรมเดียว

คำอธิบาย

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

บังเอิญมันทำให้ฉันสนใจว่าคำอธิบายของฉันทั้งสอง≜นั้นแตกต่างกันอย่างไรแม้ว่าพวกเขาจะทำสิ่งเดียวกันจากมุมมองของ Brachylog ที่แรก≜ก็คือคำกริยา nondeterministic แรกในโปรแกรมดังนั้นมันจึงกำหนดลำดับของผลลัพธ์; ในกรณีนี้มันจะคำนวณค่าที่ชัดเจนที่เป็นไปได้ทั้งหมดสำหรับผลรวมของรายการตามลำดับ 0, 1, 2, 3 …และใช้เพื่อให้แน่ใจว่ารายการจะถูกส่งออกตามลำดับผลรวมของพวกเขา รายการจะปรากฏขึ้นหลังจากเอาท์พุทจำนวน จำกัด ) ที่สอง≜ใช้ในการคำนวณความเป็นไปได้ที่ชัดเจนสำหรับรายการ (แทนที่จะแสดงสูตรที่ระบุว่าองค์ประกอบของรายการเกี่ยวข้องกันอย่างไร)

Perl 6 , 37 ไบต์

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

ลองออนไลน์!

โดยพื้นฐานแล้วจะรันpolymodด้วยรายการจำนวนมากตามที่ต้องการโดยโมดูโลจะมีค่ามากกว่าอินพุตเช่น 0.polymod (1,1,1), 1.polymod (2,2,2) เป็นต้นวิธีนั้นตัวเลขจะอยู่ภายในเสมอ ช่วง Perl6 จะไม่ให้โมดูโลอินฟินิตี้ของฉัน ...

ภาษา Wolfram (Mathematica) , 62 ไบต์

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

ลองออนไลน์!

-3 ไบต์พร้อมกับการแยกที่ไม่สอดคล้องกัน (ลบ@#&)

ลองออนไลน์!

C # (Visual C # Interactive Compiler) , 148 ไบต์

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

ลองออนไลน์!

-3 ไบต์ขอบคุณ @ASCIIOnly!

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

Jelly , 10 (9?) ไบต์

^{9 ถ้าเราสามารถส่งออกโดยใช้การแยกที่ไม่สอดคล้องกัน (ซึ่งผมได้สอบถามเกี่ยวกับ) - €การกำจัดของ}

‘ɼṗ³ċƇ®Ṅ€ß

ลองออนไลน์!

อย่างไร?

‘ɼṗ³ċƇ®Ṅ€ß - 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 ไบต์

[¼¾LIãvy¾å—

-4 ไบต์โดยการสร้างพอร์ตของ@Maltysen 's คำตอบ

ลองออนไลน์

คำอธิบาย:

[             # 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 ไบต์

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

Tuples ได้รับคำสั่งจากผลรวมที่เพิ่มขึ้นและภายในผลรวมที่กำหนด

ลองออนไลน์!

Python 2 , 126 112 106 101 100 83 ไบต์

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

ลองออนไลน์!

5 ไบต์ thx เพื่อmypetlion ; 1 byte จากตาอินทรีแห่งArBo ; 17 ไบต์จากxnor !

สร้างพาร์ติชันที่เรียงลำดับแล้วของmลงในnถังขยะm = 0,1,2,3,...โดยเลือกหมายเลขไบนารีด้วยn-1 0s และm 1s

C # (.NET Core) , 608 570 567 ไบต์

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

ลองออนไลน์!

พระเจ้าของฉันฉันทำอะไรไปแล้ว (ลูปมากมายนั่นคือสิ่งที่ฉันทำ)

มันควรจะทำงานได้!

หากคุณย้ายลูปการพิมพ์กลับหนึ่งตัวยึดมันจะแสดงรายการตามที่สร้างขึ้นทุกครั้งที่ลูป (ฉันขอแนะนำให้เพิ่มบรรทัดใหม่หรือบางสิ่งบางอย่างเพื่อแยกความแตกต่างแต่ละวงถ้าคุณทำ)

สุจริตเวลาส่วนใหญ่ของฉันใช้เวลาในการต่อสู้กับภาษา ... ไม่มีอาร์เรย์สวยพิมพ์พฤติกรรมต่าง ๆ ของ == ...

หวังว่ารุ่นนี้อ่านง่ายกว่า

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 ไบต์

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

ลองออนไลน์!

การบล็อกโค้ดแบบไม่ระบุชื่อที่ส่งคืนรายการอนันต์แบบไม่ จำกัด นี้ใช้กลยุทธ์เดียวกับคำตอบ Chas ของบราวน์

คำอธิบาย:

{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 ไบต์

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

ชุดความเข้าใจแบบวนซ้ำพร้อมการเรียงลำดับแบบต่อเนื่อง ..

ไม่ได้อยู่ใน TIO คุณสามารถเรียกใช้ในโปรแกรม (หากคุณเปิดการ จำกัด ประเภท nat หรือไม่สิ้นสุด):

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

รวม 0s ที่เป็นทางเลือกในการตอบมิฉะนั้นจะเป็น 52 ไบต์ที่โยงกับ nat1

ภาษา Wolfram (Mathematica) , 131 ไบต์

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={}

ลองออนไลน์!

perl -M5.010 122 ไบต์

$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}"

เพิ่มบางบรรทัดใหม่เพื่อประโยชน์ในการอ่าน (ไม่นับเป็นจำนวนไบต์)

Python 2 , 120 ไบต์

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

ลองออนไลน์!

ค่อนข้างนานกว่าคำตอบอื่น ๆ ส่วนใหญ่ แต่ฉันชอบความคิดที่อยู่เบื้องหลัง

Stax , 6 ไบต์

£ƒ$↔┬ï

เรียกใช้และแก้ไขข้อบกพร่อง

สำหรับnขั้นตอนการป้อนข้อมูลคือคร่าวๆ

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 ไบต์

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

ลองออนไลน์!

ไชโย! สุดท้ายได้ภายใต้ 100 :) โดยทั่วไปพอร์ตของC # คำตอบของฉัน

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