Рассчитать разбиения N

22

Ваша задача проста: Дано целое число N , Ouput каждый список положительных целых чисел, сумм к N . Например, если ввод был 5, вы должны вывести

[1, 1, 1, 1, 1]
[1, 1, 1, 2]
[1, 1, 3]
[1, 2, 2]
[1, 4]
[2, 3]
[5]

Эти списки не должны выводиться в каком-либо определенном порядке, равно как и числа внутри каждого списка. Например, это также будет приемлемым выводом для '5':

[1, 1, 1, 2]
[5]
[3, 1, 1]
[2, 1, 2]
[4, 1]
[1, 1, 1, 1, 1]
[2, 3]

Вы можете смело предположить, что ввод будет положительным целым числом, и вы можете взять это число в любом разумном формате.

Вы не можете использовать любые встроенные функции, которые делают это.

Если ваша программа либо дает сбой, либо занимает слишком много времени для большого N, это нормально, но вы должны как минимум вывести правильный вывод для первых 15.

Применяются стандартные лазейки, и выигрывает самый короткий ответ в байтах!

Тест IO

1:
[[1]]

2:
[[1, 1], [2]]

3:
[[1, 1, 1], [1, 2], [3]]

4:
[[1, 1, 1, 1], [1, 1, 2], [1, 3], [2, 2], [4]]

5:
[[1, 1, 1, 1, 1], [1, 1, 1, 2], [1, 1, 3], [1, 2, 2], [1, 4], [2, 3], [5]]

7:
[[1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 2], [1, 1, 1, 1, 3], [1, 1, 1, 2, 2], [1, 1, 1, 4], [1, 1, 2, 3], [1, 1, 5], [1, 2, 2, 2], [1, 2, 4], [1, 3, 3], [1, 6], [2, 2, 3], [2, 5], [3, 4], [7]]

10:
[[1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 2], [1, 1, 1, 1, 1, 1, 1, 3], [1, 1, 1, 1, 1, 1, 2, 2], [1, 1, 1, 1, 1, 1, 4], [1, 1, 1, 1, 1, 2, 3], [1, 1, 1, 1, 1, 5], [1, 1, 1, 1, 2, 2, 2], [1, 1, 1, 1, 2, 4], [1, 1, 1, 1, 3, 3], [1, 1, 1, 1, 6], [1, 1, 1, 2, 2, 3], [1, 1, 1, 2, 5], [1, 1, 1, 3, 4], [1, 1, 1, 7], [1, 1, 2, 2, 2, 2], [1, 1, 2, 2, 4], [1, 1, 2, 3, 3], [1, 1, 2, 6], [1, 1, 3, 5], [1, 1, 4, 4], [1, 1, 8], [1, 2, 2, 2, 3], [1, 2, 2, 5], [1, 2, 3, 4], [1, 2, 7], [1, 3, 3, 3], [1, 3, 6], [1, 4, 5], [1, 9], [2, 2, 2, 2, 2], [2, 2, 2, 4], [2, 2, 3, 3], [2, 2, 6], [2, 3, 5], [2, 4, 4], [2, 8], [3, 3, 4], [3, 7], [4, 6], [5, 5], [10]]

Супер большой тестовый пример: 15 должен вывести это

[[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, 2], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5], [1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2], [1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 4], [1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3], [1, 1, 1, 1, 1, 1, 1, 1, 1, 6], [1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3], [1, 1, 1, 1, 1, 1, 1, 1, 2, 5], [1, 1, 1, 1, 1, 1, 1, 1, 3, 4], [1, 1, 1, 1, 1, 1, 1, 1, 7], [1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2], [1, 1, 1, 1, 1, 1, 1, 2, 2, 4], [1, 1, 1, 1, 1, 1, 1, 2, 3, 3], [1, 1, 1, 1, 1, 1, 1, 2, 6], [1, 1, 1, 1, 1, 1, 1, 3, 5], [1, 1, 1, 1, 1, 1, 1, 4, 4], [1, 1, 1, 1, 1, 1, 1, 8], [1, 1, 1, 1, 1, 1, 2, 2, 2, 3], [1, 1, 1, 1, 1, 1, 2, 2, 5], [1, 1, 1, 1, 1, 1, 2, 3, 4], [1, 1, 1, 1, 1, 1, 2, 7], [1, 1, 1, 1, 1, 1, 3, 3, 3], [1, 1, 1, 1, 1, 1, 3, 6], [1, 1, 1, 1, 1, 1, 4, 5], [1, 1, 1, 1, 1, 1, 9], [1, 1, 1, 1, 1, 2, 2, 2, 2, 2], [1, 1, 1, 1, 1, 2, 2, 2, 4], [1, 1, 1, 1, 1, 2, 2, 3, 3], [1, 1, 1, 1, 1, 2, 2, 6], [1, 1, 1, 1, 1, 2, 3, 5], [1, 1, 1, 1, 1, 2, 4, 4], [1, 1, 1, 1, 1, 2, 8], [1, 1, 1, 1, 1, 3, 3, 4], [1, 1, 1, 1, 1, 3, 7], [1, 1, 1, 1, 1, 4, 6], [1, 1, 1, 1, 1, 5, 5], [1, 1, 1, 1, 1, 10], [1, 1, 1, 1, 2, 2, 2, 2, 3], [1, 1, 1, 1, 2, 2, 2, 5], [1, 1, 1, 1, 2, 2, 3, 4], [1, 1, 1, 1, 2, 2, 7], [1, 1, 1, 1, 2, 3, 3, 3], [1, 1, 1, 1, 2, 3, 6], [1, 1, 1, 1, 2, 4, 5], [1, 1, 1, 1, 2, 9], [1, 1, 1, 1, 3, 3, 5], [1, 1, 1, 1, 3, 4, 4], [1, 1, 1, 1, 3, 8], [1, 1, 1, 1, 4, 7], [1, 1, 1, 1, 5, 6], [1, 1, 1, 1, 11], [1, 1, 1, 2, 2, 2, 2, 2, 2], [1, 1, 1, 2, 2, 2, 2, 4], [1, 1, 1, 2, 2, 2, 3, 3], [1, 1, 1, 2, 2, 2, 6], [1, 1, 1, 2, 2, 3, 5], [1, 1, 1, 2, 2, 4, 4], [1, 1, 1, 2, 2, 8], [1, 1, 1, 2, 3, 3, 4], [1, 1, 1, 2, 3, 7], [1, 1, 1, 2, 4, 6], [1, 1, 1, 2, 5, 5], [1, 1, 1, 2, 10], [1, 1, 1, 3, 3, 3, 3], [1, 1, 1, 3, 3, 6], [1, 1, 1, 3, 4, 5], [1, 1, 1, 3, 9], [1, 1, 1, 4, 4, 4], [1, 1, 1, 4, 8], [1, 1, 1, 5, 7], [1, 1, 1, 6, 6], [1, 1, 1, 12], [1, 1, 2, 2, 2, 2, 2, 3], [1, 1, 2, 2, 2, 2, 5], [1, 1, 2, 2, 2, 3, 4], [1, 1, 2, 2, 2, 7], [1, 1, 2, 2, 3, 3, 3], [1, 1, 2, 2, 3, 6], [1, 1, 2, 2, 4, 5], [1, 1, 2, 2, 9], [1, 1, 2, 3, 3, 5], [1, 1, 2, 3, 4, 4], [1, 1, 2, 3, 8], [1, 1, 2, 4, 7], [1, 1, 2, 5, 6], [1, 1, 2, 11], [1, 1, 3, 3, 3, 4], [1, 1, 3, 3, 7], [1, 1, 3, 4, 6], [1, 1, 3, 5, 5], [1, 1, 3, 10], [1, 1, 4, 4, 5], [1, 1, 4, 9], [1, 1, 5, 8], [1, 1, 6, 7], [1, 1, 13], [1, 2, 2, 2, 2, 2, 2, 2], [1, 2, 2, 2, 2, 2, 4], [1, 2, 2, 2, 2, 3, 3], [1, 2, 2, 2, 2, 6], [1, 2, 2, 2, 3, 5], [1, 2, 2, 2, 4, 4], [1, 2, 2, 2, 8], [1, 2, 2, 3, 3, 4], [1, 2, 2, 3, 7], [1, 2, 2, 4, 6], [1, 2, 2, 5, 5], [1, 2, 2, 10], [1, 2, 3, 3, 3, 3], [1, 2, 3, 3, 6], [1, 2, 3, 4, 5], [1, 2, 3, 9], [1, 2, 4, 4, 4], [1, 2, 4, 8], [1, 2, 5, 7], [1, 2, 6, 6], [1, 2, 12], [1, 3, 3, 3, 5], [1, 3, 3, 4, 4], [1, 3, 3, 8], [1, 3, 4, 7], [1, 3, 5, 6], [1, 3, 11], [1, 4, 4, 6], [1, 4, 5, 5], [1, 4, 10], [1, 5, 9], [1, 6, 8], [1, 7, 7], [1, 14], [2, 2, 2, 2, 2, 2, 3], [2, 2, 2, 2, 2, 5], [2, 2, 2, 2, 3, 4], [2, 2, 2, 2, 7], [2, 2, 2, 3, 3, 3], [2, 2, 2, 3, 6], [2, 2, 2, 4, 5], [2, 2, 2, 9], [2, 2, 3, 3, 5], [2, 2, 3, 4, 4], [2, 2, 3, 8], [2, 2, 4, 7], [2, 2, 5, 6], [2, 2, 11], [2, 3, 3, 3, 4], [2, 3, 3, 7], [2, 3, 4, 6], [2, 3, 5, 5], [2, 3, 10], [2, 4, 4, 5], [2, 4, 9], [2, 5, 8], [2, 6, 7], [2, 13], [3, 3, 3, 3, 3], [3, 3, 3, 6], [3, 3, 4, 5], [3, 3, 9], [3, 4, 4, 4], [3, 4, 8], [3, 5, 7], [3, 6, 6], [3, 12], [4, 4, 7], [4, 5, 6], [4, 11], [5, 5, 5], [5, 10], [6, 9], [7, 8], [15]]

Каталог

Фрагмент стека в нижней части этого поста создает каталог из ответов а) в виде списка кратчайшего решения для каждого языка и б) в качестве общей таблицы лидеров.

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

## Language Name, N bytes

где Nразмер вашего представления. Если вы улучшите свой счет, вы можете сохранить старые результаты в заголовке, вычеркнув их. Например:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Показать фрагмент кода

code-golf  math  number-theory  combinatorics  integer-partitions 
— DJMcMayhem
источник
1
— DJMcMayhem
2
Не могли бы вы уточнить, что вы имеете в виду под ручкой ?
— Деннис
@flawr Я не согласен - поиск всех разделов достаточно отличается от поиска строгих разделов. Тем не менее, этот может быть обманчивой целью.
— Мего
Я думаю, что поиск неупорядоченных разделов и не ограничение количества частей делает это достаточно другим.
— xnor
Можете ли вы уточнить, что вы подразумеваете под буитином ?
— Утренняя монахиня

Ответы:

6

Pyth, 10 9 байтов

{SMlMM./U

Не слишком уверен, что это не обман, но в правилах сказано, что нельзя использовать целочисленное разбиение (это не указано четко в самом вопросе, но комментарий ОП в вопросе говорит о целочисленном разбиении). Я использую раздел списка строк , который создает фрагменты списка, которые соединяются до «материнского» списка. Я считаю, что должен поблагодарить @Maltysen за идею использования списков, а не строк.

n = 15 занимает меньше одной секунды на моей машине.

В псевдокоде потока данных:

              input       // initial data
        U     range       // makes a list of length equal to input
      ./      partition   // partitions string
   lMM        length      // length of each substring in each way to partition
 SM           sort        // sort each way to partition
{             deduplicate // removes all duplicate after sorting
              print       // implicit, output final result

Попробуйте это онлайн здесь.

— busukxuan
источник
{mSlMd./*Nсохраняет байт
— Leaky Nun
Вы можете перейти на 7 байтов, если вы используете разделение списка вместо строкового раздела: pyth.herokuapp.com/?code=sMM.%2Fm1&input=5&debug=0
— Maltysen
@ LeakyNun Ну, на самом деле я пытался, и это не спасло байт. Когда я увидел ваш комментарий, я обнаружил, что мой ответ на самом деле был 10 байтами, поэтому я фактически не учел (забыл блоки gedit начинаются с 1).
— Busukxuan
@Maltysen Вам нужно отсортировать каждый подсписок, а затем дедуплицировать.
— Busukxuan
@ Maltysen Вы были правы, использование списков сокращает его. Я попытался добавить сортировку и дедупликацию в код, на который вы ссылались, и это не помогло, но все благодаря вам, у меня появилась идея заменить * N на U. Спасибо!
— Busukxuan
6

Pyth, 18 байт

L?b{SM+R-bsdsyMb]Y

Попробуйте онлайн! (В yконце используется для вызова функции)

Это довольно быстро.

Это использует рекурсию. Если ввод b, мой метод будет генерировать разделы из 0в b-1, а затем генерировать правильные разделы из каждого.

Например, когда b=4:

  • b=0 дает [[]]
  • b=1 дает [[1]]
  • b=2 дает [[2], [1, 1]]
  • b=3 дает [[3], [1, 2], [1, 1, 1]]

Затем, к каждому разделу в b=0, добавьте 4(чтобы получить сумму 4); к каждому разделу в b=1, добавить 3(чтобы сделать сумму 4); и т.п.

Это в основном, как это работает.

L?b{SM+R-bsdsyMb]Y

L                    define a function called "y" which takes an argument: "b"
 ?b                  test for truthiness of b (in this case, test if b>0).


   {SM+R-bsdsyMb     if truthy:

             yMb         call this function from 0 to b-1.
            s            unpack each list of partitions, generating only partitions.
      +R                 to each partition (d), append:
        -                    the difference of
         b                   b (the argument) and
          sd                 the sum of d (the partition).
    SM                   sort each partition.
   {                     remove duplicates.


                ]Y   if falsey:

                 Y       yield [].
                ]        yield [[]].
— Дрянная Монахиня
источник
5

MATL , 20 байтов

:"0Gq:@XNG3$Yc!dS!Xu

Попробуйте онлайн!

Для ввода 15требуется около 2 секунд в онлайн-компиляторе.

объяснение

Это работает путем генерации точек разбиения и последующего преобразования в длины разделов . Под этим я подразумеваю следующее. При заданном входе N = 5 возможное разбиение будет [2 2 1]. Это представлено точками разбиения [0 2 4 5], так что последовательные различия (или длины) точек разбиения дают результирующее разбиение входного номера.

Все массивы точек разбиения начинаются с 0 и заканчиваются N . Число k промежуточных точек варьируется от 0 до N -1. Для заданных N и k промежуточные точки могут быть сгенерированы как комбинация чисел [1, 2, ..., N -1], взятых k за раз.

Несколько массивов точек разбиения могут привести к одному и тому же результату в другом порядке. Например, точки разбиения [0 1 3 5] дадут длины разбиения [1 2 2], т. Е. Такие же, как предыдущие [2 2 1], только в другом порядке. Это необходимо учитывать, сортируя каждый массив длин разделов и удаляя дубликаты .

:        % Implicitly input N. Push [1 2 ... N]. These are the possible values of k,
         % except with N instead of 0
"        % For each
  0      %   Push 0
  Gq:    %   Push [1 ... N-1]. These the possible intermediate points
  @XN    %   Push k and produce the combinations. Each k produces a 2D array with
         %   each combination on a row. The value k=N produces an empty array
  G      %   Push N
  3$Yc   %   Prepend a column of zeros and append a column of N to the array
  !d     %   Transpose. Consecutive differences of each column
  S!     %   Sort each column. Transpose
  Xu     %   Keep only unique rows
         % Implicitly end for and display all arrays in the stack
— Луис Мендо
источник
1
Хорошо, концепция точек разбиения - очень умный способ решить эту проблему.
— Ник
@ Ник Спасибо! И добро пожаловать (будучи активным) на этот сайт! :-)
— Луис Мендо
5

J, 49 42 36 35 32 байта

a:1&([:~.@,(,;}./:~@,(+{.))&>)~]

Сейчас молчаливо!

Создает целочисленное разбиение n , создавая целочисленные разбиения от 1 до n . Вычисляет результат для n = 15 в миллисекундах.

Начиная с начального целочисленного раздела, [[1]]который соответствует n = 1, создайте следующий целочисленный раздел, соединив результаты двух операций: добавление 1 к каждому разделу; увеличивая наименьшее значение на 1 в каждом разделе. Конечно, дубликаты разделов будут удалены. Чтобы получить целочисленный раздел n = 2 и далее,

Partition for n = 1
[[1]]

Partition for n = 2
[[1, 1]] join [[2]]
= [[1, 1], [2]]

Partition for n = 3
[[1, 2], [1, 1, 1]] join [[3], [1, 2]]
= [[3], [1, 2], [1, 1, 1]]

... and so on

использование

   f =: a:1&([:~.@,(,;}./:~@,(+{.))&>)~]
   f 1
┌─┐
│1│
└─┘
   f 2
┌───┬─┐
│1 1│2│
└───┴─┘
   f 3
┌─────┬───┬─┐
│1 1 1│1 2│3│
└─────┴───┴─┘
   f 5
┌─────────┬───────┬─────┬───┬─────┬───┬─┐
│1 1 1 1 1│1 1 1 2│1 2 2│2 3│1 1 3│1 4│5│
└─────────┴───────┴─────┴───┴─────┴───┴─┘
   # f 15
176

объяснение

Поскольку J не поддерживает рваные массивы, каждый раздел должен быть упакован, чтобы они не были дополнены нулями при добавлении к другим разделам.

a:1&([:~.@,(,;}./:~@,(+{.))&>)~]  Input: n
a:                                The empty box
                               ]  Get the input n
  1&(                        )~   Repeat n times with an initial array of one empty box
           (              )&>       Operate on each partition
                     (   )            Hook a partition
                       {.               Get its head (the smallest value)
  1                   +                 Add 1 to it
  1           }.                      Drop the first value in each partition
                    ,                 Join the previous two results
                /:~@                  Sort it
  1         ,                         Prepend a 1 to the initial partition
             ;                        Box the last two results and join them
     [:   ,                         Flatten the pairs of boxes
       ~.@                          Remove duplicates and return
                                  Return the final result where each box
                                  is a partition of n
— миль
источник
4

Python, 65 байт

Python 3

def f(n,i=1,l=[]):n or print(l);i>n or[f(n-i,i,[i]+l),f(n,i+1,l)]

Эта функция накапливает раздел и печатает выходные данные, разветвляясь на выбор. Он решает, сколько 1 нужно поместить в раздел, сколько 2 и так далее. Для каждого значенияi оно либо

  • Добавляет часть размера iи уменьшаетn до n-iили
  • Переходит к i+1

Если i>n, тогда больше не могут быть сделаны детали, поэтому он останавливается. Если nпадает до0 , раздел будет успешным и будет напечатан.

Python 2

f=lambda n,i=1:n/i and[l+[i]for l in f(n-i,i)]+f(n,i+1)or[[]][n:]

Рекурсивный метод, который выводит список разделов. Как и в коде Python 3, он подсчитывает размер частиi и на каждом шаге решает, добавлять ли другую часть размера iили останавливать.

Оба из них делают n=15почти мгновенно.

— XNOR
источник
3

Javascript, 194 байта

p=n=>{var a=[];for(var i=1;i<=n-i;i+=1){for(v of p(n-i)){v.push(i);a.push(v.sort())}}a.push([n]);return a};n=5;s=p(n).map(v=>JSON.stringify(v));s=s.filter((v,i)=>s.indexOf(v)==i);console.log(s);

Номера уменьшенная

Поиск уникальных объектов путем сортировки и сравнения со строкой является довольно хакерским, но, вероятно, экономит место.

p = n => {
    var a = [];

    for (var i = 1; i <= n-i; i++)
    {
        for (v of p(n-i)) {
            v.push(i);
            a.push(v.sort());
        }
    }

    a.push([n]);

    return a;
}

n = 5;
s = p(n).map(v =>  JSON.stringify(v));
s = s.filter((v,i) => s.indexOf(v) == i);
console.log(s);
— Ник
источник
4
Quite a hack but saves spaceЭто именно то, о чем этот сайт. : D
— DJMcMayhem
2

Python 3.5, 82 72 байта

f=lambda n:{(*sorted([*p,i]),)for i in range(1,n)for p in f(n-i)}|{(n,)}

Возвращает набор кортежей. n = 15 заканчивается мгновенно.

Проверьте это на repl.it .

— Деннис
источник
2

Haskell, 44 байта

0%m=[[]]
n%m=[j:r|j<-[m..n],r<-(n-j)%j]
(%1)

Вспомогательная функция n%mдает разбиение nна части ≥m, используя основную функцию m=1. Это ветви каждой первой записи jсm≤j≤n , рекурсиями на оставшуюся часть раздела n-jна часть , которые являются , по крайней мере j. Базовый случай n==0дает только пустой раздел.

— XNOR
источник
1

Желе , 9 байт

b1ŒṖḅ1Ṣ€Q

Попробуйте онлайн!

Как это работает

b1ŒṖḅ1Ṣ€Q  Main link. Argument: n (integer)

b1         Convert n to unary, i.e., a list A of n 1's.
  ŒṖ       Generate all partitions of the list A.
    ḅ1     Convert each flat list from unary to integer.
      Ṣ€   Sort each resulting list.
        Q  Unique; deduplicate the lists.
— Деннис
источник
1

J, 39 байт

[:~.i.<@\:~@(#;.1~"1 0)1,@{@;(<1 0)#~<:

Это монадический глагол, который принимает целое число и возвращает массив штучных массивов. Попробуй это здесь. Использование:

   p =: [:~.i.<@\:~@(#;.1~"1 0)1,@{@;(<1 0)#~<:
   p 3
+-----+---+-+
|1 1 1|2 1|3|
+-----+---+-+

На входе 15 он работает около секунды на моей машине.

объяснение

Эта задача сразу же выглядела как работа для Catalog ( {) и Cut ( ;.). Схема алгоритма:

  • Произведите все массивы 0-1 длины n.
  • Для каждого из них вырежьте nмассив фиктивных длин вдоль 1 с и перечислите длины каждой части.
  • Отсортируйте длины и удалите дублированные массивы из результата.

Видимо, у Луиса Мендо тоже была такая же идея .

Объяснение кода:

[:~.i.<@\:~@(#;.1~"1 0)1,@{@;(<1 0)#~<:   Input is n.
                                     <:   n-1
                                   #~     copies of
                             (<1 0)       the boxed array [1 0].
                       1    ;             Prepend the boxed array [1].
                          {@              Catalog: produces all combinations of taking one
                                          item from each box, in a high-dimensional matrix.
                        ,@                Flatten the matrix. This results in a list of all
                                          boxed 0-1 arrays of length n that begin with a 1.
    i.                                    The array A =: 0, 1, ..., n-1.
            (     "1 0)                   For each of the boxed arrays B:
              ;.1~                          cut A along the occurrences of 1s in B,
             #                              take the length of each part,
        \:~@                                sort the lengths,
      <@                                    and put the result in a box.
[:~.                                      Remove duplicate boxes.
— Zgarb
источник
Очень хорошее использование резки ;.снова.
— миль
1

Brachylog , 33 байта (не конкурирует)

:1f:oad.
:1eI,.##lI,.:{.>0}a+?,.=

Это не конкурирует из-за исправления ошибки.

Это займет около 1 секунды 15на моей машине. Для 20и больше это вылетает за Out of global stackисключением.

объяснение

При этом не используется никакого встроенного разделения, и вместо этого используется тот факт, что +оба способа работают через распространение ограничений.

  • Основной предикат:

    :1f                       Find the list of all valid outputs of predicate 1
   :oa                    Sort each element of that list
      d.                  Output is that list of sorted lists minus all duplicates

  • Предикат 1:

    :1eI                      I is an integer between Input and 1
    .##lI,                Output is a list of length I
          .:{.>0}a        Elements of Output are integers greater than 0
                  +?,     The sum of the elements of Output is Input
                     .=   Assign values to the elements of Output
— Fatalize
источник
1

Mathematica, 62 54 байта

Inner[#2~Table~#&,FrobeniusSolve[r=Range@#,#],r,Join]&

Разделы целого числа n можно найти, решая для n- наборов неотрицательных целых чисел ( c 1 , c 2 , ..., c n ) таких, что c 1 + 2 c 2 + ... + n c n = п . FrobeniusSolveспособен найти все решения этого уравнения, которые используются для создания такого количества копий их соответствующих значений, чтобы найти все целочисленные разбиения n .

— миль
источник
... а как это не встроенный?
— Утренняя монахиня
@LeakyNun FrobeniusSolveне находит целочисленных разбиений, он находит все решения неотрицательных целых чисел x1 ... xN для уравнений a1 x1 + a2 x2 + ... aN xN = bзаданной формы a1 ... aNи b.
— миль
0

JavaScript (Firefox 30-57) 79 ES6, 65 байт

f=(n,m=1,a=[])=>n?m>n?[]:[...f(n-m,m,[...a,m]),...f(n,m+1,a)]:[a]

Порт решения @ xnor's Python. (Если бы только я заметил, что вы могли бы вернуться, mа также n...)

— Нил
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.