OEIS A000009 conta il numero di partizioni rigide degli interi. Una partizione rigorosa di un numero intero non negativo nè un insieme di numeri interi positivi (quindi non è consentita la ripetizione e l'ordine non importa) a cui si sommano n.

Ad esempio, 5 ha tre partizioni rigide: 5, 4,1, e 3,2.

10 ha dieci partizioni:

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

Sfida

Dato un numero intero non negativo n<1000, genera il numero di partizioni rigorose che ha.

Casi test:

0 -> 1

42 -> 1426

Ecco un elenco dei numeri di partizione rigorosi da 0 a 55, da 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]

Questo è code-golf , quindi vince la soluzione più breve in byte.

Mathematica, 11 byte

PartitionsQ

Caso di prova

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

Pyth, 7 byte

l{I#./Q

Provalo online. Suite di test.

• Prendi l'input ( Q).
• Trova le sue partizioni (./ ).
• Filtrare ( #) su uniquify ({ ) non cambiando ( I) la partizione. Ciò rimuove le partizioni con i duplicati.
• Trova la lunghezza del risultato ( l).

Haskell, 39 byte

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

La funzione (:[0])converte un numero kin elenco [k,0]. Così,

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

calcola il prodotto cartesiano di [1,0],[2,0],...,[n,0], che fornisce tutti i sottoinsiemi di [1..n]0 che rappresentano elementi omessi. Le partizioni rigide ncorrispondono a tali elenchi con la somma n. Tali elementi sono conteggiati da una comprensione dell'elenco, che è più breve di length.filter.

ES6, 64 byte

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

Funziona mediante sottrazione di prova ricorsiva. kè il numero che è stato sottratto per ultimo e il numero successivo da sottrarre deve essere maggiore (ma non così grande da non poter sottrarre un numero ancora maggiore). 1 viene aggiunto perché è sempre possibile sottrarre nse stesso. (Anche dal momento che questo è ricorsivo, devo fare attenzione che tutte le mie variabili siano locali.)

Python, 68 byte

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

Basta chiamare la funzione anonima che passa l'intero non negativo ncome argomento ... e attendere la fine dell'universo.

Python 2, 49 byte

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

I rami ricorsione ad ogni potenziale addendo kda 1a ndecidere se dovrebbe essere incluso. Ogni summand incluso viene sottratto dalla somma desiderata ne alla fine, se n=0rimane, viene contato quel percorso.

Haskell, 43 byte

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

La funzione binaria n%kconta il numero di partizioni rigorose nin parti con una parte massima k, quindi la funzione desiderata èf n=n%n . Ogni valore kpuò essere incluso, che diminuisce ndi k, o escluso, e in entrambi i casi il nuovo massimo kè uno inferiore, dando la ricorsione n%k=n%(k-1)+(n-k)%(k-1).

Julia, 53 byte

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

Questa è una funzione anonima che accetta un numero intero e restituisce un numero intero. Per chiamarlo, assegnarlo a una variabile.

Otteniamo le partizioni intere usando partitions, filtersolo quelle con somme distinte, collectin un array e troviamo l'ultimo indice (cioè la lunghezza) usando endof.

Haskell, 58 byte

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

Esempio di utilizzo: map h [0..10]-> [1,1,1,2,2,3,4,5,6,8,10].

È un semplice approccio a forza bruta. Controlla le somme di tutte le sottosequenze di 1..x. Questo funziona anche per x == 0, perché tutte le sottosequenze di [1..0]sono [[]]e la somma di []è 0.

05AB1E , 8 byte

ÅœʒDÙQ}g

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

LæOQO

Provalo online!

Nota: questo è estremamente lento e scadrà per gli input superiori a circa 20.

Spiegazione:

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