Le défi est de lister toutes les partitions ordonnées (composition (combinatoire)) d'un entier positif donné n. Ce sont les listes de nombres de 1à ndont la somme est n. Par exemple, pour une entrée donnée n = 4, le résultat devrait être:

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

Le résultat peut être dans n'importe quel ordre, mais doit contenir une fois chaque partition ordonnée. Cela signifie que pour n = 4, [1, 1, 2], [1, 2, 1]et [2, 1, 1]doivent tous faire partie du résultat.

Voici mon propre code JavaScript qui y parvient:

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 octets ):

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

Pyth, 7 6 octets

Solution à 7 octets:

Pyth a une partition entière intégrée ./, donc 5 des 7 octets reçoivent les commandes.

{s.pM./

Essayez-le en ligne!

Explication:

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

Solution à 6 octets:

Si vous avez une liste, ./calculera avec les commandes; il ne reste plus qu'à refaire les listes.

lMM./m

Essayez-le en ligne!

Explication:

     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 octets

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

xnor a enregistré deux octets.

Python, 56 octets

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

Une solution récursive: les partitions ordonnées de nsont une partition de plus petite iavec 0<=i<n, suivie du reste n-icomme dernier élément. Pour un cas de base, n=0n'a que la partition vide.

Python 2, 61 octets

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

Ce n'est pas le plus court, mais j'aime vraiment la méthode car c'est tellement bizarre.

Génère et évalue récursivement des 2**(n-1)chaînes, comme

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,

pour n=4. Ces chaînes sont évaluées en tuples représentant toutes les partitions. Entre deux 1 quelconques se trouve soit un +, les joignant en un seul nombre, soit un ,, divisant des sections adjacentes.

JavaScript (Firefox 30-57), 63 octets

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

Mathematica, 40 octets

Join@@Permutations/@IntegerPartitions@#&

L'intégration de Mathematica pour les partitions entières ne donne pas tout ordonné partitions , nous devons donc générer toutes les permutations possibles de chacune d'entre elles, puis aplatir le résultat.

CJam , 17 ans 14 octets

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

Essayez-le en ligne!

Explication

Je sais j'ai dit que l'utilisation du produit cartésien est plus longue, mais j'ai fini par trouver un moyen de l'utiliser plus efficacement. Je pense que les deux approches sont intéressantes en soi, donc je les mets dans des postes séparés.

Ceci est toujours basé sur l'idée que nous pouvons choisir des ntemps entre l'ajout de a 1à la partition actuelle ou l'incrémentation du dernier élément de la partition actuelle. Dans cette solution, nous le faisons en générant 2 ^n-1 programmes différents qui correspondent à ces différents choix.

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ée , 7 6 octets

-1 octet grâce à @Dennis (conversion de unaire ḅ1, plutôt que somme pour chacun pour chacun S€€)

1ẋŒṖḅ1

TryItOnline

Comment?

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

Il s'agit d'un port de la brillante réponse de @ xnor , utilisant plusieurs niveaux d'extensions bash pour obtenir le résultat souhaité:

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

Ideone.

• La première ligne est simplement une expansion arithmétique pour créer une variable $acontenant 1suivie de n-1zéros.
• La première expansion ${a//0/{+,']\ $[}1'}remplace chaque 0dans $ades copies de la chaîne {+,']\ $[}1'. Ainsi n = 4 on obtient la chaîne1{+,']\ $[}1'{+,']\ $[}1'{+,']\ $[}1'
• Ceci est préfixé $[et postfixé ],pour donner$[1{+,']\ $[}1'{+,']\ $[}1'{+,']\ $[}1]
• Il s'agit d'une extension d'accolade qui s'étend à $[1+1+1+1], $[1+1+1] 1, $[1+1] $[1+1], $[1+1] 1 1,...
• Celui-ci est finalement développé arithmétiquement pour donner le résultat souhaité.

Une utilisation prudente des guillemets, une barre oblique inversée s'échappe et evalgarantit que les extensions se produisent dans le bon ordre.

Rubis, 61 octets

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

non golfé

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

usage

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 octets

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

Essayez-le en ligne!

Explication

C'est une situation où vous pensez que les langages déclaratifs feraient bien, mais à cause de la surcharge +et de la difficulté à écrire un prédicat de sommation qui propage correctement les contraintes, ils ne le font pas.

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

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

Essayez-le en ligne!

Explication

CJam n'a pas de combinatoire utile intégrée pour les partitions entières. Nous allons donc le faire manuellement. Pour trouver toutes les partitions ordonnées d'un entier n, nous pouvons regarder une liste de ncelles-ci et considérer toutes les manières possibles d'insérer des séparateurs. Ensuite, nous allons additionner les 1s dans chaque section. Exemple pour n = 3:

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

J'ai essayé d'utiliser un produit cartésien pour générer tous ces séparateurs, mais cela a fini par 21 octets. Au lieu de cela, je suis retourné à cette ancienne technique pour générer des ensembles de puissance (cela est basé sur une ancienne réponse de Dennis mais je ne la trouve pas pour le moment). L'idée est la suivante: pour générer toutes les partitions, nous pouvons partir d'une liste vide. Ensuite n, nous pouvons prendre une décision binaire: soit nous ajoutons un 1(correspond à un séparateur dans l'exemple ci-dessus), soit nous incrémentons la dernière valeur de la liste (correspond à ne pas avoir de séparateur). Pour générer toutes les partitions, nous effectuons simplement les deux opérations à chaque étape et conservons toutes les sorties possibles pour l'étape suivante. Il s'avère que dans CJam, l'ajout et l'incrémentation du premier élément sont plus courts, mais le principe reste le même:

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 octets

Golfé:

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

Non golfé:

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

Violon

Mathematica 10.0, 44 octets

Une tentative sans utiliser de modules internes liés aux partitions. A partir de chaque partition ordonnée de taille k , deux partitions successives de k + 1 sont générées: l'une en ajoutant 1 au début, et l'autre en incrémentant la première valeur.

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

Un moyen plus drôle, mais malheureusement 2 octets de plus pour implémenter la même idée:

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

05AB1E , 14 12 octets

Enregistré 2 octets grâce à Adnan

>G¹LNãvyO¹Q—

Explication

>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

Essayez-le en ligne!

La solution correspondante est plus courte de 2 octets dans 2sable .

2sable , 10 octets

>GLNãvyOQ—

Essayez-le en ligne!

Haskell, 41 octets

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

Pas la solution Haskell la plus courte, mais j'aime bien qu'elle n'utilise pas de [..]plages. Au lieu de cela, il calcule récursivement les partitions de ncomme les partitions den-1 avec soit un nouveau 1 au début soit une première valeur supérieure. Cela explique pourquoi il y 2^(n-1)en a.

Mathematica, 53 octets

Ne bat pas la réponse de Martin Ender, qui utilise la fonction intégrée IntegerPartitions fonction intégrée (et les intégrés sont tout à fait corrects pour moi). (Cela ne bat pas non plus la réponse de feersum, que je n'ai vue que trop tard.) Mais je voulais pratiquer une fonction récursive au golf.

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

Génère récursivement toutes les compositions, en générant tous les nombres finaux possibles j, puis en se rappelant #-joù se #trouve l'entrée.

Rétine , 32 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Essayez-le en ligne!

Explication

Cela fonctionne de manière similaire à ma réponse CJam . Nous parcourons une liste Net à chaque position nous prenons les deux branches de la décision binaire a) incrémentons la dernière valeur ou b) commençons une nouvelle valeur à 1.

Étape 1

.+
$*

Convertissez l'entrée en unaire.

Étape 2

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

Le +dit à Retina d'exécuter cette étape en boucle jusqu'à ce que la sortie cesse de changer. Le lui %dit de diviser l'entrée en lignes avant d'appliquer la scène et de les rejoindre ensuite. En mettant l' %after the +, la rétine se fend et rejoint après chaque itération. Une itération de la scène prend l'une des décisions que j'ai mentionnées et bifurque ainsi l'ensemble actuel de partitions.

Comment cela fonctionne réellement, c'est qu'il correspond à un 1(mais seulement le premier comme indiqué par le 1devant du backtick), et le remplace par !(que nous utiliserons comme le chiffre unaire de notre sortie), suivi du 1s restant sur cette ligne (cela incrémente la dernière valeur). Ensuite, sur une autre ligne ( ¶), il imprime le préfixe de la ligne actuelle, suivi de ,!, qui insère un séparateur, puis démarre la valeur suivante à 1.

Étape 3

!+
$.&

Cela convertit les séquences de !en nombres décimaux en les remplaçant par leur longueur.

Étape 4

A`^,

Et enfin, nous remarquons que nous avons généré deux fois plus de lignes que nous le voulions, et la moitié d'entre elles commencent par un ,(celles où nous avons initialement pris la décision de fractionner, même s'il n'y avait rien à séparer après). Par conséquent, nous supprimons toutes les lignes commençant par a ,.

Perl, 44 octets

Comprend +3 pour -n(le code utilise $'et $0il ne peut donc pas être exécuté en -eligne de commande)

Donnez un numéro à partitionner sur STDIN:

partitions.pl <<< 4

partitions.pl

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

Si cela ne vous dérange pas les espaces supplémentaires à la fin d'une ligne et une nouvelle ligne supplémentaire, cette solution de 42 octets fonctionne également (exécutée en tant que perl -M5.010 partitions.pl):

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

Julia, 113 octets

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

Solution non récursive

Expliqué:

1. [vcat([1 for _=i+1:N],sum([1 for _=N-i:N-1])) for i=1:N] construire un ensemble de listes qui résument à N, dont les permutations ressembleront à la solution (par exemple pour N = 4: [[1,1,1,1], [1,1,2], [1,3], [4 ]])
2. map(x->[permutations(x)...],) Calculez toutes les permutations
3. reduce(vcat,) les combiner dans une liste de listes
4. unique() filtrer les doublons

MATL , 15 octets

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

Essayez-le en ligne!

Explication

nAvec une entrée donnée , cela calcule la puissance cartésienne avec des exposants croissants kde 1à n; et pour chaque exposant ksélectionne les tuples qui ont une somme égale à l'entrée.

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

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)

Version non résolue.

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)

Trouvé un espace vide et supprimé une variable inutile pour sécuriser 11 octets. il s'avère que table.insert () est inefficace en octets

PHP, 125 octets

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 octets pour print_r($r);au lieu de echo json_encode($r);pour la sortie

une solution récursive avec 250 octets

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 octets + 6 octets à appeler

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.

Essayez-le en ligne!
Appelez avec [4]*L., répétez avec ;jusqu'à ce que toutes les solutions aient été présentées.

Alternativement, si une pression répétée ;n'est pas correcte (ou doit être ajoutée au nombre d'octets), l'appel bagof(L,[4]*L,M).ajoute 17 octets pour l'appel.

J , 30 26 octets

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

Fonctionne en divisant la liste des n unaires en utilisant les valeurs binaires de 2 ⁿ .

Essayez-le en ligne!

Explication

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

En fait, 17 16 octets

Cette réponse est partiellement basée sur la réponse MATL de Luis Mendo . Suggestions de golf bienvenues. Essayez-le en ligne!

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

En fait, 17 16 15 octets

Ceci est une fourchette intéressante de la réponse CJam de Martin Ender (celle avec le produit cartésien), avec une différence de mise en œuvre que j'ai trouvée intéressante. Lorsque l'une des chaînes de Martin commence par un incrément, les erreurs empêchent cette chaîne d'être évaluée. En fait, l'erreur est supprimée et la chaîne est quand même évaluée. Cela finit par donner les compositions de chacun kdans la gamme[1..n] .

Plutôt que d' essayer d'enlever les compositions supplémentaires, je pris la n-1e puissance cartésien d' "1u"une annexe"1" au début de chaque chaîne. Cette astuce ne donne que les compositions de n. C'est malheureusement plus long que la réponse de Martin.

Suggestions de golf bienvenues. Essayez-le en ligne!

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.