Обчисліть розділи 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]]

Каталог

Фрагмент стека внизу цієї публікації генерує каталог з відповідей а) як список найкоротших варіантів для кожної мови та б) як загальний таблиця лідерів.

Щоб переконатися, що ваша відповідь відображається, будь ласка, почніть свою відповідь із заголовка, використовуючи наступний шаблон Markdown:

## Language Name, N bytes

де Nрозмір вашого подання. Якщо ви покращите свій рахунок, ви можете зберегти старі бали у заголовку, прокресливши їх. Наприклад:

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



2
Чи можете ви пояснити, що ви маєте на увазі під ручкою ?
Денніс

@flawr Я не згоден - пошук усіх розділів достатньо відрізняється від пошуку суворих розділів. Однак, це може бути цілеспрямованою ціллю.
Мего

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

Чи можете ви уточнити, що ви маєте на увазі під буїтіном ?
Leaky Nun

Відповіді:


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

Спробуйте його онлайн тут.


{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

Піт, 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
Приємно, що концепція точок розділення - це дуже розумний спосіб вирішити це.
Нік

@Nick Дякую! І ласкаво просимо на (активний) цей сайт! :-)
Луїс Мендо


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

Пітон, 65 байт

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

Пітон 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майже миттєво.


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дає лише порожню секцію.




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 він працює близько секунди на моїй машині.

Пояснення

Цей виклик одразу став схожим на роботу для каталогу ( {) та Cut ( ;.). Контур алгоритму:

  • Створіть усі масиви довжиною 0-1 n.
  • Для кожного з них виріжте nматрицю довжини матриці вздовж 1s та перерахуйте довжини кожної частини.
  • Сортуйте довжини та видаліть з результату повторювані масиви.

Мабуть, таку ж ідею мав і Луїс Мендо .

Пояснення коду:

[:~.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.

Дуже приємно використовувати зріз ;.знову.
миль

1

Брахілог , 33 байти ( неконкурентоспроможний )

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

Це не змагається через виправлення помилок.

15На моїй машині це займає близько 1 секунди . Для 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
    

1

Математика, 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 = n . FrobeniusSolveздатний знайти всі рішення цього рівняння, які використовуються для створення стільки копій відповідних значень, щоб знайти всі цілі розділи n .


... а як це не вбудований?
Leaky Nun

@LeakyNun FrobeniusSolveне знаходить цілих розділів, він знаходить усі рішення невід'ємних цілих чисел x1 ... xN до рівнянь форми та a1 x1 + a2 x2 + ... aN xN = bзаданої форми . a1 ... aNb
миль

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]

Порт рішення Python @ xnor. (Якби я лише помітив, що ви можете повторитись mтак само, як і n...)

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.