Megértése példa

Ez iterációjával keresztül minden lehetséges kombinációját a sertés és a csirke (a megadott darabszám), amíg nem talál olyat, ami a korrekt lábak száma, majd visszatér a számok a sertés és csirke. Ha ez lesz az egyes kombináció nem találnak érvényes választ, akkor visszatér [Nincs, Nincs] jelzésére hiba.

Lényegében solvevan ismételve az összes lehetséges kombinációt csirke és a sertés, és amikor talál egy ilyet, visszaengedik.)

NumChickens + NumPigs kell egyezniük NumHeads, így ellenőrzi minden NumChickens 0 NumHeads (ez az, amit for range(0,NumHeads+1)csinál), és meghatározza, hogy NumPigs NumHeads-NumChickens.

Onnan, hogy csak egy kérdés, megszorozva ki a lábak számát, és látta, ha azok megegyeznek.

Alapvetően próbál kitalálni a választ a problémára, „Hány csirke és a sertés vannak a kakaslábfű, ha van X és Y fejek lábát a gazdasági udvar?” A for numChicks in range(0, numHeads + 1):kód létrehoz egy változót numChicks, és végighalad azt numChicks = 0 numChicks = numHeads. (Megjegyzés: a tartomány funkció nem tartalmazza a legnagyobb érték).

Minden száma numChicks ellenőrzi, hogy hátha ez numChicks és a megfelelő numPigs értékek jön ki a helyes értéket numLegs. numHeads mindig helyesek, mivel numChicks + numPigs = numHeads, de numLegs változik eloszlása ​​alapján - így a hurok. Ha bármely ponton az oldatot talált (ha totLegs == numLegs), majd ezt az értéket adja vissza. Ha a teljes hurok lesz kész, és nem sikerült megoldást találni, akkor a lista [Nincs, Nincs] vissza, ami azt jelenti, hogy nincs megoldás erre a bemenetre.

Alex Martelli utal algebrai megoldást, amely fogok tartalmazzák a teljesség kedvéért itt. Ez lehet kidolgozni a használata egyenletrendszer. Mivel egy egyszerű matematikai megoldás, ez talán gyorsabb, legalábbis nagy számban lábak és fejek :-)

Legyen:

• H legyen a fejek számát;
• L az lábak száma;
• Clegyen a csibék száma; és
• P legyen a sertések száma.

Tekintve C, és Pki tudjuk számolni a másik két változó:

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

Megyek részletesen minden lépését az alábbi számítások alapjául. A ferde matematikailag nem kétséges rámutatni arra, hogy lépéseket lehetne kombinálni, de mégis inkább legyen egyértelmű. Tól (1), ki tudjuk számítani:

   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)

és helyettesítő, hogy a (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)

Most már van két képlet, az egyik, hogy ki tudja számítani a csibék száma tetőtől és a láb (4), a másik, ami ki tudja számítani a sertések száma származó csibék és fejek (3).

Tehát itt a Python kódot kell csinálni, a megfelelő ellenőrzéseket annak biztosítására, hogy ne adja meg néhányat a bizarr matematikai megoldások, mint a 2 fej és 7 lábak ad nekünk egy disznó és fél együtt egy fél csirke, vagy 1 fej és 12 lábak így 5 sertés és -4 csibék :-)

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]

Természetesen, ha elmész tört számok a fej és a lábak, akkor minden fogadás ki van kapcsolva. Itt egy teljes vizsgálati programnak, így kipróbálhatják a különböző értékeket, hogy mindkét módszer vissza ugyanazon értékek:

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)