Viết chương trình, với n đầu vào , sẽ tạo ra tất cả các n-tup có thể sử dụng số tự nhiê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)... 

• Đầu ra có thể theo bất kỳ thứ tự nào không phá vỡ bất kỳ quy tắc nào khác.
• Chương trình phải được viết để chạy mãi mãi và liệt kê tất cả các bộ dữ liệu áp dụng chính xác một lần, theo lý thuyết.
  • Trong thực tế, chương trình của bạn sẽ đạt đến giới hạn và sự cố loại số nguyên của bạn. Điều này có thể chấp nhận được miễn là chương trình sẽ chạy dài vô tận nếu chỉ loại số nguyên của bạn là không giới hạn.
  • Mỗi bộ dữ liệu hợp lệ phải được liệt kê trong thời gian hữu hạn, nếu chỉ chương trình được phép chạy lâu như vậy.
• Đầu ra có thể, tùy chọn của bạn, bao gồm các số 0 ngoài các số tự nhiên.
• Bạn có thể chọn định dạng đầu ra của chương trình để thuận tiện, miễn là sự tách biệt giữa các bộ dữ liệu và số bên trong mỗi bộ dữ liệu là rõ ràng và nhất quán. (Ví dụ: một tuple trên mỗi dòng.)
• Đầu vào (n) là một số nguyên từ một đến sáu. Hành vi cần thiết không được xác định cho các đầu vào bên ngoài phạm vi này.
• Luật chơi golf áp dụng, chương trình ngắn nhất sẽ thắng.

Cảm ơn "Artemis Fowl" đã phản hồi trong giai đoạn hộp cát.

Husk , 2 byte

πN

Hãy thử trực tuyến!

Giải trình

Nlà danh sách vô hạn của số tự nhiên [1,2,3,4,... πlà sức mạnh của Cartesian. Kết quả là một danh sách vô tận của danh sách. Mỗi danh sách độ dài mong muốn xảy ra chính xác một lần vì πtuyệt vời như thế. Đầu vào và đầu ra là ẩn.

Haskell , 62 byte

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

Hãy thử trực tuyến!

n!stạo ra tất cả các n-tuples mà tổng hợp s.

Sau đó, câu trả lời là ([1..]>>=).(!), tức là \n -> [t | s<-[1..], t<-n!s].

Đây là một hàm ánh xạ một số nguyên nvào một danh sách các bộ dữ liệu lười biếng vô hạn (danh sách các số nguyên).

Haskell , 50 byte

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

Hãy thử trực tuyến!

Danh sách n-tuples được sắp xếp theo tổng. mapMthực hiện việc nâng vật nặng để tạo ra tất cả ncác số từ 0 đến k. Thủ <$fthuật được giải thích ở đây .

Haskell , 51 byte

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

Hãy thử trực tuyến!

Đệ quy kéo dài tất cả các n-1-tuple thành tất cả các n-tuple bằng cách chia số đầu tiên acủa mỗi n-1-tuple thành hai số a-k,ktổng hợp với nó, theo mọi cách có thể.

Pyth - 9 byte

Cảm ơn @FryAmTheEggman cho golf

Vòng lặp qua tất cả x và mất [1..x] ^ n. Điều này tạo ra các bản sao, vì vậy chỉ giữ những cái mới đối với x, aka chứa x trong chúng. Định dạng hơi lạ, nhưng nó có thể được tạo chuẩn với thêm một byte,.V1j}#b^Sb

.V1}#b^Sb

Hãy thử trực tuyến .

Brachylog (v2), 9 byte

~l.ℕᵐ+≜∧≜

Hãy thử trực tuyến!

Đây là một trình tạo vô hạn tạo ra tất cả các bộ dữ liệu có thể. Liên kết TIO có một tiêu đề sử dụng trình tạo để tạo 1000 phần tử và in chúng (nhưng trình tạo có thể tiếp tục vô thời hạn nếu tôi yêu cầu điều đó thay vào đó; số nguyên của Brachylog không bị ràng buộc).

Cảm giác như có một cách khó khăn hơn, nhưng có rất nhiều ràng buộc và đây là điều khó khăn nhất mà tôi có thể phù hợp với chúng trong một chương trình duy nhất.

Giải trình

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

Ngẫu nhiên, điều đó gây cho tôi sự thú vị khi cách giải thích của tôi về hai người ≜khác nhau, mặc dù họ làm điều tương tự theo quan điểm của Brachylog. Đầu tiên ≜là vị từ không điều kiện đầu tiên trong chương trình, do đó, nó đặt thứ tự kết quả; trong trường hợp này, nó tính toán tất cả các giá trị rõ ràng có thể có cho tổng của danh sách theo thứ tự 0, 1, 2, 3, và đang được sử dụng để đảm bảo rằng các danh sách được xuất theo thứ tự tổng của chúng (điều này đảm bảo rằng mỗi danh sách có thể danh sách xuất hiện sau một lượng đầu ra hữu hạn). Thứ hai ≜được sử dụng để tính toán tất cả các khả năng rõ ràng cho danh sách (thay vì xuất ra một công thức chỉ định cách các phần tử của danh sách liên quan với nhau).

Perl 6 , 37 byte

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

Hãy thử trực tuyến!

Về cơ bản chạy polymodvới càng nhiều mục cần thiết, trong đó modulo luôn lớn hơn đầu vào, tức là 0.polymod (1,1,1), 1.polymod (2,2,2), v.v ... Bằng cách đó, chữ số luôn nằm trong phạm vi. Perl6 sẽ không cho tôi modulo vô cùng ...

Ngôn ngữ Wolfram (Mathicala) , 62 byte

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

Hãy thử trực tuyến!

-3 byte với sự phân tách không nhất quán (xóa @#&)

Hãy thử trực tuyến!

C # (Trình biên dịch tương tác Visual C #) , 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);}

Hãy thử trực tuyến!

-3 byte nhờ @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?) Byte

^{9 nếu chúng ta có thể xuất bằng cách sử dụng phân tách không nhất quán (mà tôi đã hỏi về) - loại bỏ €.}

‘ɼṗ³ċƇ®Ṅ€ß

Hãy thử trực tuyến!

Làm sao?

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

[¼¾LIãvy¾å—

-4 byte bằng cách tạo ra một cổng của @Maltysen Pyth câu trả lời 's .

Hãy thử trực tuyến.

Giải trình:

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

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

Các bộ dữ liệu được sắp xếp bằng cách tăng tổng, và trong một khoản tiền nhất định, chúng được sắp xếp theo thứ tự từ vựng.

Hãy thử trực tuyến!

Python 2 , 126 112 106 101 100 83 byte

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

Hãy thử trực tuyến!

5 byte thx đến mypetlion ; 1 byte từ mắt đại bàng của ArBo ; 17 byte từ xnor !

Xây dựng các phân vùng theo thứ tự mvào các nthùng, m = 0,1,2,3,...bằng cách chọn các số nhị phân có n-1 0s và m 1s.

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

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

Hãy thử trực tuyến!

chúa ơi tôi đã làm gì (rất nhiều vòng lặp, đó là những gì tôi đã làm)

Nó nên hoạt động, mặc dù!

Nếu bạn di chuyển vòng lặp in trở lại một dấu ngoặc, nó sẽ hiển thị cho bạn danh sách khi nó được tạo, mỗi khi nó lặp. (Tôi khuyên bạn nên thêm một dòng mới hoặc một cái gì đó để phân biệt mỗi vòng lặp nếu bạn làm.)

Thành thật mà nói, rất nhiều thời gian của tôi đã dành để chiến đấu với ngôn ngữ ... không có mảng in ấn đẹp, các loại hành vi của == ...

Hy vọng phiên bản này dễ đọc hơn.

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 byte

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

Hãy thử trực tuyến!

Khối mã ẩn danh trả về một danh sách vô hạn lười biếng. Điều này sử dụng chiến lược tương tự như câu trả lời của Chas Brown .

Giải trình:

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

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

Hiểu tập đệ quy với nối chuỗi ..

Không phải trên TIO, bạn có thể chạy trong một chương trình (nếu bạn bật giới hạn cho loại nat hoặc nó sẽ không chấm dứt):

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

Bao gồm các số 0 tùy chọn trong câu trả lời nếu không nó sẽ là ràng buộc 52 byte trên nat1

Ngôn ngữ Wolfram (Mathicala) , 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={}

Hãy thử trực tuyến!

perl -M5.010 122 byte

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

Đã thêm một số dòng mới cho mục đích dễ đọc (không được tính vào số byte)

Con trăn 2 , 120 byte

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

Hãy thử trực tuyến!

Dài hơn một chút so với hầu hết các câu trả lời khác, nhưng tôi thích ý tưởng đằng sau nó.

Stax , 6 byte

£ƒ$↔┬ï

Chạy và gỡ lỗi nó

Đối với đầu vào n, thủ tục đại khái

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

Hãy thử trực tuyến!

Hoan hô! Cuối cùng đã nhận được nó dưới 100 :) Về cơ bản là một cổng của câu trả lời C # của tôi .

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