O desafio é listar todas as partições ordenadas (composição (combinatória)) de um número inteiro positivo n. Estas são as listas de números de 1para ncuja soma é n. Por exemplo, dada entrada n = 4, o resultado deve ser:

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

O resultado pode estar em qualquer ordem, mas deve conter cada partição ordenada uma vez. Isto significa que para n = 4, [1, 1, 2], [1, 2, 1]e [2, 1, 1]deve ser parte do resultado.

Aqui está o meu próprio código JavaScript que consegue isso:

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

Golfe, ES6 ( 169 167 119 109 109 105 89 85 bytes ):

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

Pitão, 7 6 bytes

Solução de 7 bytes:

Pyth possui uma partição inteira integrada ./, portanto, 5 dos 7 bytes estão recebendo os pedidos.

{s.pM./

Experimente online!

Explicação:

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

Solução de 6 bytes:

Se você tiver uma lista, ./calculará com os pedidos; tudo o que resta é fazer os números das listas novamente.

lMM./m

Experimente online!

Explicação:

     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 bytes

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

O xnor salvou dois bytes.

Python, 56 bytes

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

Uma solução recursiva: As partições ordenadas de nsão uma partição de algumas menores icom 0<=i<n, seguidas pelo restante n-icomo o último elemento. Para um caso base, n=0possui apenas a partição vazia.

Python 2, 61 bytes

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

Este não é o mais curto, mas eu realmente gosto do método porque é muito estranho.

Gera e avalia recursivamente 2**(n-1)cadeias de caracteres, como

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,

para n=4. Essas cadeias são avaliadas para tuplas representando todas as partições. Entre quaisquer dois 1s existe um +, juntando-os em um único número ou um ,, dividindo seções adjacentes.

JavaScript (Firefox 30-57), 63 bytes

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

Mathematica, 40 bytes

Join@@Permutations/@IntegerPartitions@#&

O built-in do Mathematica para partições inteiras não fornece todas as partições ordenadas , portanto, temos que gerar todas as permutações possíveis de cada uma delas e achatar o resultado.

CJam , 17 14 bytes

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

Experimente online!

Explicação

Sei que disse que usar o produto cartesiano é mais longo, mas acabei encontrando uma maneira de usá-lo com mais eficiência. Eu acho que as duas abordagens são interessantes por si só, então estou colocando-as em posts separados.

Isso ainda se baseia na idéia de que podemos escolher ntempos entre anexar 1a à partição atual ou incrementar o último elemento da partição atual. Nesta solução, fazemos isso gerando 2 ^n-1 programas diferentes que correspondem a essas diferentes opções.

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

Geléia , 7 6 bytes

-1 byte graças a @Dennis (converta de unário ḅ1, em vez de soma para cada um para cada S€€)

1ẋŒṖḅ1

TryItOnline

Quão?

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

Esta é uma porta da brilhante resposta do @ xnor , usando vários níveis de expansões do bash para alcançar o resultado desejado:

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

Ideone.

• A primeira linha é simplesmente uma expansão aritmética para criar uma variável $acontendo 1seguidos de n-1zeros.
• A primeira expansão ${a//0/{+,']\ $[}1'}substitui cada 0no $acom cópias da cadeia {+,']\ $[}1'. Assim, n = 4, obtemos a string1{+,']\ $[}1'{+,']\ $[}1'{+,']\ $[}1'
• É prefixado $[e pós-fixado com ],para fornecer$[1{+,']\ $[}1'{+,']\ $[}1'{+,']\ $[}1]
• Esta é uma expansão de chave que se expande para $[1+1+1+1], $[1+1+1] 1, $[1+1] $[1+1], $[1+1] 1 1,...
• Isso finalmente é expandido aritmeticamente para fornecer o resultado necessário.

O uso cuidadoso de aspas, a barra invertida e a fuga evalgarantem que as expansões ocorram na ordem correta.

Ruby, 61 bytes

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

destroçado

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

uso

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

Braquilog , 20 bytes

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

Experimente online!

Explicação

Essa é uma situação em que você acha que as linguagens declarativas se sairiam bem, mas, devido à sobrecarga +e dificuldade em escrever um predicado de soma que propague adequadamente as restrições, elas não o fazem.

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

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

Experimente online!

Explicação

O CJam não possui uma combinação combinatória útil para partições inteiras. Então, faremos isso manualmente. Para encontrar todas as partições ordenadas de um número inteiro n, podemos olhar para uma lista de nunidades e considerar todas as formas possíveis de inserir separadores. Em seguida, somaremos os 1s em cada seção. Exemplo para n = 3:

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

Tentei usar um produto cartesiano para gerar todos esses separadores, mas isso acabou em 21 bytes. Em vez disso, voltei a essa antiga técnica para gerar conjuntos de potência (isso é baseado em uma resposta antiga de Dennis, mas não consigo encontrá-la agora). A idéia é a seguinte: para gerar todas as partições, podemos começar de uma lista vazia. Às nvezes, podemos tomar uma decisão binária: anexamos a 1(corresponde a um separador no exemplo acima) ou incrementamos o último valor da lista (corresponde a não ter um separador). Para gerar todas as partições, simplesmente executamos as duas operações em cada etapa e mantemos todas as saídas possíveis para a próxima etapa. Acontece que no CJam, a adição e o incremento do primeiro elemento são mais curtos, mas o princípio permanece o mesmo:

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 bytes

Golfe:

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

Violino

Mathematica 10.0, 44 bytes

Uma tentativa sem usar os recursos internos da partição. De cada partição ordenada de tamanho k , são geradas duas partições sucessivas de k + 1 : uma anexando 1 e a outra incrementando o primeiro valor.

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

Uma maneira mais engraçada, mas infelizmente mais longa, de 2 bytes de implementar a mesma idéia:

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

05AB1E , 14 12 bytes

Economizou 2 bytes graças a Adnan

>G¹LNãvyO¹Q—

Explicação

>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

Experimente online!

A solução correspondente é 2 bytes mais curta no 2sable .

2sable , 10 bytes

>GLNãvyOQ—

Experimente online!

Haskell, 41 bytes

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

Não é a solução mais curta da Haskell, mas eu gosto que ela não use [..]intervalos. Em vez disso, calcula recursivamente as partições ncomo as partições n-1com um novo 1 no início ou o primeiro valor mais alto. Isso torna explícito o porquê 2^(n-1)deles.

Mathematica, 53 bytes

Não supera a resposta de Martin Ender, que usa a IntegerPartitionsfunção interna (e as internas são totalmente boas para mim). (Também não supera a resposta do feersum, que não vi até muito tarde.) Mas eu queria praticar uma função recursiva no golfe.

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

Gera recursivamente todas as composições, gerando todos os números finais possíveis je depois chamando a si próprio #-jonde #está a entrada.

Retina , 32 bytes

A contagem de bytes assume a codificação ISO 8859-1.

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

Experimente online!

Explicação

Isso funciona de maneira semelhante à minha resposta CJam . Passamos por uma lista Ne, em cada posição, tomamos os dois ramos da decisão binária a) incrementamos o último valor ou b) iniciamos um novo valor em 1.

Estágio 1

.+
$*

Converta a entrada para unário.

Etapa 2

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

O +instrui o Retina a executar esse estágio em um loop até que a saída pare de mudar. Ele %diz para dividir a entrada em linhas antes de aplicar o palco e juntá-las novamente depois. Ao colocar o %depois do+ , o Retina se divide e volta a se juntar a cada iteração. Uma iteração do estágio toma uma dessas decisões que mencionei e, assim, bifurca o conjunto atual de partições.

Como ele realmente funciona é que ele corresponde a 1(mas apenas o primeiro, conforme indicado 1na frente do backtick), e o substitui por !(o qual usaremos como o dígito unário de nossa saída), seguido pelos 1s restantes nesta linha (isso incrementa o último valor). Em outra linha ( ¶), imprime o prefixo da linha atual, seguida por ,!, que insere um separador e inicia o próximo valor em 1.

Etapa 3

!+
$.&

Isso converte as execuções de !números inteiros decimais, substituindo-as pelo comprimento.

Etapa 4

A`^,

E, finalmente, percebemos que geramos o dobro de linhas que queríamos, e metade delas começa com uma ,(aquelas em que tomamos a decisão de dividir inicialmente, mesmo que ainda não houvesse nada para dividir). Portanto, descartamos todas as linhas que começam com a ,.

Perl, 44 bytes

Inclui +3 para -n(o código usa $'e, $0portanto, não pode ser executado como um-e linha de comando)

Atribua um número à partição no STDIN:

partitions.pl <<< 4

partitions.pl

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

Se você não se importa com espaços extras no final de uma linha e uma nova linha extra, essa solução de 42 bytes também funciona (execute como perl -M5.010 partitions.pl):

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

Julia, 113 bytes

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

Solução não recursiva

Explicado:

1. [vcat([1 for _=i+1:N],sum([1 for _=N-i:N-1])) for i=1:N] crie um conjunto de listas somadas a N, cujas permutações se parecerão com a solução (por exemplo, para N = 4: [[1,1,1,1], [1,1,2], [1,3], [4 ]])
2. map(x->[permutations(x)...],) Calcular todas as permutações
3. reduce(vcat,) combiná-los em uma lista de listas
4. unique() filtrar duplicatas

MATL , 15 bytes

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

Experimente online!

Explicação

Dada a entrada n, isso calcula a potência cartesiana com expoentes crescentes kde 1para n; e para cada expoente kseleciona as tuplas que possuem uma soma igual à entrada.

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

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)

Versão não resolvida.

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)

Encontrou um espaço em branco disperso e removeu uma variável desnecessária para 11 bytes seguros. Acontece que table.insert () é byte ineficiente

PHP, 125 bytes

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

-4 bytes para em print_r($r);vez deecho json_encode($r); para a saída

uma solução recursiva com 250 bytes

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 bytes + 6 bytes para chamar

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.

Experimente online!
Ligue com [4]*L., repita com ;até que todas as soluções tenham sido apresentadas.

Como alternativa, se pressionar repetidamente ;não estiver ok (ou deve ser adicionado à contagem de bytes), a chamada bagof(L,[4]*L,M).adicionará 17 bytes à chamada.

J , 30 26 bytes

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

Funciona dividindo a lista de n unário usando os valores binários de 2 ⁿ .

Experimente online!

Explicação

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

Na realidade, 17 16 bytes

Esta resposta é parcialmente baseada na resposta MATL de Luis Mendo . Sugestões de golfe são bem-vindas. Experimente online!

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

Na verdade, 17 16 15 bytes

Esta é uma bifurcação interessante da resposta CJam de Martin Ender (aquela com o produto cartesiano), com uma diferença na implementação que achei interessante. Quando uma das cadeias de caracteres de Martin começa com um incremento, os erros impedem que essa cadeia seja avaliada. Na verdade, o erro é suprimido e a sequência é avaliada de qualquer maneira. Isso acaba dando as composições de todos kna faixa[1..n] .

Em vez de tentar remover as composições extras, tomei o n-1poder cartesiano de "1u"anexar um"1" a ao início de cada corda. Esse truque fornece apenas as composições den . Infelizmente, é mais longo que a resposta de Martin.

Sugestões de golfe são bem-vindas. Experimente online!

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.