Capire un esempio

Si iterazione attraverso ogni possibile combinazione di maiali e polli (con il numero specificato di teste) fino a trovarne uno che ha il numero corretto di gambe, e restituisce il numero di maiali e polli. Se si arriva attraverso ogni combinazione senza trovare una risposta valida, restituisce [Nessuno, None] per indicare il fallimento.

In sostanza, solvesi scorrendo ogni possibile combinazione di polli e maiali, e quando trova una corrispondenza, restituendolo.)

NumChickens + NumPigs deve essere uguale NumHeads, quindi controlla ogni NumChickens da 0 a NumHeads (che è quello che for range(0,NumHeads+1)fa), e imposta NumPigs di essere NumHeads-NumChickens.

Da lì, è solo una questione di moltiplicare il numero di piedi, e vedere se corrispondono.

In sostanza, si sta cercando di capire la risposta al problema, "Quanti polli e maiali ci sono in un cortile se non ci sono teste di X e Y gambe nel cortile?" Il for numChicks in range(0, numHeads + 1):codice crea un variabili numChicks, e cicli attraversa da numChicks = 0 a numChicks = numHeads. (Nota: la funzione gamma non include il valore più alto).

Per ciascun numero di numChicks, controlla per vedere se numChicks ei valori corrispondenti numPigs si presenta con il valore corretto di numLegs. numHeads saranno sempre corretto da numChicks + numPigs = numHeads, ma numLegs varia in base alla distribuzione - quindi il ciclo. Se in qualsiasi momento la soluzione viene trovata (ove totLegs == numLegs), allora quel valore viene restituito. Se l'intero ciclo viene fatto ed è stato trovato nessuna soluzione, allora la lista [Nessuno, None] viene restituito, il che significa che non c'è alcuna soluzione per questo ingresso.

Alex Martelli allude a una soluzione algebrica, che io includo per completezza. Esso può essere risolto con l'uso di equazioni simultanee. Essendo una soluzione semplice matematica, è forse più veloce, almeno per i grandi numeri di gambe e teste :-)

Permettere:

• H il numero di teste;
• L il numero delle gambe;
• Cil numero di pulcini; e
• P il numero di suini.

Dato Ce P, possiamo calcolare le altre due variabili con:

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

Io dettaglio ogni passo nei calcoli sottostanti. La matematicamente inclinato può senza dubbio sottolineare che passi potrebbero essere combinati, ma preferirei essere esplicito. Da (1), possiamo calcolare:

   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)

e sostituire tale 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)

Ora avete due formule, uno in grado di calcolare il numero di pulcini da testa e le gambe (4), l'altro in grado di calcolare il numero di suini da pulcini e teste (3).

Quindi, ecco il codice Python per farlo, con opportuni controlli al fine di garantire non si consente alcune delle soluzioni matematiche più bizzarri, come 2 teste e 7 gambe dandoci un maiale e mezzo con mezzo un pulcino, o 1 testa e 12 gambe dando 5 maiali e -4 pulcini :-)

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]

Naturalmente, se si passa in numeri frazionari di testa o le gambe, tutte le scommesse sono spenti. Ecco un programma di prova in modo da poter provare diversi valori per assicurare entrambi i metodi restituiscono gli stessi valori:

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)