给定输入n编写程序，将使用自然数生成所有可能的n元组。

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

• 输出的顺序可以不违反任何其他规则。
• 从理论上讲，该程序必须永久运行并列出所有适用的元组一次。
  • 实际上，您的程序将达到整数类型的限制并崩溃。只要只有整数类型是无限的，程序就可以无限长地运行，这是可以接受的。
  • 如果只允许程序运行那么长时间，则必须在有限时间内列出每个有效的元组。
• 您可以选择输出，除了自然数外还包括零。
• 为了方便起见，您可以选择程序的输出格式，只要元组和每个元组内的数字之间的分隔清晰且一致即可。（例如，每行一个元组。）
• 输入（n）是1到6的整数。对于超出此范围的输入，未定义所需的行为。
• 适用代码高尔夫球规则，以最短的程序获胜。

感谢“ Artemis Fowl”在沙盒阶段的反馈。

外壳，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总和为的所有-tuple s。

那么答案是([1..]>>=).(!)，即\n -> [t | s<-[1..], t<-n!s]。

这是一个将整数映射n到无限懒惰的元组列表（整数列表）的函数。

Haskell，50个字节

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

在线尝试！

列出n按总和排序的元组。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]]

在线尝试！

通过以各种可能的方式将每个-tuple 的第一个数字分成两个求和的数字，以递归方式将所有n-1-tuple扩展为所有n-tuple 。an-1a-k,k

Pyth-9个字节

感谢@FryAmTheEggman参加高尔夫

遍历所有x，并取[1..x] ^ n。这将导致重复，因此仅保留x的新内容，也就是在其中包含x。格式有点怪异，但可以再加一个字节将其设置为标准格式，.V1j}#b^Sb

.V1}#b^Sb

在线尝试。

Brachylog（v2），9个字节

~l.ℕᵐ+≜∧≜

在线尝试！

这是一个无限生成器，它生成所有可能的元组。TIO链接有一个标头，该标头使用生成器生成1000个元素并打印（但是如果我要求生成器可以无限期继续； Brachylog的整数是无界的）。

感觉应该有一个更简单的方法，但是有很多限制，这是我可以将它们组合到单个程序中的最糟糕的条件。

说明

~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的角度来看做的完全一样，但我对两者的解释却有多么不同，这让我感到很有趣。第一个≜是程序中的第一个非确定性谓词，因此它设置结果的顺序。在这种情况下，它将以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＃交互式编译器），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);
}

果冻，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¾å—

通过创建@Maltysen端口来生成-4字节的Pyth答案。

在线尝试。

说明：

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

元组通过增加总和来排序，在给定的总和内，它们按字典顺序排序。

在线尝试！

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个字节到mypetlion ; 距离ArBo的鹰眼1个字节; 来自17个字节 xnor的！

通过选择带有s和s的二进制数，将的有序分区构造m为nbin 。m = 0,1,2,3,...n-1 0m 1

C＃（.NET核心），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 Brown的答案相同的策略。

说明：

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

在回答中包括可选的0，否则在nat1上将绑定52个字节

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