OEIS A000009 считает количество строгих разделов целых чисел. Строгое разбиение неотрицательного целого числа nявляется множество натуральных чисел (так что не повторение не допускается, и порядок не имеет значения) , что сумма к n.

Например, 5 имеет три раздела: строгие 5, 4,1и 3,2.

10 имеет десять разделов:

10
9,1
8,2
7,3
6,4
7,2,1
6,3,1
5,4,1
5,3,2
4,3,2,1

Вызов

Если задано неотрицательное целое число n<1000, выведите количество строгих разделов.

Тестовые случаи:

0 -> 1

42 -> 1426

Вот список строгих номеров разделов от 0 до 55 от OEIS:

[1,1,1,2,2,3,4,5,6,8,10,12,15,18,22,27,32,38,46,54,64,76,89,104,122,142,165,192,222,256,296,340,390,448,512,585,668,760,864,982,1113,1260,1426,1610,1816,2048,2304,2590,2910,3264,3658,4097,4582,5120,5718,6378]

Это код-гольф , поэтому выигрывает самое короткое решение в байтах.

Mathematica, 11 байт

PartitionsQ

Прецедент

PartitionsQ@Range[10]
(* {1,1,2,2,3,4,5,6,8,10} *)

Pyth, 7 байт

l{I#./Q

Попробуйте онлайн. Тестирование.

• Возьмите вход ( Q).
• Найдите его разделы ( ./).
• Фильтруйте его ( #) по uniquify ( {), не изменяя ( I) раздел. Это удаляет разделы с дубликатами.
• Найдите длину результата ( l).

Haskell, 39 байт

f n=sum[1|x<-mapM(:[0])[1..n],sum x==n]

Функция (:[0])преобразует число kв список [k,0]. Так,

mapM(:[0])[1..n]

вычисляет декартово произведение [1,0],[2,0],...,[n,0], которое дает все подмножества [1..n]с нулями, обозначающими пропущенные элементы. Строгие разбиения nсоответствуют таким спискам с суммой n. Такие элементы подсчитываются по списку, который короче, чем length.filter.

ES6, 64 байта

f=(n,k=0)=>[...Array(n)].reduce((t,_,i)=>n-i>i&i>k?t+f(n-i,i):t,1)

Работы по рекурсивному пробному вычитанию. kэто число, которое вычиталось последним, и следующее число, которое должно быть вычтено, должно быть больше (но не настолько большим, чтобы нельзя было вычесть еще большее число). 1 добавлен, потому что вы всегда можете вычесть nсебя. (Также, поскольку это рекурсивно, я должен позаботиться о том, чтобы все мои переменные были локальными.)

Python, 68 байт

p=lambda n,d=0:sum(p(n-k,n-2*k+1)for k in range(1,n-d+1))if n else 1

Просто вызовите анонимную функцию, передающую неотрицательное целое число в nкачестве аргумента ... и дождитесь конца юниверса.

Python 2, 49 байт

f=lambda n,k=1:n/k and f(n-k,k+1)+f(n,k+1)or n==0

Рекурсия разветвляется на каждое потенциальное слагаемое kот 1до, nчтобы решить, следует ли его включать. Каждое включенное слагаемое вычитается из требуемой суммы n, и в конце, если n=0остается, этот путь подсчитывается.

Haskell, 43 байта

0%0=1
_%0=0
n%k=n%(k-1)+(n-k)%(k-1)
f n=n%n

Бинарная функция n%kподсчитывает количество строгих разбиений nна части с максимальной частью k, поэтому желаемой функцией является f n=n%n. Каждое значение kможет быть включена, которая уменьшается nс k, или исключены, и в любом случае новый максимум kодин ниже, давая рекурсиюn%k=n%(k-1)+(n-k)%(k-1) .

Юлия, 53 байта

n->endof(collect(filter(p->p==∪(p),partitions(n))))

Это анонимная функция, которая принимает целое число и возвращает целое число. Чтобы вызвать его, присвойте его переменной.

Мы получаем целые разделы , используя partitions, filterтолько те , с различными слагаемыми, collectв массив, и найти последний индекс (т.е. длину) с использованием endof.

Haskell, 58 байт

import Data.List
h x=sum[1|i<-subsequences[1..x],sum i==x]

Пример использования: map h [0..10]->[1,1,1,2,2,3,4,5,6,8,10] .

Это простой метод грубой силы. Проверьте суммы всех подпоследовательностей 1..x. Это x == 0тоже работает, потому что все подпоследовательности [1..0]являются [[]]и сумма []является 0.

05AB1E , 8 байтов

ÅœʒDÙQ}g

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

Ŝ          # Get all integer partitions of the (implicit) input
            #  i.e. 5 → [[1,1,1,1,1],[1,1,1,2],[1,1,3],[1,2,2],[1,4],[2,3],[5]]
  ʒ   }     # Filter by:
   D        #  Duplicate the current partition
    Ù       #  Uniquify (removing any duplicated values from) this copied partition
            #   i.e. [1,1,1,1,1] → [1]
            #   i.e. [1,4] → [1,4]
     Q      #  Check if it's still the same
            #   i.e. [1,1,1,1,1] and [1] → 0 (falsey)
            #   i.e. [1,4] and [1,4] → 1 (truthy)
       g    # Then take the length of the filtered list (and implicitly output it)
            #  i.e. [[1,4],[2,5],[5]] → 3

05AB1E , 5 байтов

LæOQO

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

Примечание: это очень медленно и будет превышено время ожидания для входов больше 20.

Объяснение:

L         # range 1..input
 æ        # list of subsets
  O       # sum each subset
   Q      # equal? (1 for each sum that equals the input, 0 otherwise)
    O     # sum the booleans