Herausforderung

In dieser Aufgabe haben Sie die Anzahl der Möglichkeiten berechnet, wie wir A-Kugeln in B-Zellen verteilen können, wobei jede Zelle mindestens eine Kugel hat.

Die Eingänge A und B sind in einer einzelnen Zeile angegeben, die durch ein Leerzeichen getrennt ist. Die Eingänge werden durch EOF abgeschlossen.

Vielleicht möchten Sie hier Ihre Lösungen überprüfen .

Eingang

0 0
1 0
12 4
6 3
18 17
20 19
15 13
18 9
20 20
17 14
9 2
14 13
18 11

Ausgabe

1
0
14676024
540
54420176498688000
23112569077678080000
28332944640000
38528927611574400
2432902008176640000
21785854970880000
510
566658892800
334942064711654400

Einschränkungen

• Jedes A und B kann unterschieden werden.
• 0 <= A, B <= 20
• Sie können jede Sprache Ihrer Wahl verwenden
• Kürzeste Lösung gewinnt!

JavaScript (90 93 )

function f(a,b){n=m=r=1;for(i=b;i>0;n*=-1){r+=n*m*Math.pow(i,a);m=m*i/(b-i--+1)}return--r}

http://jsfiddle.net/RDGUn/2/

Offensichtlich wird mich jede mathematisch basierte Sprache wie APL wegen der Ausführlichkeit der Syntax und des Mangels an eingebauten mathematischen Konstrukten schlagen :)

Bearbeiten Außerdem habe ich keine eingabebezogenen Funktionen außer den an die Funktion übergebenen Parametern. Ich bin mir nicht sicher, wie ich die Standardeingabe mit JavaScript verwenden soll ...

Edit: Verschieben i--in m=m*Ausdruck; einziehen n*=-1in for; Beginnen Sie r=1, Aufgaben zu kombinieren, und entfernen Sie überflüssige Aufgaben bei der Rückgabe. (außer 3 Zeichen)

Golfscript - 56 50 49 48 41 40 38 37 Zeichen

n%{~),{!}%\{0.@{.@+2$*@)@}/;;]}*)p;}/

Hinweis: Dies verarbeitet mehrere Eingabezeilen, ist schnell (1/8 Sekunden für die Testfälle) und unterbricht keine legalen Eingaben.

(Die erste Version war auch mein erstes Golfscript-Programm; dank eBusiness für den Hinweis auf einige Tricks, die ich verpasst habe).

Um dies auch zu einem nützlichen Lehrbeitrag zu machen, finden Sie hier eine Erklärung, wie es funktioniert. Wir beginnen mit der Wiederholung f(n, k) = k * (f(n-1, k) + f(n-1, k-1)). Dies kann kombinatorisch so verstanden werden, dass man, um nunterscheidbare Bälle in kunterscheidbare Eimer zu legen, so dass jeder Eimer mindestens einen Ball enthält, einen der kEimer für den ersten Ball auswählt ( k *) und dann entweder mindestens einen weiteren Ball enthält ( f(n-1, k)) oder es wird nicht ( f(n-1, k-1)).

Die daraus resultierenden Werte bilden ein Raster; Es wird nals Zeilenindex und kals Spaltenindex verwendet und beide von 0 indiziert

1   0   0   0    0    0   0 ...
0   1   0   0    0    0   0 ...
0   1   2   0    0    0   0 ...
0   1   6   6    0    0   0 ...
0   1  14  36   24    0   0 ...
0   1  30 150  240  120   0 ...
0   1  62 540 1560 1800 720 ...
.   .   .   .    .    .   . .
.   .   .   .    .    .   .  .
.   .   .   .    .    .   .   .

Wenden wir uns also dem Programm zu.

n%{~ <<STUFF>> }/

teilt die Eingabe in Zeilen auf und wertet sie dann für jede Zeile aus, setzt nund kauf den Stapel und ruft dann <<STUFF>>Folgendes auf:

),{!}%\{0.@{.@+2$*@)@}/;;]}*)p;

Dies berechnet die ersten k+1Einträge der n+1dritten Zeile dieses Gitters. Anfangs ist der Stapel n k.
),gibt Stapel von n [0 1 2 ... k]
{!}%gibt Stapel von, n [1 0 0 ... 0]wo es k0s gibt.
\{ <<MORE STUFF>> }*bringt das nnach oben und macht es so oft, wie wir es ausführen <<MORE STUFF>>.
Unser Stack ist derzeit eine Zeile der Tabelle: [f(i,0) f(i,1) ... f(i,k)]
0.@Setzt ein paar Nullen vor dieses Array. Der erste wird sein jund der zweite wird sein f(i,j-1).
{ <<FINAL LOOP>> }/Schleifen durch die Elemente des Arrays; für jeden legt es es auf den Stapel und führt dann den Schleifenkörper aus.
.@+2$*@)@ist eine langweilige Stapelmanipulation, um Pops vom Rest zu nehmen ... j f(i,j-1) f(i,j)und zu erzielen... j*(f(i,j-1)+f(i,j)) j+1 f(i,j)
;;]k+1 f(i,k)und sammelt alles in einem Array, bereit für die nächste Runde.
Wenn wir die ndritte Zeile der Tabelle generiert haben, nehmen wir
)p;das letzte Element, drucken es und verwerfen den Rest der Zeile.

Für die Nachwelt drei 38-Zeichen-Lösungen nach diesem Prinzip:
n%{~),{!}%\{0.@{.@+@.@*\)@}/;;]}*)p;}/
n%{~),{!}%\{0:x\{x\:x+1$*\)}/;]}*)p;}/
n%{~),{!}%\{0.@{@1$+2$*\@)}/;;]}*)p;}/

J, 40

4 :'|-/x(^~*y!~])i.1x+y'/&.".;._2(1!:1)3 

Z.B

4 :'-/((x^~|.@:>:)*y&(!~))i.y'/x:".>{.;:(1!:1)3
15 13
28332944640000

<1 Sek. Für alle Testfälle.

Bearbeitungen

• (52 → 47) Reduzieren mit -/statt abwechseln (1 _1)*(JBs Idee)
• (47 → 53) Festgestellte Anforderung für mehrzeilige Eingaben: - /
• (53 → 48) Nutzen Sie die Symmetrie von Binomen.
• (48 → 48) Stillschweigend machen!
• (48 → 41)
• (41 → 40) Squeeze-Inkrement + Konvertierung in1x+

Common Lisp (83)

(defun b (x y)
  (if (= (* x y) 0)
      (if (= (+ x y) 0) 1 0)
      (* y (+ (b (decf x) y) (b x (1- y)))))))

Es scheint, dass es einen kürzeren Weg geben sollte, um die Basisfälle zu testen, aber mir fällt nichts ohne weiteres ein.

J, 38 bis 42

Wählen Sie je nach Ihren strengen Präferenzen für interaktive Sprachen und Ausgabepräsentationen aus dem Spektrum der Lösungen aus:

• 38 kürzeste interaktive: 4 :'|-/(!&y*^&x)i.1x+y'/&".;._2(1!:1)3
  Starten Sie jconsole, geben Sie es ein und fügen Sie die Eingabe ein (Ende mit Cd). Sie werden feststellen, dass die Ausgabe durch Leerzeichen getrennt ist (J ist eine Vektorsprache, führt die Berechnung für die gesamte Eingabe als Ganzes durch und gibt sie als 1D-Vektor zurück, dessen Standarddarstellung in einer einzelnen Zeile steht). Ich halte das für ok, der Geist dieses Problems ist die Berechnung, nicht die Präsentation. Aber wenn Sie stattdessen auf Zeilenumbrüchen bestehen:
• 39 länger interaktiv: 4 :'|-/(!&y*^&x)i.1x+y'/&.".;._2(1!:1)3
  Wenn Sie Compose ( &) durch Under ( &.) ersetzen, wird ein Vektor von Zeichenfolgen zurückgegeben, dessen Darstellung in separaten Zeilen endet.
• 42 Batch-Modus: 4 :'echo|-/(!&y*^&x)i.1x+y'/&".;._2(1!:1)3
  Ausführen über die Befehlszeile als$ jconsole balls.ijs < balls.in

Wenn Sie dafür gestimmt haben, möchten Sie vielleicht auch der Lösung von Eelvex etwas Anerkennung zollen .

GolfScript - 45 38 36 Zeichen

Wiederholungsrelation für schmutzige Implementierungen mit mittlerer Stärke ( 38 36 Zeichen):

n%{~{.2$*{\(.2$f\2$(f+*}{=}if}:f~p}/

Die Wiederholungsbeziehung, die ich aus der Lösung von Peter Taylors gestohlen habe, sieht folgendermaßen aus:

f(x, y) = y * ( f(x-1, y) + f(x-1, y-1) )

In Sonderfällen, wenn eine der Variablen 0 ist.

In meiner Implementierung werden frühere Ergebnisse nicht wiederverwendet, sodass jeder Funktionsaufruf zu zwei neuen Aufrufen verzweigt, es sei denn, einer der Nullfälle wurde erreicht. Dies führt zu einem Worst-Case von 2 ^ 21-1 Funktionsaufrufen, der auf meinem Computer 30 Sekunden dauert.

Light-Force-Serienlösung (45 Zeichen):

n%{~.),0\{.4$?3$,@[>.,,]{1\{)*}/}//*\-}/p;;}/

J, 55 Zeichen

(wd@(4 :'(y^x)--/(!&y*^&x)|.i.y')/@".@,&'x');._2(1!:1)3

• Besteht aktuelle Testfälle. Ich glaube ich verstehe die Mathematik ...
• j602, nur Konsole ( wd). Eingabe auf stdin, Ausgabe auf stdout.

Bash-Testskript:

jconsole disballs.ijs <<END
12 4
6 3
END

Golfscript - 26 Zeichen

Warnung: Der Fall 12 4 benötigt viel Speicher (obwohl nicht so viel wie die Antwort unten) und dauert eine Weile, bis er ausgeführt wird

~:)\?:x,{x+)base(;.&,)=},,

Natürlich hat diese Antwort einige Probleme, aber ich werde sie hier belassen, da sich die Kommentare darauf beziehen und die Antwort von mellamokb darauf basiert.

Golfscript - 24 Zeichen

Warnung: Der 12 4-Fall benötigt viel Speicher und benötigt eine Weile, um ausgeführt zu werden

~:o)\?,{o)base[0]-,o=},,

Python 140 Zeichen

import sys
f=lambda n,k:(n and k and n>=k and k*(f(n-1,k-1)+f(n-1,k)))or(n+k==0 and 1)or 0
for l in sys.stdin:print f(*(map(int,l.split())))

Gleichstrom, 100 Zeichen

[0q]s5[1q]s6[l2l3>5l3 0>5l2 0=6l2 1-S2l3dS3 1-S3l1xL3s9l1xL2s9+L3*]s1[?z0=5S3S2l1xL3L2+s9fs9l4x]ds4x

Leider scheint DC nicht von Ideone unterstützt zu werden. Es gibt vielleicht noch ein oder zwei Charaktere, die man herausdrücken muss, aber es ist Schlafenszeit.

Hinweis: Dies unterstützt mehrere Eingabezeilen, hat eine ausreichende Genauigkeit, um auch für 20 19(verfluche dich, Perl, für die Zeit, die ich mit dem Debuggen meiner Lösung verschwendet habe!) Die richtige Ausgabe zu liefern , und liefert die richtige Ausgabe für 0 0.

Vorschläge von Nabb erlauben eine Verkürzung mindestens bis zu

[0q]sZ[1q]sI[?z0=ZSkSn[lnlk>Zlk0>Zln0=Iln1-SnlkdSk1-SklFxLks9lFxLns9+Lk*]dsFxfs9l4x]ds4x

auf Kosten des Zurücklassens von Junk in den Registerstapeln (und damit des Speichers, wenn wir Milliarden von Antworten berechnen).

Golfscript (28 31 37 )

~):$\.($\?:@;?,{@+}%{$base$,\-[0]=},,

Änderung der gnibblerGolfScript-Lösung. Ich denke, dies ist eine funktionierende Lösung - getestet mit [3,2], [4,2], [6,3] und [9,2] mit korrekten Antworten. (Ich habe $und @für Variablen verwendet, um den Platz um das baseSchlüsselwort zu verringern ).

Es gibt zwei Probleme mit gnibblerder aktuellen Lösung.

1. Das Überprüfen der Länge nach dem Entfernen von [0] garantiert keine Lösung, da [1,1,1,1] für die Eingabe [4,2] gültig wäre, obwohl sich alle 4 Kugeln in derselben Zelle befinden (1). Deshalb habe ich geändert, um auch zu überprüfen, ob alle Ziffern verwendet werden, dh das Array enthält 1-2, sodass jede Zelle mindestens eine Kugel enthält.
2. Bei der Eingabe [4,2] ist das Basis-3-Format der Zahlen 0-27 kleiner als 4 Stellen, und die am weitesten links stehenden Nullen sind nicht enthalten. Das bedeutet, dass [1,1] als gültige Lösung enthalten ist, obwohl es technisch gesehen tatsächlich [0,0,1,1] ist, was bedeutet, dass die ersten beiden Bälle nirgendwo platziert werden. Ich behebe dies, indem ich jedem Eintrag 3 ^ 3 hinzufüge (generisch k ^ n-1 zum Array von k ^ n Einträgen), so dass die ersten Einträge nach oben verschoben werden, um mindestens n-stellige Zahlen im Basis-k-Format und die letzten zu haben Einträge sind ohnehin automatisch ungültig und wirken sich nicht auf die Lösung aus (da die zweite Ziffer immer 0 ist).

Bearbeiten

~:@\?:$,{$+}%{@base(;@,\-,0=},,

`~:@\?:$,{$+@base(;@,\-,0=},,`

Bessere Lösung noch! Sie müssen nicht inkrementieren, sondern alle Zahlen addieren, sodass sie mit [1] beginnen. Sobald Sie diese erste Ziffer dekoniert haben, fehlen keine Ziffern (einschließlich des linken Auffüllens von Nullen). Diese Lösung sollte funktionieren und wurde mit denselben Einträgen wie oben getestet. Es ist auch viel schneller, da wir nicht inkrementieren, bevor Exponent zum Generieren des Arrays verwendet wird (aber bei größeren Eingaben immer noch das gleiche Leistungs- / Speicherproblem auftritt).

Bearbeiten : Verwenden Sie gnibblerdie Idee, das Hinzufügen des $Inneren des Filters anstelle eines zusätzlichen Schritts zu verschieben. (3 Zeichen speichern).

05AB1E , 19 Bytes

#D`ULX.Œʒ€gßĀ}gs_P+

HINWEIS: Es ist extrem langsam und läuft bereits ab 12 4. Es funktioniert jedoch wie beabsichtigt. Mal sehen, ob ich eine alternative Methode finden kann, die in angemessener Zeit für alle Testfälle funktioniert. Im Folgenden finden Sie eine viel schnellere Version, mit der alle Testfälle in weniger als einer Sekunde ausgeführt werden.

Probieren Sie es online aus oder überprüfen Sie einige weitere (der kleineren) Testfälle .

Erläuterung:

#               # Split the (implicit) input-string by spaces
 D              # Duplicate it
  `             # Push both values to the stack
   U            # Pop and store the second value in variable `X`
    L           # Create a list in the range [1,n] for the first value
     X.Π       # Create a list of all possible ways to divide this list into `X` partitions
                # (including empty sublists, so we'll have to filter them out:)
        ʒ       # Filter this list of lists of partition-lists by:
         €g     #  Get the length of each partition-list
           ß    #  Get the minimum length
            Ā   #  Truthify; 0 remains 0 (falsey); anything else becomes 1 (truthy)
             }g # After the filter, take the length to get the amount left
 s              # Swap so the duplicated input-list is at the top of the stack again
  _             # Check for each value if they're equal to 0 (1 if truthy; 0 if falsey)
   P            # Take the product of the two to check if both input-values are 0
    +           # And add it to the earlier calculated product (edge case for [0,0] = 1)
                # (After which the result is output implicitly)

05AB1E , 29 Bytes

Hier eine viel schnellere Version, die für alle Testfälle in ca. 0,5 Sekunden auf TIO funktioniert:

Î#R`V©LRvyYmX*NÈ·<*+Xy*®y->÷U

Port of @mellamokbs JavaScript-Antwort , also stellen Sie sicher, dass Sie ihn positiv bewerten!

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

Erläuterung:

Î                    # Push (result=) 0 and the input
 #                   # Split the input by spaces
  R`                 # Push the values to the stack reversed
    V                # Pop and store the first value in variable `Y`
     ©               # Store the second value in variable `®` (without popping)
      LRv            # Loop `y` in the range [`®`,1], with index `N` in the range [0,`®`):
         yYm         #  Calculate `y` to the power `Y`
            X*       #  Multiply it by `X`
                     #  (Note: `X` is 1 before setting it to another value initially)
              NÈ     #  Check if index `N` is even (1 if truthy; 0 if falsey)
                ·<   #  Double it; and decrease it by 1 (1 if truthy; -1 if falseY0
                  *  #  Multiply it to the earlier number
                   + #  And add it to the result
         Xy*         #  Push `X` multiplied by `y`
         ®y->        #  Push `®` - `y` + 1
             ÷       #  Integer divide them
              U      #  Pop and store it as new variable `X`
                     # (output the result at the top of the stack implicitly after the loop)

HINWEIS: Funktioniert 0 0in diesem Fall für LRandfälle (im Gegensatz zu der JavaScript-Antwort, von der ich diese Methode portiert habe), da das integrierte Programm eine Liste erstellt [0,1].