課題は、特定の正の整数のすべての順序付けられたパーティション（組成（組み合わせ））をリストすること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

結果は任意の順序にすることができますが、順序付けされた各パーティションを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

Haskell、37バイト

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

xnorは2バイトを保存しました。

Python、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は、空のパーティションのみがあります。

Python 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。これらの文字列は、すべてのパーティションを表すタプルに評価されます。任意の2つの1の間には+、それらを1つの数字に結合するか、またはa ,が隣接するセクションを分割します。

JavaScript（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]]

Pure Bash、51

これは@xnorの素晴らしい回答の移植版であり、複数レベルのbash拡張を使用して目的の結果を実現します。

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

イデオン。

• 最初の行は、ゼロ$aが1続く変数を作成するための単純な算術展開n-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て、展開が正しい順序で行われるようにします。

Ruby、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には、整数パーティション用の便利な組み合わせが組み込まれていません。そのため、これを手動で行います。整数のすべての順序付けられたパーティションを見つけるには、n1のリストを見て、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

デカルト積を使用してこれらすべての区切り文字を生成しようとしましたが、21バイトになりました。代わりに、パワーセットを生成するためのこの古い手法に戻りました（これは、デニスの古い答えに基づいていますが、現時点では見つかりません）。アイデアは次のとおりです。すべてのパーティションを生成するには、空のリストから開始できます。その後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の 2つの後続パーティションが生成されます。1つは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—

オンラインでお試しください！

Haskell、41バイト

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

最短のHaskellソリューションではありませんが、[..]範囲を使用しないことが気に入っています。代わりに、最初の新しい1または最初の値が1より大きいnパーティションとして、パーティションを再帰的に計算n-1します。これにより2^(n-1)、それらが存在する理由が明確になります。

Mathematica、53バイト

組み込みIntegerPartitions関数を使用するMartin Enderの答えに勝るものはありません（組み込み関数は私にはまったく問題ありません）。（また、フェールサムの答えを打ち負かしましたが、それは遅すぎるまで見えませんでした。）しかし、ゴルフの再帰関数を練習したかったのです。

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

可能性のあるすべての最終番号jを生成し、入力が存在する#-j場所でそれ自体を呼び出すことにより、すべての構成を再帰的に生成#します。

網膜、32バイト

バイトカウントはISO 8859-1エンコードを前提としています。

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

オンラインでお試しください！

説明

これは私のCJamの回答と同様に機能します。リストN1を調べ、各位置でバイナリ決定の両方の分岐を取得します。a）最後の値をインクリメントするか、b）1で新しい値を開始します。

ステージ1

.+
$*

入力を単項に変換します。

ステージ2

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

+出力が変化しなくなるまでループでこの段階を実行する網膜に伝えます。%段階を適用する前に、行に入力を分割し、その後一緒に戻ってそれらを結合するためにそれを伝えます。の%後に置くことにより+、Retinaは各反復後に分割され、再結合します。ステージの1回の繰り返しで、前述の決定のいずれかが行われ、現在のパーティションセットが分岐されます。

実際にどのように機能するかは、1（1バックティックの前に示されている最初の1つのみ）に一致し、（!出力の単項数字として使用する）に置き換えて、残り1のこの行（最後の値をインクリメントします）。次に、別の行（¶）に現在の行のプレフィックスを出力し、その後,!にを挿入し1ます。これにより、セパレータが挿入され、次の値がで始まります。

ステージ3

!+
$.&

これは、実行!を10進整数に変換して、それらを長さに置き換えます。

ステージ4

A`^,

そして最後に、必要な行の2倍の行を生成し、それらの半分が,（まだ分割するものがなかったとしても最初に分割の決定を行った）で始まることに気付きます。したがって、で始まるすべての行を破棄します,。

Perl、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

LUA 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.;

または、繰り返し押し;ても問題ない場合（またはバイトカウントに追加する必要がある場合）、callでbagof(L,[4]*L,M).17バイトを追加します。

J、30 26バイト

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

2 ^nのバイナリ値を使用して、単項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バイト

この回答は、ルイスメンドーのMATL回答に一部基づいています。ゴルフの提案を歓迎します。オンラインでお試しください！

;╗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の回答（デカルト製品の回答）の興味深い分岐であり、実装の違いは興味深いと思いました。Martinの文字列のいずれかが増分で始まる場合、エラーによりその文字列は評価されません。実際には、エラーは抑制され、文字列は評価されます。これkは範囲内のすべての構成を与えることになります[1..n]。

余分な楽曲を削除するのではなく、各文字列の先頭にaのn-1デカルトの累乗を"1u"追加し"1"ました。このトリックはの構成のみを与えnます。残念ながら、マーティンの答えよりも長いです。

ゴルフの提案を歓迎します。オンラインでお試しください！

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.