Buradaki zorluk, verilen bir pozitif tamsayının tüm sıralı bölümlerini (kompozisyonu (birleştirici)) listelemektir n. Bunlar dan sayıların listeleri 1için nolan toplamıdır n. Örneğin, giriş verilmişse n = 4sonuç şöyle olmalıdır:

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

Sonuç herhangi bir sırayla olabilir, ancak sipariş edilen her bölümü bir kez içermelidir. Bu araçlar için olduğu n = 4, [1, 1, 2], [1, 2, 1]ve [2, 1, 1]tüm sonucunun parçası olmalıdır.

İşte bunu sağlayan kendi JavaScript kodum:

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

Golf, ES6 ( 169 167 119 109 105 89 85 bayt ):

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

Pyth, 7 6 bayt

7 byte çözüm:

Pyth yerleşik bir tamsayı bölmesine sahiptir ./, bu nedenle 7 bayttan 5'i siparişi almaktadır.

{s.pM./

Çevrimiçi deneyin!

Açıklama:

     ./  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 baytlık çözüm:

Eğer bir listeniz varsa, ./siparişlerle hesaplanacaktır; geriye kalan tek şey listeleri tekrar yapmaktır.

lMM./m

Çevrimiçi deneyin!

Açıklama:

     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 bayt

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

xnor iki byte kaydetti.

Python, 56 bayt

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

Özyinelemeli bir çözüm: Sıralanan nbölümler, bazılarının daha küçük iolan bölümleridir 0<=i<n, ardından kalan n-ison öğe olarak kalır. Temel bir durumda, n=0sadece boş bölüm var.

Python 2,61 bayt

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

Bu en kısa değil, ama yöntemi gerçekten seviyorum çünkü çok garip.

Tekrarlı olarak 2**(n-1)dizeleri oluşturur ve değerlendirir.

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,

için n=4. Bu dizgiler tüm bölümleri temsil eden perdeleri değerlendirir. Herhangi bir iki 1 arasında +, bunları tek bir sayıya katmak veya a ,, bitişik bölümleri bölmek şeklindedir.

JavaScript (Firefox 30-57), 63 bayt

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

Mathematica, 40 bayt

Join@@Permutations/@IntegerPartitions@#&

Mathematica'nın yerleşik tamsayı bölümleri tüm sipariş bölümlerini vermez , bu nedenle her birinin olası tüm izinlerini oluşturmalı ve sonucu düzeltmeliyiz.

CJam , 17 14 bayt

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

Çevrimiçi deneyin!

açıklama

Kartezyen ürününü kullanmanın daha uzun olduğunu söylediğimi biliyorum , ancak daha verimli kullanmanın bir yolunu buldum. Her iki yaklaşımın da kendi başlarına ilginç olduğunu düşünüyorum, bu yüzden ayrı yazılara yerleştiriyorum.

Bu, hala nbir ekleme eklemek arasında zaman seçebileceğimiz fikrine dayanmaktadır.1 , mevcut bölüme veya mevcut bölümün son elemanını arttırma . Bu çözümde bunu , bu farklı seçimlere karşılık gelen 2 ^n-1 farklı program oluşturarak yapıyoruz .

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

Jöle , 7 6 bayt

@Dennis sayesinde -1 bayt ( ḅ1her biri için toplamdan ziyade tekli dosyadan dönüştürme S€€)

1ẋŒṖḅ1

TryItOnline

Nasıl?

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

Saf Bash, 51

İstenilen sonucu elde etmek için birden fazla bash genişletme düzeyi kullanan @ xnor'ın mükemmel cevabının limanı :

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

Ideone.

• İlk satır, ardından sıfırları $aiçeren bir değişken oluşturmak için basit bir aritmetik genişlemedir .1n-1
• İlk genişletme ${a//0/{+,']\ $[}1'}her yerini 0in $adizesinin kopyaları ile {+,']\ $[}1'. Böylece n = 4 dizesini alırız1{+,']\ $[}1'{+,']\ $[}1'{+,']\ $[}1'
• Bu önek $[ve ],vermek için ile eklenmiştir$[1{+,']\ $[}1'{+,']\ $[}1'{+,']\ $[}1]
• Bu genişleyen bir ayraç genişletme $[1+1+1+1], $[1+1+1] 1, $[1+1] $[1+1], $[1+1] 1 1,...
• Bu nihayet gerekli sonucu verecek şekilde aritmetik olarak genişletilir.

Tırnakların dikkatli kullanılması, ters eğik çizgi kaçması ve evalgenişlemelerin doğru sırada olmasını sağlar.

Ruby, 61 bayt

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

ungolfed

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

kullanım

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 bayt

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

Çevrimiçi deneyin!

açıklama

Bu, bildirimsel dillerin iyi olacağını düşündüğünüz bir durumdur, ancak aşırı yüklenme nedeniyle +ve sıkıntı nedeniyle, kısıtlamaları doğru şekilde yayan bir toplama belirtisi yazarken.

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

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

Çevrimiçi deneyin!

açıklama

CJam tamsayılı bölümler için yerleşik kullanışlı bir birleştiriciye sahip değildir. Yani bunu manuel olarak yapacağız. Bir tamsayının tüm sıralı bölümlerini bulmak için birler nlistesine bakabilir nve ayırıcılar eklemek için mümkün olan her yolu düşünebiliriz. Sonra 1her bölümde s'i toplayacağız. Örnek n = 3:

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

Tüm bu ayırıcıları üretmek için bir Kartezyen ürünü kullanmayı denedim, ancak bu 21 bayta ulaştı. Bunun yerine güç setleri üretmek için bu eski tekniğe geri döndüm (bu Dennis'in eski bir cevabına dayanıyor ama şu anda bulamıyorum). Fikir şudur: Tüm bölümleri oluşturmak için boş bir listeden başlayabiliriz. Öyleyse, nzamanlar ikili bir karar verebiliriz: ya bir ekleriz 1(yukarıdaki örnekte bir ayırıcıya karşılık gelir) ya da listenin son değerini arttırırız (bir ayırıcıya sahip olmamaya karşılık gelir). Tüm bölümleri oluşturmak için her adımda her iki işlemi de gerçekleştiriyoruz ve bir sonraki adım için tüm olası çıktıları koruyoruz. CJam'da, ilk öğeyi hazırlama ve artırmanın daha kısa olduğu, ancak ilkenin aynı kaldığı ortaya çıktı:

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 bayt

golfed:

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=@

Ungolfed:

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=@

Keman

Mathematica 10.0, 44 bayt

Bölümle ilişkili yerleşikleri kullanmadan yapılan deneme. K büyüklüğündeki her bir düzenlenmiş bölümden, k + 1'in ardışık iki bölümü oluşturulur: biri 1'i hazırlar, diğeri ilk değeri artırır.

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

Daha komik, ama ne yazık ki aynı fikri uygulama yolunun 2 baytı daha uzun:

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

05AB1E , 14 12 bayt

Adnan sayesinde 2 bayt kaydedildi

>G¹LNãvyO¹Q—

açıklama

>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

Çevrimiçi deneyin!

Karşılık gelen çözüm 2sable içinde 2 bayttır .

2sable , 10 bayt

>GLNãvyOQ—

Çevrimiçi deneyin!

Haskell, 41 bayt

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

En kısa Haskell çözümü değil, ancak [..]aralıkları kullanmamasını seviyorum . Bunun yerine, başlangıçtaki yeni bir 1 veya daha yüksek olan ilk değer nolan bölümlerin bölümlerini yinelemeli olarak hesaplar n-1. Bu, neden 2^(n-1)bunlarda olduğunu açıkça ortaya koyuyor .

Mathematica, 53 bayt

Martin Ender'in yerleşik IntegerPartitionsişlevi kullanan yanıtını geçmez (ve yerleşikler bana göre tamamen iyi). (Çok geç olmadan göremediğim feersum'un cevabını da geçmedi.) Ama golf özyinelemeli bir işlev uygulamak istedim.

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

Tüm kompozisyonları tekrarlı bir şekilde üretir, mümkün olan tüm son sayıları oluşturarak jve ardından girişin #-jbulunduğu yeri arayarak kendisini oluşturur #.

Retina , 32 bayt

Bayt sayısı, ISO 8859-1 kodlamasını varsayar.

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

Çevrimiçi deneyin!

açıklama

Bu benim CJam cevabımı benzer şekilde çalışır . Bir liste üzerinden geçiyoruz Nve her pozisyonda ikili kararın iki kolunu da alıyoruz a) son değeri arttırmak veya b) 1'de yeni bir değer başlatmak.

1. Aşama

.+
$*

Girişi unary'ye dönüştürün.

2. aşama

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

+Çıktı değişen durana kadar bir döngü içinde bu aşamaya yürütmek Retina söyler. %Daha sonradan tekrar bir araya onları sahne uygulamadan önce satırlara girişi bölünmüş ve katılmak söyler. Koyarak %sonra +her tekrardan sonra, Retina bölünme ve biraraya gelmiş. Sahnenin bir yinelemesi bahsettiğim kararlardan birini verir ve böylece mevcut bölüm kümesini çatallar.

Nasıl gerçekten çalışıyor bir eşleştiğini olduğunu 1(ama sadece ilk belirtildiği gibi birini 1ile backtick önünde) ve yerine geçer bunu !kalan takiben (bizim çıkış tekli basamak olarak kullanacağız), 1s bu satırda (bu, son değeri artırır). Sonra başka bir satırda ( ¶), geçerli satırın önekini yazdırır, ardından ,!bir ayırıcı ekler ve ardından bir sonraki değeri başlar 1.

Sahne 3

!+
$.&

Bu !, uzunluklarını değiştirerek, sayılarını tam sayılara dönüştürür .

4. Aşama

A`^,

Sonunda, istediğimizden iki kat daha fazla satır oluşturduğumuzu fark ettik ve bunların yarısı ( ,daha sonra ayrılacak bir şey olmamasına rağmen başlangıçta ayrılma kararını verdiklerimizle) başlıyor . Bu nedenle, a ile başlayan tüm satırları atarız ,.

Perl, 44 bayt

İçin +3 içerir -n(kod kullanır $'ve $0bu nedenle-e komut satırı )

STDIN'de bölümlemeye numara verin:

partitions.pl <<< 4

partitions.pl

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

Bir satırın sonunda fazladan boşluklar ve fazladan bir yeni satırın sakıncası yoksa, bu 42 baytlık çözüm de çalışır (farklı çalıştırma perl -M5.010 partitions.pl):

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

Julia, 113 Bayt

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

Özyinelemeyen çözüm

Açıklaması:

1. [vcat([1 for _=i+1:N],sum([1 for _=N-i:N-1])) for i=1:N] permütasyonları çözüme benzeyecek olan N'ye toplanacak bir liste seti (örneğin N = 4 için: [[1,1,1,1], [1,1,2], [1,3], [4 ]])
2. map(x->[permutations(x)...],) Tüm permütasyonları hesapla
3. reduce(vcat,) onları bir liste listesine ekleyin
4. unique() filtre kopyaları

MATL , 15 bayt

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

Çevrimiçi deneyin!

açıklama

Giriş Verilen nbu üsler artan Kartezyen gücünü hesaplar kgelen 1etmek n; ve her bir üs kiçin, girişe eşit toplamı olan perdeleri seçer.

:       % 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 bayt

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)

Ungolved versiyonu.

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)

Başıboş bir boşluk buldu ve gereksiz bir değişkeni güvenli 11 byte'a çıkardı. Görünüşe göre, table.insert () bayt verimsiz

PHP, 125 Bayt

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

Çıktı print_r($r);yerine -4 baytecho json_encode($r);

250 Bayt ile özyinelemeli bir çözüm

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

Prolog, 81 bayt + 6 bayt çağrı

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.

Çevrimiçi deneyin!
Arayın [4]*L., ;tüm çözümler sunulana kadar tekrarlayın .

Alternatif olarak, art arda basılması ;tamam değilse (veya bayt sayısına eklenmelidir), aramaya bagof(L,[4]*L,M).17 bayt ekleyen çağrı.

J , 30 26 bayt

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

Yarma İşleri tekli listesi n 2'nin ikili değerleri kullanarak ⁿ .

Çevrimiçi deneyin!

açıklama

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

Aslında, 17 16 bayt

Bu cevap kısmen Luis Mendo'nun MATL cevabına dayanmaktadır . Golf önerileri kabul edilir. Çevrimiçi deneyin!

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

Ungolfing

         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.

Aslında, 17 16 15 bayt

Bu, Martin Ender'in CJam cevabının (Kartezyen ürünü olan) cevabının ilginç bir çatalı, uygulamada ilginç olduğunu düşündüm. Martin dizelerinden biri bir artışla başladığında, hatalar o dizginin değerlendirilmesini engeller. Aslında, hata bastırılır ve dize yine de değerlendirilir. Bu k, aralıktaki her birinin bileşimlerini vererek sona erer [1..n].

Ekstra bileşimleri çıkarmaya çalışmak yerine , her bir dizginin başına eklenen n-1a'nın Kartezyen gücünü aldım . Bu numara sadece kompozisyonları veriyor . Maalesef, Martin'in cevabından daha uzun."1u""1"n

Golf önerileri kabul edilir. Çevrimiçi deneyin!

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

Ungolfing

         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.