Завдання полягає в тому, щоб перелічити всі упорядковані розділи (композиція (комбінаторика)) заданого натурального числа n. Ці списки чисел від 1до nякої сума n. Наприклад, з урахуванням введення 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 вбудований цілий розділ ./, тому 5 з 7 байт отримує впорядкування.

{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 зберегло два байти.

Пітон, 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. Ці рядки оцінюються за кортежами, що представляють усі розділи. Між будь-якими двома 1 є або a +, об'єднуючи їх в єдине число, або a, , розбиваючи сусідні ділянки.

JavaScript (Firefox 30-57), 63 байти

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

Математика, 40 байт

Join@@Permutations/@IntegerPartitions@#&

Вбудована система Mathematica для цілих розділів не дає всіх упорядкованих розділів, тому ми повинні генерувати всі можливі перестановки кожного з них, а потім вирівнювати результат.

CJam , 17 14 байт

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

Спробуйте в Інтернеті!

Пояснення

Я знаю, я говорив, що використовувати декартовий продукт довше, але я врешті знайшов спосіб його більш ефективного використання. Я думаю, що обидва підходи цікаві самі по собі, тому я розміщую їх в окремих посадах.

Це все ще ґрунтується на ідеї, що ми можемо вибирати nчаси між додаванням a 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 байт

-1 байт завдяки @Dennis (конвертувати з унарного ḅ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 рік

Це порт блискучої відповіді @ xnor , використовуючи кілька рівнів розгортання баш для досягнення бажаного результату:

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гарантує, що розширення відбуваються у правильному порядку.

Рубін, 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]]

Брахілог , 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них і розглянути всі можливі способи вставити роздільники. Тоді ми підсумовуємо 1s у кожному розділі. Приклад для n = 3:

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

Я спробував використати декартовий продукт для генерування всіх цих роздільників, але це в 21 байт. Натомість я повернувся до цієї старої техніки для генерації енергетичних наборів (це засновано на старій відповіді Денніса, але зараз я не можу її знайти). Ідея така: генерувати всі розділи ми можемо починати із порожнього списку. Тоді nми можемо прийняти бінарне рішення: або додаємо a 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 байт

Збережено 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

Спробуйте в Інтернеті!

Відповідний розчин на 2 байти коротший за два рази .

2 придатних , 10 байт

>GLNãvyOQ—

Спробуйте в Інтернеті!

Haskell, 41 байт

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

Не найкоротше рішення Haskell, але мені подобається, що воно не використовує [..]діапазони. Натомість він рекурсивно обчислює розділи nяк розділи n-1з новим 1 на початку або з першим значенням вище. Це чітко пояснює, чому 2^(n-1)їх є.

Математика, 53 байти

Не перемагає відповідь Мартіна Ендера, який використовує вбудовану IntegerPartitionsфункцію (і вбудовані мною цілком добре). (Також це не перемагає відповідь 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в передній панелі), і замінює його на! (який ми будемо використовувати як одинарний показник нашого виводу), а потім решту 1s у цьому рядку (це збільшує останнє значення). Потім на іншому рядку ( ¶) він друкує префікс поточного рядка, за ним ,!, який вставляє роздільник і потім запускає наступне значення у 1.

3 етап

!+
$.&

Це перетворює прогони !десяткових цілих чисел, замінюючи їх довжиною.

Етап 4

A`^,

І нарешті, ми помічаємо, що ми генерували вдвічі більше рядків, ніж хотіли, і половина з них починається з ,(тих, де ми спочатку приймали рішення про розщеплення, хоча після цього ще не було нічого розбивати). Тому ми відкидаємо всі рядки, які починаються з а ,.

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

Луа 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);

-4 байт для print_r($r);замість 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));

Prolog, 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.)@^<:

Працює, розділяючи список унарних n , використовуючи двійкові значення 2 ⁿ .

Спробуйте в Інтернеті!

Пояснення

#&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`Σ╜=`░

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.

Власне, 17 16 15 байт

Це цікава вилка відповіді CJam Мартіна Ендера (одна з декартовим продуктом), з різницею в реалізації, яку я вважав цікавою. Коли одна з рядків Мартіна починається з приростом, помилки не дозволяють оцінювати цей рядок. Насправді помилка придушена, а рядок оцінюється все одно. Це в кінцевому підсумку дає композиції кожного kв асортименті [1..n].

Замість того, щоб спробувати видалити зайві композиції, я взяв на себе n-1силу "1u"декарту, доданого "1"до початку кожного рядка. Ця хитрість дає лише композиції оn . Це, на жаль, довше, ніж відповідь Мартіна.

Пропозиції з гольфу вітаються. Спробуйте в Інтернеті!

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.