Ihre Herausforderung ist einfach: Gegeben eine ganze Zahl N , ouput jede Liste von positiven ganzen Zahlen , dass Summen N . Wenn die Eingabe beispielsweise 5 war, sollten Sie sie ausgeben
[1, 1, 1, 1, 1]
[1, 1, 1, 2]
[1, 1, 3]
[1, 2, 2]
[1, 4]
[2, 3]
[5]
Diese Listen müssen weder in einer bestimmten Reihenfolge ausgegeben werden, noch müssen die Nummern in jeder Liste angegeben werden. Dies wäre beispielsweise auch eine akzeptable Ausgabe für '5':
[1, 1, 1, 2]
[5]
[3, 1, 1]
[2, 1, 2]
[4, 1]
[1, 1, 1, 1, 1]
[2, 3]
Sie können davon ausgehen, dass die Eingabe eine positive Ganzzahl ist, und Sie können diese Zahl in jedem vernünftigen Format verwenden.
Sie können nicht alle eingebauten Funktionen , die dies tun.
Wenn Ihr Programm entweder fehlschlägt oder für großes N zu lange dauert, ist dies in Ordnung, aber Sie müssen mindestens die richtige Ausgabe für die ersten 15 erzeugen.
Es gelten Standardlücken und die kürzeste Antwort in Bytes gewinnt!
Testen Sie 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]]
Super großer Testfall: 15 sollten dies ausgeben
[[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]]
Katalog
Das Stapel-Snippet am Ende dieses Beitrags generiert den Katalog aus den Antworten a) als Liste der kürzesten Lösungen pro Sprache und b) als Gesamt-Bestenliste.
Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:
## Language Name, N bytes
Wo N
ist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:
## Ruby, <s>104</s> <s>101</s> 96 bytes
quelle
Antworten:
Pyth,
109 BytesWir sind uns nicht sicher, ob dies kein Betrug ist, aber die Regeln besagen nur, dass keine Ganzzahlpartition verwendet werden kann (dies ist in der Frage selbst nicht klar angegeben, aber ein Kommentar von OP in der Frage besagt Ganzzahlpartition). Ich verwende eine
String-Listen- Partition, die Slices der Liste erstellt, die sich zur "Mutter" -Liste verketten. Ich glaube, ich muss @Maltysen für die Idee danken, Listen anstelle von Strings zu verwenden.n = 15 dauert auf meinem Computer weniger als eine Sekunde.
Im Datenfluss-Pseudocode:
Probieren Sie es hier online aus.
quelle
{mSlMd./*N
speichert ein BytePyth, 18 Bytes
Probieren Sie es online! (Mit dem
y
am Ende wird die Funktion aufgerufen)Das geht ziemlich schnell.
Dies verwendet eine Rekursion. Wenn die Eingabe lautet
b
, generiert meine Methode die Partitionen von0
bisb-1
und anschließend die richtigen Partitionen von jeder Partition.Zum Beispiel, wenn
b=4
:b=0
gibt[[]]
b=1
gibt[[1]]
b=2
gibt[[2], [1, 1]]
b=3
gibt[[3], [1, 2], [1, 1, 1]]
Dann auf jede Partition in
b=0
, append4
(um die Summe 4 zu machen); an jede Partition inb=1
anhängen3
(um die Summe zu bilden4
); etc.So funktioniert es hauptsächlich.
quelle
MATL , 20 Bytes
Probieren Sie es online!
Für die Eingabe
15
benötigt der Online-Compiler ca. 2 Sekunden.Erläuterung
Dies funktioniert , indem Partition zu erzeugen Punkte und dann auf Partition konvertieren Längen . Was ich damit meine, ist das Folgende. Bei Eingabe von N = 5 ist eine mögliche Partition [2 2 1]. Dies wird durch Teilungspunkte [0 2 4 5] dargestellt, so dass aufeinanderfolgende Differenzen auftreten (oder Längen) der Partitionspunkte die resultierende Partition der eingegebenen Nummer ergeben.
Alle Arrays von Trennstellen beginnen mit 0 und enden mit N . Die Anzahl k der Zwischenpunkte variiert von 0 bis N –1. Für N und k gegeben, können die Zwischenpunkte als eine Kombination der Zahlen [1, 2, ..., N -1] erzeugt werden, die k zu einem Zeitpunkt genommen werden.
Mehrere Arrays von Partitionspunkten können in unterschiedlicher Reihenfolge zum gleichen Ergebnis führen. Beispielsweise würden Partitionspunkte [0 1 3 5] die Partitionslängen [1 2 2] ergeben, dh die gleichen wie die vorherigen [2 2 1], nur in einer anderen Reihenfolge. Dies muss berücksichtigt werden, indem jedes Array von Partitionslängen sortiert und Duplikate entfernt werden .
quelle
Haskell, 53 Bytes
quelle
J,
4942363532 BytesEs ist jetzt stillschweigend!
Erstellt die ganzzahlige Partition von n, indem die ganzzahligen Partitionen von 1 bis n erstellt werden . Berechnet das Ergebnis für n = 15 in einer Millisekunde.
Erstellen Sie ausgehend von der anfänglichen ganzzahligen Partition,
[[1]]
die n = 1 entspricht, die nächste ganzzahlige Partition, indem Sie die Ergebnisse aus zwei Operationen zusammenfassen: Fügen Sie an jede Partition eine 1 an; Inkrementieren des kleinsten Werts in jeder Partition um 1. Natürlich werden doppelte Partitionen entfernt. Um die ganzzahlige Partition n = 2 und weiter zu erhalten,Verwendung
Erläuterung
Da J keine unregelmäßigen Arrays unterstützt, muss jede Partition in ein Kästchen gesetzt werden, damit sie nicht mit Nullen aufgefüllt werden, wenn sie an andere Partitionen angehängt werden.
quelle
Python, 65 Bytes
Python 3
Diese Funktion sammelt eine Partition und druckt die Ausgaben, wobei nach Auswahl verzweigt wird. Es entscheidet, wie viele Einsen in die Partition eingefügt werden, wie viele Zweisen und so weiter. Für jeden Wert
i
ist es entwederi
und verringert sichn
aufn-i
oderi+1
Wenn
i>n
dann keine Teile mehr hergestellt werden können, so hört es auf. Wenn dies dern
Fall ist,0
ist die Partition erfolgreich und wird gedruckt.Python 2
Eine rekursive Methode, die eine Liste von Partitionen ausgibt. Wie beim Python 3-Code wird die Teilegröße hochgezählt
i
und bei jedem Schritt entschieden, ob ein weiterer Teil der Größe hinzugefügti
oder gestoppt werden soll.Beides geschieht
n=15
fast augenblicklich.quelle
Javascript, 194 Bytes
Nicht minimiert
Das Finden von Unikaten durch Sortieren und Vergleichen mit einer Zeichenfolge ist ein ziemlicher Hack, spart jedoch wahrscheinlich Platz.
quelle
Quite a hack but saves space
Genau darum geht es auf dieser Website. : DPython 3.5,
8272 BytesGibt eine Menge von Tupeln zurück. n = 15 endet sofort.
Testen Sie es auf repl.it .
quelle
Haskell, 44 Bytes
Die Hilfsfunktion
n%m
teilt die Partitionenn
in Teile auf≥m
, wobei die Hauptfunktion verwendet wirdm=1
. Es verzweigt sich von jedem ersten Eintragj
mitm≤j≤n
, wobei auf der verbleibenden Partitionn-j
mindestens in Teile zerlegt wirdj
. Der Basisfalln==0
gibt nur die leere Partition an.quelle
Pyth, 17 Bytes
Definiert eine Funktion mit dem Namen
y
. Probieren Sie es online aus .quelle
Gelee , 9 Bytes
Probieren Sie es online!
Wie es funktioniert
quelle
J, 39 Bytes
Dies ist ein monadisches Verb, das eine Ganzzahl annimmt und ein Array von Boxed Arrays zurückgibt. Probieren Sie es hier aus. Verwendung:
Bei Eingabe 15 läuft es auf meinem Computer etwa eine Sekunde lang.
Erläuterung
Diese Herausforderung sah sofort wie ein Job für Catalog (
{
) und Cut (;.
) aus. Der Umriss des Algorithmus lautet:n
.n
entlang der Einsen aus und listen Sie die Längen jedes Teils auf.Luis Mendo hatte anscheinend die gleiche Idee .
Erklärung des Codes:
quelle
;.
wieder geschnitten .Brachylog , 33 Bytes (nicht konkurrierend)
Dies ist aufgrund einer Fehlerbehebung nicht konkurrierend.
Dies dauert
15
auf meinem Computer ca. 1 Sekunde . Für20
und größer stürzt dies mit einerOut of global stack
Ausnahme ab.Erläuterung
Hierbei wird keine integrierte Partitionierung verwendet. Stattdessen wird die Tatsache verwendet, dass
+
die Weitergabe von Einschränkungen in beide Richtungen funktioniert.Hauptprädikat:
Prädikat 1:
quelle
Mathematica,
6254 BytesDie Partitionen einer ganzen Zahl n können gefunden werden, indem nach n- Tupeln nicht negativer ganzer Zahlen ( c 1 , c 2 , ..., c n ) so aufgelöst wird, dass c 1 + 2 c 2 + ... + n c n = n .
FrobeniusSolve
ist in der Lage, alle Lösungen für diese Gleichung zu finden, die verwendet werden, um so viele Kopien ihrer jeweiligen Werte zu erstellen, um alle ganzzahligen Partitionen von n zu finden .quelle
FrobeniusSolve
findet keine ganzzahligen Teilungen, es findet alle Lösungen von nicht-negativen ganzen Zahlenx1 ... xN
zu Gleichungen der Forma1 x1 + a2 x2 + ... aN xN = b
gegebena1 ... aN
undb
.JavaScript
(Firefox 30-57) 79ES6, 65 BytePort von @ xnors Python-Lösung. (Wenn ich nur bemerkt hätte, dass man sich genauso
m
gut wiederkehren könnte wien
...)quelle