Pochopení příklad

Je iterace všech možných kombinací prasat a kuřat (s určeným počtem hlav), dokud nenajde ten, který má správný počet nohou, a pak se vrátí počty prasat a kuřat. Dostane-li se do každé kombinace, aniž by našli platnou odpověď, vrátí [None, None], aby indikoval poruchu.

V podstatě solveje iterace všech možných kombinací kuřat a prasat, a když najde shodu, vrací ji.)

NumChickens + NumPigs musí rovnat NumHeads, takže se kontroluje každých NumChickens od 0 do NumHeads (to je to, co for range(0,NumHeads+1)dělá), a nastaví NumPigs aby mohly NumHeads-NumChickens.

Odtud je to jen otázka násobení se počet stop a vyzkoušejte, zda se shodují.

V podstatě, to se snaží přijít na to odpověď na problém, „Kolik kuřat a prasat existují ve dvoře, pokud jsou X a Y hlavy nohy v dvoře?“ for numChicks in range(0, numHeads + 1):Kód vytvoří proměnné numChicks a cykly přes to z numChicks = 0 numChicks = numHeads. (Poznámka: Funkce rozsah nezahrnuje nejvyšší hodnoty).

Pro každý počet numChicks, se kontroluje, zda že numChicks a odpovídající hodnoty numPigs přijde se správnou hodnotou numLegs. numHeads bude vždy správné, protože numChicks + numPigs = numHeads, ale numLegs se liší v závislosti na rozdělení - tedy smyčky. Pokud kdykoli je zjištěno, že roztok (při totLegs == numLegs), a pak se vrátí, aby hodnota. Pokud je celá smyčka udělá a žádné řešení bylo nalezeno, je vrácena pak je tento seznam [None, None], což znamená, že neexistuje řešení tohoto vstupu.

Alex Martelli se zmiňuje o algebraické řešení, které budu pro úplnost zahrnout. To může být zpracován s použitím simultánních rovnic. Být jednoduchým matematickým řešením, je možná rychlejší, alespoň pro velké počty nohou a hlavy :-)

Nechat:

• H je počet hlav;
• L je počet ramen;
• Cbýt počet kuřat; a
• P je počet prasat.

Vzhledem k tomu, Ca Pmůžeme vypočítat další dvě proměnné s:

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

Budu detail každý krok v níže uvedených výpočtech. Matematicky nakloněný lze bezpochyby připomínají, že kroky mohou být kombinovány, ale já bych raději být explicitní. Z (1), můžeme vypočítat:

   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)

a náhradní že do (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)

Nyní máte dvě rovnice, takový, který může vypočítat počet kuřat z hlavy a nohou (4), druhá, která může spočítat počet prasat z kuřat a hlavy (3).

Tak tady je Python kód, jak to udělat, s vhodnými kontrolami, aby vám neumožňují některé z více bizarní matematické řešení, jako je 2 hlavami a 7 nohy dává nám prase a půl spolu s půl kuře, nebo 1 hlavu a 12 nohy poskytnutí 5 prasat a kuřat -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]

Samozřejmě, pokud předat do desetinná čísla hlavy nebo nohou, všechny sázky jsou pryč. Zde je kompletní testovací program, takže si můžete vyzkoušet různé hodnoty, aby zajistily, obě metody vrátí stejné hodnoty:

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)