OEIS A000009 conta o número de partições estritas dos números inteiros. Uma partição estrita de um número inteiro não negativo né um conjunto de números inteiros positivos (portanto, nenhuma repetição é permitida e a ordem não importa) que somam isso n.

Por exemplo, 5 tem três partições rígidas: 5, 4,1, e 3,2.

10 tem dez partições:

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

Desafio

Dado um número inteiro não negativo n<1000, produza o número de partições estritas que possui.

Casos de teste:

0 -> 1

42 -> 1426

Aqui está uma lista dos números de partição estritos de 0 a 55, do 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]

Isso é código-golfe , então a solução mais curta em bytes vence.

Mathematica, 11 bytes

PartitionsQ

Caso de teste

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

Pitão, 7 bytes

l{I#./Q

Experimente online. Suíte de teste.

• Pegue a entrada ( Q).
• Encontre suas partições ( ./).
• Filtre-o ( #) em uniquify ( {) não alterando (I ) a partição. Isso remove partições com duplicatas.
• Encontre o comprimento do resultado ( l).

Haskell, 39 bytes

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

A função (:[0])converte um número kna lista [k,0]. Então,

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

calcula o produto cartesiano de [1,0],[2,0],...,[n,0], que fornece todos os subconjuntos [1..n]com zeros para elementos omitidos. As partições estritas de ncorrespondem a essas listas com soma n. Esses elementos são contados por uma compreensão da lista, que é menor que length.filter.

ES6, 64 bytes

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

Trabalhos por subtração de teste recursivo. ké o número que foi subtraído pela última vez e o próximo número a ser subtraído deve ser maior (mas não tão grande que um número ainda maior não possa ser subtraído). 1 é adicionado porque você sempre pode subtrair a nsi próprio. (Além disso, como isso é recursivo, tenho que cuidar para que todas as minhas variáveis ​​sejam locais.)

Python, 68 bytes

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

Apenas chame a função anônima passando o número inteiro não negativo ncomo argumento ... e aguarde o fim do universo.

Python 2, 49 bytes

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

Os ramos de recursão em cada summand potencial kde 1para ndecidir se devem ser incluídas. Cada somamand incluída é subtraída da soma desejada ne, no final, se n=0permanecer, esse caminho é contado.

Haskell, 43 bytes

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

A função binária n%kconta o número de partições estritas de nem partes com uma parte máxima k, portanto a função desejada é f n=n%n. Cada valor kpode ser incluído, o que diminui npor k, ou excluídas, e de qualquer forma o novo máximo ké uma inferior, dando a recursividade n%k=n%(k-1)+(n-k)%(k-1).

Julia, 53 bytes

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

Esta é uma função anônima que aceita um número inteiro e retorna um número inteiro. Para chamá-lo, atribua-o a uma variável.

Nós obtemos as partições inteiras usando partitions, filtersomente para aqueles com summands distintos, collectem uma matriz e encontramos o último índice (ou seja, o comprimento) usando endof.

Haskell, 58 bytes

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

Exemplo de uso: map h [0..10]-> [1,1,1,2,2,3,4,5,6,8,10].

É uma abordagem simples de força bruta. Verifique as somas de todas as subsequências de 1..x. Isso funciona x == 0também porque todas as subsequências de [1..0]são [[]]e a soma de []é 0.

05AB1E , 8 bytes

ÅœʒDÙQ}g

Experimente online ou verifique todos os casos de teste .

Explicação:

Ŝ          # 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 bytes

LæOQO

Experimente online!

Nota: isso é extremamente lento e atingirá o tempo limite de entradas maiores que cerca de 20.

Explicação:

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