주어진 양의 정수로 정렬 된 모든 파티션 (구성 (combinatorics))을 나열해야합니다 n. 합계가 에서 1까지 n인 숫자의 목록입니다 n. 예를 들어 input이 주어지면 n = 4결과는 다음과 같아야합니다.

4
1, 3
3, 1
2, 2
2, 1, 1
1, 2, 1
1, 1, 2
1, 1, 1, 1

결과는 어떤 순서로든 가능하지만 각 주문 파티션을 한 번 포함해야합니다. 이 수단에 대한 것으로 n = 4, [1, 1, 2], [1, 2, 1]그리고 [2, 1, 1]모든 결과의 일부 여야합니다.

이것을 달성하는 내 자신의 JavaScript 코드는 다음과 같습니다.

function range(n) {
    for (var range = [], i = 0; i < n; range.push(++i));
    return range;
}

function composition(n) {
    return n < 1 ? [[]] : range(n).map(function(i) {
        return composition(n - i).map(function(j) {
            return [i].concat(j);
        });
    }).reduce(function(a, b) {
        return a.concat(b);
    });
}

Golfed, ES6 ( 169 167 119 109 105 89 85 바이트 )

n=>n?[].concat(...[...Array(n)].map((x,i)=>i+1).map(b=>m(n-b).map(a=>[b,...a]))):[[]]

Pyth, 7 6 바이트

7 바이트 솔루션 :

Pyth에는 정수 파티션이 내장 ./되어 있으므로 7 바이트 중 5 바이트가 순서를 갖습니다 .

{s.pM./

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

설명:

     ./  Integer partition (sorted by default)
  .pM    get all the orderings of each of the partitions as a nested list of lists of orderings
 s       Flatten by one layer
{        Remove duplicates

6 바이트 솔루션 :

목록이 있으면 ./주문으로 계산합니다. 남아있는 것은리스트 번호를 다시 만드는 것입니다.

lMM./m

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

설명:

     m  Get lists by gathering a list of [0, 1,...input] (I could use U as well)

   ./   Partition with orderings
 MM     Map an operation across each of the orderings lists of elements
l       where that operation is the length of the sublists

하스켈, 37 바이트

f 0=[[]]
f n=[a:x|a<-[1..n],x<-f$n-a]

xnor는 2 바이트를 절약했습니다.

파이썬, 56 바이트

f=lambda n:[x+[n-i]for i in range(n)for x in f(i)]or[[]]

재귀 솔루션 :의 정렬 된 파티션은 n어떤 이하의 파티션이다 i와 0<=i<n나머지 다음에, n-i마지막 요소로. 기본 경우 n=0빈 파티션 만 있습니다.

파이썬 2, 61 바이트

f=lambda n,s='1,':1/n*[eval(s)]or f(n-1,'1+'+s)+f(n-1,'1,'+s)

이것은 가장 짧지는 않지만 너무 이상하기 때문에 방법을 정말로 좋아합니다.

다음과 2**(n-1)같이 문자열을 재귀 적으로 생성하고 평가합니다

1+1+1+1,
1,1+1+1,
1+1,1+1,
1,1,1+1,
1+1+1,1,
1,1+1,1,
1+1,1,1,
1,1,1,1,

에 대한 n=4. 이 문자열은 모든 파티션을 나타내는 튜플로 평가됩니다. 두 개의 1 사이 +에는 하나의 숫자로 결합 된이거나 ,인접한 섹션을 분할 하는 입니다.

자바 스크립트 (Firefox 30-57), 63 바이트

f=n=>n?[for(i of Array(n).keys())for(a of f(i))[n-i,...a]]:[[]]

Mathematica, 40 바이트

Join@@Permutations/@IntegerPartitions@#&

정수 파티션에 내장 된 Mathematica는 모든 정렬 된 파티션을 제공하지 않으므로 각 파티션의 가능한 모든 순열을 생성 한 다음 결과를 평탄화해야합니다.

CJam , 17 14 바이트

ri"X)"m*{~]p}/

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

설명

나는 내가 말한 알고 데카르트의 제품을 사용하는 것이 이상이라고하지만, 좀 더 효율적으로 사용하는 방법을 찾는 결국. 두 가지 접근 방식이 모두 흥미 롭다고 생각하므로 별도의 게시물에 넣습니다.

이것은 여전히 현재 파티션에 na 1를 추가 하거나 현재 파티션의 마지막 요소를 증가시키는 시간을 선택할 수 있다는 생각에 기반 합니다. 이 솔루션에서는 이러한 다양한 선택에 해당하는 2 ^{개의 n-1} 개의 서로 다른 프로그램을 생성하여이 작업을 수행 합니다.

ri      e# Read input and convert to integer N.
        e# Decrement.
"X)"m*  e# Get all strings of length N which consist of 'X' and ')'. If
        e# we treat these strings as CJam code then 'X' pushes a 1 and ')'
        e# increments the top of the stack.
        e# Note that some of these strings will begin with an increment that
        e# doesn't have anything on the stack to work with. This will result in
        e# an error and terminate the program. Luckily, the programs are ordered
        e# such that all programs starting with 'X' are first in the list, so
        e# we get to print all the 2^(N-1) permutations before erroring out.
{       e# For each of these programs (well for the first half of them)...
  ~     e#   Evaluate the string as CJam code. This leaves the partition as
        e#   individual integers on the stack.
  ]p    e#   Wrap the stack in a list and pretty-print it.
}/

젤리 , 7 6 바이트

@Dennis 덕분에 -1 바이트 ( ḅ1각각에 대한 합계가 아닌 단항 에서 변환 S€€)

1ẋŒṖḅ1

TryItOnline

방법?

1ẋŒṖḅ1 - Main link: n          e.g. 4
1ẋ     - repeat 1 n times          [1,1,1,1]
  ŒṖ   - partitions of a list     [[[1],[1],[1],[1]], [[1],[1],[1,1]], [[1],[1,1],[1]],
                                   [[1],[1,1,1]],     [[1,1],[1],[1]], [[1,1],[1,1]],
                                   [[1,1,1],[1]],     [[1,1,1,1]]]
    ḅ1 - from base 1 (vectorises)  [[1,1,1,1],        [1,1,2],         [1,2,1],
                                   [1,3],             [2,1,1],         [2,2],
                                   [3,1],             [4]]

순수한 배쉬, 51

이것은 원하는 결과를 얻기 위해 여러 레벨의 bash 확장을 사용하는 @xnor의 훌륭한 답변 포트입니다 .

a=$[10**($1-1)]
eval echo \$[${a//0/{+,']\ $[}1'}],

이데온

• 첫 번째 줄은 단순히 다음에 0을 $a포함 하는 변수를 만들기위한 산술 확장 입니다.1n-1
• 첫 번째 확장 ${a//0/{+,']\ $[}1'}은 각각 0을 $a문자열의 복사본으로 대체 합니다 {+,']\ $[}1'. 따라서 n = 4 우리는 문자열을 얻는다1{+,']\ $[}1'{+,']\ $[}1'{+,']\ $[}1'
• 이는하게 앞에와 있습니다 $[와라는 접미어와 ],에주고$[1{+,']\ $[}1'{+,']\ $[}1'{+,']\ $[}1]
• 이것은 확장 괄호 확장입니다 $[1+1+1+1], $[1+1+1] 1, $[1+1] $[1+1], $[1+1] 1 1,...
• 이것은 필요한 결과를 제공하기 위해 산술적으로 확장됩니다.

따옴표, 백 슬래시 이스케이프를주의해서 사용 eval하고 확장이 올바른 순서로 수행되도록합니다.

루비, 61 바이트

f=->n{n<1?[[]]:(1..n).map{|i|f[n-i].map{|x|x<<i}}.flatten(1)}

언 골프

f=->n{
  n < 1 ?
    [[]]
  :
    (1..n).map { |i|
      f[n-i].map { |x|
        x << i
      }
    }.flatten(1)
}

용법

p f[4]
# => [[1, 1, 1, 1], [1, 1, 2], [1, 2, 1], [1, 3], [2, 1, 1], [2, 2], [3, 1], [4]]

Brachylog , 20 바이트

~lL#++?,L:=f:{:0x}ad

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

설명

이것은 선언적 언어가 잘 될 것이라고 생각하는 상황이지만 +제약 조건을 올바르게 전파하는 합산 술어를 오버로드 하고 까다롭게 작성하기 때문에 그렇지 않습니다.

~lL                     L is a list of length Input
  L#+                   L is a list of non-negative integers
  L  +?,                The sum of the elements of L results in the Input
        L:=f            Find all values for the elements of L which satisfy those constraints
            :{:0x}a     Remove all 0s from each sublist of the result of Findall
                   d    Remove all duplicate sublists

CJam , 19 바이트

Lari{_1af.+1@f+|}*p

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

설명

CJam에는 정수 파티션을위한 유용한 조합 기능이 내장되어 있지 않습니다. 이 작업을 수동으로 수행하겠습니다. 정수 의 정렬 된 모든 파티션 을 찾으려면 파티션 n목록을보고 n구분 기호를 삽입하는 가능한 모든 방법을 고려할 수 있습니다. 그런 다음 1각 섹션 에서 s를 합산합니다 . 예 n = 3:

1 1 1 => 3
1 1|1 => 2|1
1|1 1 => 1|2
1|1|1 => 1|1|1

Cartesian 제품을 사용하여 이러한 구분 기호를 모두 생성하려고 시도했지만 결국 21 바이트로 끝났습니다. 대신 전원 세트를 생성 하는 이 오래된 기술 로 돌아갔습니다 (이것은 Dennis의 오래된 답변을 기반으로하지만 지금은 찾을 수 없습니다). 아이디어는 이것입니다 : 모든 파티션을 생성하기 위해 빈 목록에서 시작할 수 있습니다. 그런 다음 n이진 결정을 내릴 수 있습니다 1. 위의 예제에서 구분 기호에 해당하거나 목록의 마지막 값을 늘리십시오 (구분자가없는 것). 모든 파티션을 생성하려면 각 단계에서 두 작업을 모두 수행하고 다음 단계에서 가능한 모든 출력을 유지하십시오. CJam에서는 첫 번째 요소를 앞에 추가하고 늘리는 것이 더 짧지 만 원리는 동일하게 유지됩니다.

La       e# Push [[]] onto the stack. The outer list will be the list of
         e# all possible partitions at the current iteration, and we initialise
         e# it to one empty partition (basically all partitions of 0).
ri       e# Read input and convert to integer N.
{        e# Repeat this N times...
  _      e#   Duplicate the list of partitions of i-1.
  1af.+  e#   Increment the first element in each of these. This is done
         e#   by performing a pairwise addition between the partition and [1].
         e#   There is the catch that in the first iteration this will turn
         e#   the empty array into [1], so it's equivalent to the next step.
  1@f+   e#   Pull up the other copy of the list of partitions of i-1 and
         e#   prepend a 1 to each of them.
  |      e#   Set union. This gets rid of the duplicate result from the first
         e#   iteration (in all other iterations this is equivalent to concatenating
         e#   the two lists).
         e#   Voilà, a list of all partitions of i.
}*
p        e# Pretty-print the result.

T-SQL, 203 바이트

골프 :

USE master
DECLARE @ INT=12

;WITH z as( SELECT top(@)cast(number+1as varchar(max))a FROM spt_values WHERE'P'=type),c as(SELECT a*1a,a b FROM z UNION ALL SELECT c.a+z.a,b+','+z.a FROM c,z WHERE c.a+z.a*1<=@)SELECT b FROM c WHERE a=@

언 골프 드 :

USE master --needed to make sure it is executed from the correct database
DECLARE @ INT=12

;WITH z as
(
  SELECT top(@)cast(number+1as varchar(max))a
  FROM spt_values
  WHERE'P'=type
),c as
(
  SELECT a*1a,a b
  FROM z
  UNION ALL
  SELECT c.a+z.a,b+','+z.a
  FROM c,z
  WHERE c.a+z.a*1<=@
)
SELECT b 
FROM c
WHERE a=@

깡깡이

Mathematica 10.0, 44 바이트

파티션 관련 내장을 사용하지 않는 시도입니다. 크기가 k 인 각 정렬 된 파티션에서 k + 1 의 두 개의 후속 파티션 이 생성됩니다. 하나는 1을 추가하고 다른 하나는 첫 번째 값을 증가시켜 생성됩니다.

Nest[##&[{1,##},{#+1,##2}]&@@@#&,{{1}},#-1]&

더 재미 있지만 슬프게도 같은 아이디어를 구현하는 데 2 ​​바이트 더 길다.

#@{1}&/@Tuples[Prepend[1]@*MapAt[#+1&,1],#-1]&

05AB1E , 14 12 바이트

Adnan 덕분에 2 바이트 절약

>G¹LNãvyO¹Q—

설명

>G              # for N in range(1..input)
  ¹L            # range(1, input)
    Nã          # cartesian product with N (all combinations of length N)
      v         # for each resulting list
       yO¹Q—    # if it's sum equals the input print it

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

해당 솔루션은 2sable 에서 2 바이트 더 짧습니다 . .

2sable , 10 바이트

>GLNãvyOQ—

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

하스켈, 41 바이트

f 1=[[1]]
f n=do a:b<-f$n-1;[1:a:b,a+1:b]

가장 짧은 Haskell 솔루션은 아니지만 [..]범위를 사용하지 않는 것이 좋습니다 . 대신, 시작시 새 1 또는 첫 번째 값이 더 높은 n파티션으로 파티션을 재귀 적으로 계산합니다 n-1. 이것은 왜 2^(n-1)그것들 이 있는지 명시 적으로 만듭니다 .

수학, 53 바이트

내장 IntegerPartitions기능 을 사용하는 Martin Ender의 답변을 능가하지 마십시오 (내장에는 완전히 괜찮습니다). (너무 늦기 전에는 보지 못했던 feersum의 대답을 이기지 못했습니다.) 그러나 골프 재귀 기능을 연습하고 싶었습니다.

If[#<1,{{}},Join@@Table[#~Append~j&/@#0[#-j],{j,#}]]&

가능한 모든 최종 숫자를 생성 j한 다음 입력 #-j위치 를 호출 하여 모든 컴포지션을 재귀 적으로 생성합니다 #.

레티 나 , 32 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

.+
$*
+%1`1
!$'¶$`,!
!+
$.&
A`^,

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

설명

이것은 내 CJam 답변 과 유사하게 작동합니다 . 우리는 목록 N을 살펴보고 각 위치에서 이진 결정의 두 가지 지점을 취합니다 .a) 마지막 값을 늘리거나 b) 1에서 새 값을 시작합니다.

스테이지 1

.+
$*

입력을 단항으로 변환하십시오.

2 단계

+%1`1
!$'¶$`,!

는 +출력이 변화 멈출 때까지 루프에서이 단계를 실행하는 망막을 말한다. 는 %그 이후 다시 함께 그들을 무대를 적용하기 전에 라인에 입력을 분할에 가입하도록 알려줍니다. %후 를 넣어서+ 놓으면 Retina는 각 반복 후에 분할되고 다시 결합됩니다. 스테이지를 한 번 반복하면 내가 언급 한 결정 중 하나를 만들어 현재 파티션 세트를 분기합니다.

어떻게 실제로 작동하는 것은이 일치한다는 것이다 1(그러나 첫 번째에 의해 지시 된 바와 같이 하나 1와 역 따옴표 앞), 및을 대체하여 !나머지 다음에 (우리가 우리의 출력의 단항 자리로 사용할 수 있습니다) 1들 이 행에서 (마지막 값이 증가합니다). 그런 다음 다른 줄 ( ¶)에서 현재 줄의 접두사를 인쇄하고 그 뒤에 ,!구분 기호를 삽입 한 다음에서 다음 값을 시작합니다 1.

3 단계

!+
$.&

이것은 런을 !길이로 바꾸어 10 진수 정수 로 변환합니다 .

4 단계

A`^,

마지막으로, 우리는 우리가 원하는 것보다 두 배 많은 라인을 생성했으며 그 중 절반은 ,(분할 후 아무것도 분할하지 않았음에도 불구하고 처음에 분할 결정을 한 지점)으로 시작합니다. 따라서 우리는로 시작하는 모든 줄을 버립니다 ,.

펄, 44 바이트

에 +3 포함 -n(코드 사용 $'및 명령 행 $0으로 실행할 수 없음 -e)

STDIN에서 파티션 번호를 지정하십시오.

partitions.pl <<< 4

partitions.pl

#!/usr/bin/perl -n
$_=$&-$_.",$_$'",do$0for/\d+/..$&-1;print

줄 끝에 여분의 공백과 추가 줄 바꿈이 신경 쓰지 않으면이 42 바이트 솔루션도 작동합니다 (으로 실행 perl -M5.010 partitions.pl).

#!/usr/bin/perl -n
$_=$`-$_." $_ $'",do$0for/\s/..$_-1;say

줄리아, 113 바이트

f(N)=unique(reduce(vcat,(map(x->[permutations(x)...],[vcat([1 for _=i+1:N],sum([1 for _=N-i:N-1])) for i=1:N]))))

비 재귀 솔루션

설명 :

1. [vcat([1 for _=i+1:N],sum([1 for _=N-i:N-1])) for i=1:N] 순열이 솔루션과 닮은 N으로 요약되는 목록 집합을 작성합니다 (예 : N = 4 : [[1,1,1,1], [1,1,2], [1,3], [4) ]])
2. map(x->[permutations(x)...],) 모든 순열 계산
3. reduce(vcat,) 그것들을 목록의 목록으로 결합
4. unique() 중복 필터

MATL , 15 바이트

:"G:@Z^t!XsG=Y)

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

설명

입력 n이 주어지면 지수가 k에서 1까지 증가하는 데카르트 힘을 계산합니다 n. 각 지수 k에 대해 입력과 동일한 합을 갖는 튜플을 선택합니다.

:       % Take input n implicitly and push range [1 2 ... n]
"       % For each k in that range
  G:    %   Push [1 2 ... n] again
  @     %   Push k
  Z^    %   Cartesian power. Gives 2D array, say A, with each k-tuple in a row.
  t     %   Duplicate
  !     %   Transpose
  Xs    %   Sum of each column. Gives a row vector
  G=    %   True for entries that equal the input
  Y)    %   Use as logical vector into the rows of array A
        % End implicitly
        % Display stack implicitly

루아 214 203 182 바이트

function g(m, l, n,c)for i=1,m do if i+n < m then l[#l+1]=i;g(m,l,n+i,c+1)elseif i+n == m then l[#l+1]=i;print(unpack(l))end end for k=c,#l do l[k]=nil end end g(io.read()*1,{},0,0)

몽골어 버전.

function g(m, l, n,c)
    for i=1,m do 
        if i+n < m then 
            l[#l+1]=i
            g(m,l,n+i,c+1)
        elseif i+n == m then 
            l[#l+1]=i
            print(unpack(l))
        end 
    end 
    for k=c,#l do 
        l[k]=nil 
    end 
end 
g(io.read()*1,{},0,0)

표백 공백을 찾았고 11 바이트를 안전하게하기 위해 불필요한 변수를 제거했습니다. 결과적으로 table.insert ()는 바이트 비효율적입니다.

PHP, 125 바이트

for($i=$n=$argv[1];$i<=str_repeat(1,$n);$i++)if(array_sum($a=str_split($i))==$n&!strpos($i,"0"))$r[]=$a;echo json_encode($r);

출력 print_r($r);대신 -4 바이트echo json_encode($r);

250 바이트의 재귀 솔루션

function f($n){global$a;foreach($a as$x)foreach(range(1,$n)as$y)$a[]=array_merge((array)$x,[$y]);if(--$n)f($n);}$a=range(1,$w=$argv[1]);f($w-1);foreach($a as$z)if(array_sum((array)$z)==$w)$c[join("-",(array)$z)]=$z;echo json_encode(array_values($c));

프롤로그, 81 바이트 + 6 바이트 호출

L*L.
[H|T]*L:-H>1,M is H-1,[M,1|T]*L.
[H,K|T]*L:-H>1,M is H-1,N is K+1,[M,N|T]*L.

온라인으로 사용해보십시오!
로 전화하여 모든 솔루션이 제시 될 때까지 [4]*L.반복하십시오 ;.

또는 반복해서 누르는 ;것이 좋지 않은 경우 (또는 바이트 수에 추가해야하는 경우) 호출 bagof(L,[4]*L,M).하면 호출에 17 바이트가 추가됩니다.

J , 30 26 바이트

#&1<@(+/;.1)~2#:@(+i.)@^<:

2 ⁿ 의 이진 값을 사용하여 단항 n 목록을 분할하여 작동합니다 .

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

설명

#&1<@(+/;.1)~2#:@(+i.)@^<:  Input: n
                        <:  Decrement n
             2         ^    Compute 2^(n-1)
                 (   )@     Operate on that
                   i.         Make the range [0, 1, ..., 2^(n-1)-1]
                  +           Add 2^(n-1) to each in that range
              #:@           Convert each in that range to binary
#&1                         Make n copies of 1 (n in unary)
     (     )~               Operate over each row on RHS and unary n on LHS
        ;.1                   Chop unary n starting at each 1
      +/                        Reduce by addition on each chop
   <@                           Box the sums of each chop

실제로 17 16 바이트

이 답변은 부분적으로 Luis Mendo의 MATL answer을 기반으로 합니다. 골프 제안을 환영합니다. 온라인으로 사용해보십시오!

;╗R`╜R∙i`M`Σ╜=`░

언 골핑

         Implicit input n.
;╗       Duplicate n and save a copy of n to register 0.
R        Take the range of [1..n].
`...`M   Map the following function over the range. Variable k.
  ╛R       Push n from register 0 and take the range [1..n] again.
  ∙        Take the k-th Cartesian power of the range.
  i        Flatten that product.
`...`░   Push values of the previous map where the following function returns a truthy value.
          Variable L.
  Σ        Push sum(L).
  ╜        Push n from register 0.
  =        Check if sum(L) == n.
         Implicit return.

실제로 17 16 15 바이트

이것은 Martin Ender의 CJam 답변 (Cartesian 제품 이있는 것)의 흥미로운 포크이며 구현이 흥미 롭습니다. Martin의 문자열 중 하나가 증분으로 시작하면 오류로 인해 해당 문자열이 평가되지 않습니다. 실제로는 오류가 억제되고 문자열이 평가됩니다. 이것은 모든 k범위 의 구성을 제공합니다 [1..n].

여분의 구성을 제거하려고 시도하는 대신 각 줄의 시작 부분에 a n-1의 "1u"추가 된 데카르트 힘을 가져 왔습니다 "1". 이 트릭은의 작곡 만 제공합니다 n. 불행히도 그것은 Martin의 대답보다 길다.

골프 제안을 환영합니다. 온라인으로 사용해보십시오!

D"1u"∙`1@Σ£ƒk`M

언 골핑

         Implicit input n.
D        Decrement n.
"1u"∙    Take the (n-1)th Cartesian power of the string "1u".
          In Actually, 1 pushes 1 to the stack and u is increment.
`...`M   Map the following function over the Cartesian power. Variable s.
  1@       Push a 1 to be used later.
  Σ        Summing a list of chars joins the chars into one string.
  £ƒ       Turn s into a function and call it immediately on the 1 in the stack.
  k        Take the whole stack and wrap in a list. This is a composition of n.
         Implicit return.