Forstå et eksempel

Det er å iterere gjennom alle mulige kombinasjoner av gris og kylling (med det angitte antall hoder) inntil den finner en som har det riktige antall ben, og deretter returnerer antallet griser og kyllinger. Hvis det blir gjennom hver kombinasjon uten å finne et gyldig svar, går det [Ingen, Ingen] for å indikere feil.

I hovedsak solveer iterere gjennom alle mulige kombinasjoner av høner og griser, og når den finner en kamp, returnerer den.)

NumChickens + NumPigs må være lik NumHeads, så det sjekker hver NumChickens fra 0 til NumHeads (det er det som for range(0,NumHeads+1)gjør), og setter NumPigs å være NumHeads-NumChickens.

Derfra er det bare et spørsmål om å multiplisere ut antall føtter, og se om de passer.

I utgangspunktet er det å prøve å finne ut svaret på problemet, "Hvor mange høner og griser er det i en barnyard hvis det er X hoder og Y ben i et jorde?" Den for numChicks in range(0, numHeads + 1):kode oppretter en variabler numChicks, og sykluser gjennom den fra numChicks = 0 til numChicks = numHeads. (Merk: utvalget funksjonen inkluderer ikke den høyeste verdi).

For hvert nummer av numChicks, sjekker den for å se om det numChicks og tilhørende numPigs verdier kommer opp med den riktige verdien av numLegs. numHeads vil alltid være korrekt, siden numChicks + numPigs = numHeads, men numLegs varierer basert på fordelingen - derav sløyfen. Hvis på noe tidspunkt løsningen blir funnet (når totLegs == numLegs), så at verdien blir skrevet. Hvis hele løkken blir gjort, og ingen løsning ble funnet, vil lista [Ingen, Ingen] returnert, noe som betyr at det er ingen løsning for denne inngangen.

Alex Martelli henspiller på en algebraisk løsning som jeg vil inkludere her for fullstendighet. Det kan utarbeides med bruk av likninger. Å være en enkel matematisk løsning, er det muligens raskere, i hvert fall for store mengder bein og hoder :-)

La:

• H være antall hoder;
• L være antallet av ben;
• Cvære antall kyllinger; og
• P være antall griser.

Gitt Cog Pkan vi beregne de to andre variablene med:

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

Jeg detalj hvert trinn i beregningene nedenfor. Det matematisk tilbøyelig kan uten tvil påpeke at tiltak kan kombineres, men jeg foretrekker å være eksplisitt. Fra (1), kan vi beregne:

   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)

og erstatning som i (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)

Nå har du to formler, en som kan beregne antall kyllinger fra hode og ben (4), den andre som kan beregne antall griser fra kyllinger og hoder (3).

Så her er Python koden for å gjøre det, med nødvendige kontroller for å sikre at du ikke la noen av de mer bisarre matematiske løsninger, som 2 hoder og 7 ben gir oss en gris og en halv sammen med en halv kylling, eller en hode og 12 ben som gir 5 griser og kyllinger -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]

Selvfølgelig, hvis du passerer i brøk antall hodet eller bena, er alle spill av. Her er en komplett testprogram slik at du kan prøve ut ulike verdier for å sikre begge metodene returnerer de samme verdiene:

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)