입력 값이 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)... 

• 출력은 다른 규칙을 위반하지 않는 순서 일 수 있습니다.
• 프로그램은 영원히 실행되도록 이론적으로 모든 적용 가능한 튜플을 정확히 한 번만 작성하도록 작성되어야합니다.
  • 실제로 프로그램은 정수 유형의 한계에 도달하고 충돌합니다. 정수 유형 만 무제한 인 경우 프로그램 이 무한정 실행 되는 한 허용됩니다 .
  • 프로그램 만 오래 실행되도록 허용 된 경우 각 유효한 튜플은 유한 시간 내에 나열되어야합니다.
• 원하는 경우 출력에 자연수 외에 0이 포함될 수 있습니다.
• 튜플과 각 튜플 내부의 숫자가 명확하고 일관된 한 편의에 따라 프로그램의 출력 형식을 선택할 수 있습니다. 예를 들어 한 줄에 하나의 튜플입니다.
• 입력 (n)은 1에서 6까지의 정수입니다. 이 범위를 벗어난 입력에 대해서는 필수 동작이 정의되어 있지 않습니다.
• 코드 골프 규칙이 적용되며 가장 짧은 프로그램이 이깁니다.

샌드 박스 단계에서의 피드백에 대한 "Artemis Fowl"덕분입니다.

껍질 , 2 바이트

πN

온라인으로 사용해보십시오!

설명

N자연수의 무한한 목록입니다 [1,2,3,4,... π데카르트 힘입니다. 결과는 무한한 목록 목록입니다. 원하는 길이의 각 목록은 π그렇게 멋지 므로 정확히 한 번 발생 합니다. 입력과 출력은 암시 적입니다.

하스켈 , 62 바이트

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

온라인으로 사용해보십시오!

n!sn합계 인 모든 튜플을 생성합니다 s.

그러면 대답은 ([1..]>>=).(!)즉 \n -> [t | s<-[1..], t<-n!s].

정수 n를 무한 게으른 튜플 목록 (정수 목록)에 매핑하는 함수 입니다.

하스켈 , 50 바이트

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

온라인으로 사용해보십시오!

n합계로 정렬 된 튜플을 나열합니다 . mapM무거운 리프팅 n은 0에서 k까지의 모든 숫자의 튜플 을 생성합니다 . <$f트릭입니다 여기에 설명했다 .

하스켈 , 51 바이트

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

온라인으로 사용해보십시오!

각 튜플 의 첫 번째 숫자 를 가능한 모든 방식으로 그에 해당하는 두 개의 숫자로 분할하여 모든 n-1튜플을 모든 n튜플에 재귀 적으로 확장합니다 .an-1a-k,k

Pyth-9 바이트

골프를위한 @FryAmTheEggman에게 감사합니다

모든 x를 반복하고 [1..x] ^ n을 사용합니다. 이렇게하면 복제가 이루어 지므로 해당 x에 새로운 것, 즉 x가 들어있는 것만 유지합니다. 형식이 약간 이상하지만 1 바이트 이상으로 표준으로 만들 수 있습니다..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…으로 계산하고 목록이 합계의 순서대로 출력되도록합니다 (각각 가능한 제한된 양의 출력 후에 목록이 나타납니다). 두 번째 ≜는 목록의 요소가 서로 관련되는 방식을 지정하는 공식을 출력하는 대신 목록에 대한 모든 명백한 가능성을 계산하는 데 사용됩니다.

펄 6 , 37 바이트

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

온라인으로 사용해보십시오!

기본적으로 polymod모듈러스가 항상 입력보다 큽니다 (예 : 0.polymod (1,1,1), 1.polymod (2,2,2) 등). 필요한만큼 많은 항목으로 실행됩니다 . 범위. Perl6은 모듈로 무한대를 허용하지 않습니다 ...

Wolfram Language (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);}

온라인으로 사용해보십시오!

@ASCIIOnly 덕분에 -3 바이트!

// 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 의 Pyth 응답 포트를 생성하여 -4 바이트 .

온라인으로 사용해보십시오.

설명:

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

튜플은 합계를 증가시켜 정렬하며, 주어진 합계 내에서 사 전적으로 정렬됩니다.

온라인으로 사용해보십시오!

파이썬 (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

온라인으로 사용해보십시오!

mypetlion 까지 5 바이트 ; ArBo 의 독수리 눈에서 1 바이트 ; xnor 에서 17 바이트 !

의 정렬 된 파티션을 구축 m에 n대한, 빈 m = 0,1,2,3,...이진 번호를 선택하여 n-1 0s와 m 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("]");
        }
    }
}

펄 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 Language (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={}

온라인으로 사용해보십시오!

펄 -M5.010122 바이트

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

가독성을위한 몇 가지 줄 바꿈 추가 (바이트 수에 포함되지 않음)

파이썬 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

자바 스크립트 (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)
}