Wenn Sie ein Programm schreiben, das eine Eingabe von n erhält, werden alle möglichen n-Tupel unter Verwendung natürlicher Zahlen generiert.

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

• Die Ausgabe kann in einer beliebigen Reihenfolge erfolgen, die keine anderen Regeln verletzt.
• Das Programm muss so geschrieben sein, dass es für immer läuft und theoretisch alle anwendbaren Tupel genau einmal auflistet.
  • In Wirklichkeit wird Ihr Programm das Limit Ihres Integer-Typs erreichen und abstürzen. Dies ist akzeptabel , so lange das Programm würde unendlich lange laufen , wenn nur Ihr Integer - Typ war unbegrenzt.
  • Jedes gültige Tupel muss innerhalb einer begrenzten Zeit aufgelistet werden, wenn nur das Programm so lange ausgeführt werden darf.
• Die Ausgabe kann optional zusätzlich zu den natürlichen Zahlen auch Nullen enthalten.
• Sie können das Ausgabeformat Ihres Programms nach Belieben auswählen, solange die Trennung zwischen Tupeln und Zahlen in jedem Tupel klar und konsistent ist. (Zum Beispiel ein Tupel pro Zeile.)
• Die Eingabe (n) ist eine ganze Zahl von eins bis sechs. Das erforderliche Verhalten ist für Eingaben außerhalb dieses Bereichs nicht definiert.
• Es gelten die Code-Golf-Regeln, das kürzeste Programm gewinnt.

Vielen Dank an "Artemis Fowl" für das Feedback während der Sandbox-Phase.

Schale , 2 Bytes

πN

Probieren Sie es online!

Erläuterung

Nist die unendliche Liste natürlicher Zahlen [1,2,3,4,... πist kartesische Kraft. Ergebnis ist eine unendliche Liste von Listen. Jede Liste der gewünschten Länge kommt genau einmal vor, weil das πso cool ist. Eingabe und Ausgabe sind implizit.

Haskell , 62 Bytes

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

Probieren Sie es online!

n!sgeneriert alle n-tupel, die zusammengerechnet werden s.

Dann lautet die Antwort ([1..]>>=).(!), das heißt \n -> [t | s<-[1..], t<-n!s].

Dies ist eine Funktion, die eine Ganzzahl neiner unendlichen Liste fauler Tupel (Listen ganzer Zahlen) zuordnet.

Haskell , 50 Bytes

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

Probieren Sie es online!

Listet nTupel sortiert nach Summe auf. mapMtut das schwere Heben, um alle nTupel von Zahlen von 0 bis k zu erzeugen . Der <$fTrick wird hier erklärt .

Haskell , 51 Bytes

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

Probieren Sie es online!

n-1Spannt rekursiv alle -Tupel in alle n-Tupel, indem die erste Zahl ajedes n-1-Tupels a-k,kauf jede mögliche Weise in zwei Zahlen aufgeteilt wird , die sich daraus ergeben.

Pyth - 9 Bytes

Vielen Dank an @FryAmTheEggman für das Golfen

Durchläuft alle x und nimmt [1..x] ^ n. Dadurch werden Duplikate erstellt, sodass nur diejenigen erhalten bleiben, die für dieses x neu sind, also auch x enthalten. Die Formatierung ist etwas seltsam, kann aber mit einem weiteren Byte zum Standard gemacht werden..V1j}#b^Sb

.V1}#b^Sb

Probieren Sie es online aus .

Brachylog (v2), 9 Bytes

~l.ℕᵐ+≜∧≜

Probieren Sie es online!

Dies ist ein unendlicher Generator, der alle möglichen Tupel generiert. Der TIO-Link hat einen Header, der den Generator verwendet, um 1000 Elemente zu generieren und diese zu drucken (aber der Generator könnte auf unbestimmte Zeit fortgesetzt werden, wenn ich stattdessen danach frage; Brachylogs ganze Zahlen sind unbegrenzt).

Es fühlt sich so an, als ob es einen engeren Weg geben sollte, aber es gibt eine Menge Einschränkungen und dies ist der engere Weg, den ich für ein einziges Programm finden kann.

Erläuterung

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

Im Übrigen finde ich es interessant, wie unterschiedlich meine Erklärungen der beiden ≜sind, obwohl sie aus Brachylogs Sicht genau dasselbe tun. Das erste ≜ist das erste nicht deterministische Prädikat im Programm, daher legt es die Reihenfolge der Ergebnisse fest. In diesem Fall berechnet es alle möglichen expliziten Werte für die Summe der Liste in der Reihenfolge 0, 1, 2, 3 ... und wird verwendet, um sicherzustellen, dass die Listen in der Reihenfolge ihrer Summe ausgegeben werden (dies stellt sicher, dass jedes möglich ist Liste erscheint nach einer begrenzten Anzahl von Ausgaben). Die zweite ≜Methode berechnet alle expliziten Möglichkeiten für die Liste (anstatt eine Formel auszugeben, die angibt, wie sich die Elemente der Liste zueinander verhalten).

Perl 6 , 37 Bytes

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

Probieren Sie es online!

polymodLäuft im Wesentlichen mit so vielen Einträgen wie nötig, wobei das Modulo immer größer als der Eingang ist, dh 0.polymod (1,1,1), 1.polymod (2,2,2) usw. Auf diese Weise befindet sich die Ziffer immer innerhalb die Reichweite. Perl6 lässt mich nicht unendlich Modulo ...

Wolfram Language (Mathematica) , 62 Byte

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

Probieren Sie es online!

-3 Bytes mit inkonsistenter Trennung (löschen @#&)

Probieren Sie es online!

C # (Visual C # Interactive Compiler) , 148 Byte

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

Probieren Sie es online!

-3 Bytes dank @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?) Bytes

^{9 wenn wir mit einer nicht konsistenten Trennung ausgeben dürfen (über die ich nachgefragt habe) - Entfernen der €.}

‘ɼṗ³ċƇ®Ṅ€ß

Probieren Sie es online!

Wie?

‘ɼṗ³ċƇ®Ṅ€ß - 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 Bytes

[¼¾LIãvy¾å—

-4 Bytes durch Erstellen eines Ports von @Maltysens Pyth-Antwort .

Probieren Sie es online aus.

Erläuterung:

[             # 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 Bytes

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

Tupel werden nach zunehmender Summe geordnet und innerhalb einer gegebenen Summe lexikographisch geordnet.

Probieren Sie es online!

Python 2 , 126 112 106 101 100 83 Bytes

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

Probieren Sie es online!

5 bytes thx zu mypetlion ; 1 Byte vom Adlerauge von ArBo ; 17 Bytes von xnor !

Konstruieren Sie die geordneten Partitionen von min nBins, m = 0,1,2,3,...indem Sie mit n-1 0s und m 1s Binärzahlen auswählen .

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

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

Probieren Sie es online!

Mein Gott, was habe ich getan (so viele Loops, das habe ich getan)

Es sollte aber funktionieren!

Wenn Sie die Druckschleife um eine Klammer nach hinten verschieben, wird die Liste bei jeder Schleife angezeigt. (Ich empfehle, eine neue Zeile oder etwas hinzuzufügen, um jede Schleife zu unterscheiden, wenn Sie dies tun.)

Ehrlich gesagt, ich habe viel Zeit damit verbracht, mit der Sprache zu kämpfen ... keine hübschen Arrays, verschiedene Verhaltensweisen von == ...

Hoffentlich ist diese Version leichter zu lesen.

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 Bytes

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

Probieren Sie es online!

Anonymer Codeblock, der eine faule unendliche Liste zurückgibt. Dies verwendet dieselbe Strategie wie die Antwort von Chas Brown .

Erläuterung:

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

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

Rekursives Mengenverständnis mit Sequenzverkettung.

Nicht auf TIO können Sie in einem Programm ausgeführt werden (wenn Sie die Grenzwerte für den nat-Typ aktivieren oder das Programm nicht beendet wird):

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

Schließt die optionalen Nullen in die Antwort ein, andernfalls wären es 52 Bytes, die an nat1 binden

Wolfram Language (Mathematica) , 131 Byte

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

Probieren Sie es online!

Perl -M5.010 122 Bytes

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

Aus Gründen der Lesbarkeit wurden einige neue Zeilen hinzugefügt (nicht in der Byteanzahl enthalten)

Python 2 , 120 Bytes

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

Probieren Sie es online!

Ein bisschen länger als die meisten anderen Antworten, aber mir hat die Idee dahinter gefallen.

Stax , 6 Bytes

£ƒ$↔┬ï

Führen Sie es aus und debuggen Sie es

Für die Eingabe nist das Verfahren grob

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 Byte

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

Probieren Sie es online!

Hurra! Endlich unter 100 :) Grundsätzlich ein Port meiner C # Antwort .

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