OEIS A000009 zählt die Anzahl der strengen Partitionen der ganzen Zahlen. Eine strikte Partition einer nichtnegativen Ganzzahl nist eine Menge positiver Ganzzahlen (daher ist keine Wiederholung zulässig, und die Reihenfolge spielt keine Rolle), zu der sich diese Summe zusammensetzt n.

Zum Beispiel 5 drei strenge Partitionen: 5, 4,1, und 3,2.

10 hat zehn Partitionen:

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

Herausforderung

Geben Sie bei einer nichtnegativen Ganzzahl n<1000 die Anzahl der festgelegten Partitionen aus.

Testfälle:

0 -> 1

42 -> 1426

Hier ist eine Liste der strengen Partitionsnummern von 0 bis 55 von 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]

Das ist Code-Golf , also gewinnt die kürzeste Lösung in Bytes.

Mathematica, 11 Bytes

PartitionsQ

Testfall

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

Pyth, 7 Bytes

l{I#./Q

Probieren Sie es online aus. Testsuite.

• Nimm die Eingabe ( Q).
• Finden Sie seine Partitionen ( ./).
• Filtern Sie es ( #) nach Uniquify ( {), ohne Idie Partition zu ändern ( ). Dadurch werden Partitionen mit Duplikaten entfernt.
• Finde die Länge des Ergebnisses ( l).

Haskell, 39 Bytes

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

Die Funktion (:[0])konvertiert eine Zahl kin die Liste [k,0]. So,

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

berechnet das kartesische Produkt von [1,0],[2,0],...,[n,0], wobei alle Teilmengen von [1..n]mit 0 für ausgelassene Elemente stehen. Die strengen Aufteilungen von nentsprechen solchen Listen mit Summe n. Solche Elemente werden durch ein Listenverständnis gezählt, das kürzer als ist 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)

Funktioniert durch rekursive Versuchssubtraktion. kist die Zahl, die zuletzt subtrahiert wurde, und die nächste zu subtrahierende Zahl muss größer sein (aber nicht so groß, dass eine noch größere Zahl nicht subtrahiert werden kann). 1 wird hinzugefügt, weil Sie sich immer nselbst subtrahieren können. (Da dies auch rekursiv ist, muss ich darauf achten, dass alle meine Variablen lokal sind.)

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

Rufen Sie einfach die anonyme Funktion auf, die die nichtnegative Ganzzahl nals Argument übergibt ... und warten Sie auf das Ende des Universums.

Python 2, 49 Bytes

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

Die Rekursion verzweigt sich bei jedem möglichen Summanden kab, 1um nzu entscheiden, ob sie einbezogen werden soll. Jeder eingeschlossene Summand wird von der gewünschten Summe subtrahiert n, und am Ende n=0wird dieser Pfad gezählt , falls er verbleibt.

Haskell, 43 Bytes

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

Die Binärfunktion n%kzählt die Anzahl der strengen Partitionen nin Teile mit einem maximalen Teil k, daher ist die gewünschte Funktion f n=n%n. Jeder Wert kkann enthalten sein, die abnimmt , ndurch koder ausgeschlossen und so oder so die neue maximalk ist eine untere, die Rekursion zu geben n%k=n%(k-1)+(n-k)%(k-1).

Julia, 53 Bytes

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

Dies ist eine anonyme Funktion, die eine Ganzzahl akzeptiert und eine Ganzzahl zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

Wir bekommen die ganzzahligen Partitionen partitions, filterdie nur diejenigen mit unterschiedlichen Summanden verwenden, collectin ein Array und finden den letzten Index (dh die Länge), der verwendet wird endof.

Haskell, 58 Bytes

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

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

Es ist ein einfacher Brute-Force-Ansatz. Überprüfen Sie die Summen aller Teilfolgen von 1..x. Dies funktioniert x == 0auch, weil alle Teilfolgen von [1..0]sind [[]]und die Summe von []ist 0.

05AB1E , 8 Bytes

ÅœʒDÙQ}g

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Probieren Sie es online!

Hinweis: Dies ist extrem langsam und es tritt eine Zeitüberschreitung bei Eingaben von mehr als etwa 20 auf.

Erläuterung:

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