Das Verständnis ein Beispiel

Es wird Iterieren durch jede mögliche Kombination von Schweinen und Hühnern (mit der angegebenen Anzahl der Köpfe), bis er eine findet, die die korrekte Anzahl der Beine hat, und gibt dann die Anzahl der Schweine und Hühner. Wenn es durch jede Kombination bekommt ohne eine gültige Antwort zu finden, gibt es [None, None], um anzuzeigen, Versagen.

Im Wesentlichen solvewird Iteration durch jede mögliche Kombination von Hühnern und Schweinen, und wenn es eine Übereinstimmung findet, zurückkehr es.)

NumChickens + NumPigs muss NumHeads gleich, so überprüft sie alle NumChickens von 0 bis NumHeads (das ist , was der for range(0,NumHeads+1)Fall ist) und setzt NumPigs NumHeads-NumChickens zu sein.

Von dort, es ist nur eine Frage der Multiplikation der Anzahl der Füße, und zu sehen, ob sie übereinstimmen.

Im Grunde ist es versucht , die Antwort auf das Problem herauszufinden : „Wie viele Hühner und Schweine ist in einem Barnyard es , wenn X Köpfe und Y Beine im Barnyard sind?“ Der for numChicks in range(0, numHeads + 1):Code wird ein Variablen numChicks, und durchläuft es von numChicks = 0 bis numChicks = numHeads. (Hinweis: Die Bereichsfunktion nicht den höchsten Wert enthält).

Für jede Anzahl von numChicks, überprüft er, ob die numChicks und entsprechende numPigs Werte mit dem korrekten Wert von numLegs aufkommt. numHeads wird immer korrekt, da numChicks + numPigs = numHeads, aber numLegs hängt von der Verteilung basiert - daher der Schleife. Wenn an irgendeinem Punkt wird die Lösung gefunden (wenn totLegs == numLegs), dann wird dieser Wert zurückgegeben. Wenn die gesamte Schleife gemacht wird und keine Lösung gefunden wurde, dann ist die Liste [None, None] zurückgegeben wird, was bedeutet, dass es keine Lösung für diesen Eingang.

Alex Martelli spielt auf einer algebraischen Lösung , die ich hier der Vollständigkeit halber enthalten werde. Man kann mit dem Einsatz von simultanen Gleichungen ausgearbeitet. Als eine einfache mathematische Lösung, es ist möglicherweise schneller, zumindest für große Anzahl von Beinen und Köpfen :-)

Lassen:

• H sein, die Anzahl der Köpfe;
• L Ist die Anzahl der Beine;
• CIst die Anzahl der Küken; und
• P Ist die Anzahl der Schweine.

Gegeben Cund Pkönnen wir die beiden anderen Variablen berechnen mit:

H =  C +  P (1)
L = 2C + 4P (2)

Ich werde Detail jeden Schritt in den folgenden Berechnungen. Die mathematisch veranlagt kann darauf kein Zweifel, dass Schritte kombiniert werden könnten , aber ich würde es vorziehen , explizit zu sein. Aus (1), können wir berechnen:

   H = C + P
=> 0 = C + P - H       [subtract H from both sides]
=> 0 = H - C - P       [multiply both sides by -1]
=> P = H - C           [add P to both sides] (3)

und Ersatz, dass in (2):

    L = 2C + 4P
=>  L = 2C + 4(H - C)   [substitute H-C for P]
=>  L = 2C + 4H - 4C    [expand 4(H-C) to 4H-4C]
=>  L = 4H - 2C         [combine 2C-4C into -2C]
=>  0 = 4H - 2C - L     [subtract L from both sides]
=> 2C = 4H - L          [add 2C to both sides]
=>  C = 2H - L/2        [divide both sides by 2] (4)

Jetzt haben Sie zwei Formeln, eine , die die Anzahl der Küken von Kopf und Beinen berechnen kann (4), die andere die Zahl der Schweine von Küken und Köpfen berechnen kann (3).

Also hier ist der Python-Code, es zu tun, mit geeigneten Kontrollen, um sicherzustellen, Sie nicht einige der bizarren mathematischer Lösungen ermöglichen, wie zwei Köpfe und 7 Beinen geben uns ein Schwein und eine Hälfte zusammen mit einem halben Küken oder 1 Kopf und 12 geben die Beine 5 Schweinen und Küken -4 :-)

def solve (numLegs, numHeads):
    # Use the formulae (these make integers).
    chicks = numHeads * 2 - int (numLegs / 2)
    pigs = numHeads - chicks

    # Don't allow negative number of animals.
    if chicks < 0 or pigs < 0:
        return [None, None]

    # Don't allow fractional animals.
    if chicks * 2 + pigs * 4 != numLegs:
        return [None, None]
    if chicks + pigs != numHeads:
        return [None, None]

    return [pigs, chicks]

wenn Sie in Bruchzahlen von Kopf oder Beine natürlich passieren, sind alle Wetten ab. Hier ist ein komplettes Testprogramm, so dass Sie beiden Methoden verschiedene Werte ausprobieren, um sicherzustellen, können die gleichen Werte zurück:

import sys

def usage (reason):
    print "Error: %s"%(reason)
    print "Usage: solve <numHeads> <numLegs>"
    sys.exit (1);

def solve1 (numLegs, numHeads):
    for numChicks in range (0, numHeads + 1):
        numPigs = numHeads - numChicks
        totLegs = 4 * numPigs + 2 * numChicks
        if totLegs == numLegs:
            return [numPigs, numChicks]
    return [None, None]

def solve2 (numLegs, numHeads):
    chicks = numHeads * 2 - int (numLegs / 2)
    pigs = numHeads - chicks
    if chicks < 0 or pigs < 0:           return [None, None]
    if chicks * 2 + pigs * 4 != numLegs: return [None, None]
    if chicks + pigs != numHeads:        return [None, None]
    return [pigs, chicks]

if len (sys.argv) != 3:
    usage ("Wrong number of parameters (%d)"%(len (sys.argv)))

try:    heads = int (sys.argv[1])
except: usage ("Invalid <numHeads> of '%s'"%(sys.argv[1]))

try:    legs = int (sys.argv[2])
except: usage ("Invalid <numLegs> of '%s'"%(sys.argv[2]))

print "[pigs, chicks]:"
print "  ", solve1 (legs, heads)
print "  ", solve2 (legs, heads)