Capire un esempio [chiusa]

Question

def solve(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 barnYard(heads, legs):
    pigs, chickens = solve(legs, heads)
    if pigs == None:
        print "There is no solution."
    else:
        print 'Number of pigs: ', pigs
        print 'Number of Chickens: ', chickens

sto imparando Python e sono imbattuto in questo esempio, qualcuno può spiegare in parole povere (o pseudo-codice) che cosa questo sta facendo riga per riga.

Grazie

Answer 1

solve sta calcolando il numero di pulcini (1 a testa, 2 gambe) e quante suini (1 testa, 4 gambe) che serve per totale fino a numeri dati di teste e gambe.

Si utilizza una "forza bruta", vale a dire, al massimo semplici, approccio:

• si cerca addirittura possibile il numero di pulcini da nessuno a tutti di come molti come è stato specificato il numero di teste (Che è il ruolo del for numChicks in range(0, numHeads + 1): ciclo, dal momento che range dà interi dal valore di partenza incluso al valore finale escluso);
• per ogni dato numChicks calcola quanti maiali ci sarebbe quello di dare il numero richiesto di teste, da parte del dichiarazione numPigs = numHeads - numChicks
• allora calcola quanti gambe totali quei pulcini e maiali avrebbero, da totLegs = 4*numPigs + 2*numChicks
• allora controlla se il totLegs uguale il numero richiesto: in caso affermativo, restituisce una lista con due voci, il numero di pulcini e maiali che risolvono il problema
• infine, se "cade del fondo" loop for senza aver restituito un valore ancora, sa che non c'è soluzione, e significa che restituendo un elenco ciascuno di cui due elementi è None.

barnYard pochi delegati la soluzione al solve e le stampa in maniera leggibile bella, sia come "soluzione" o come numeri piacevolmente decorate di pulcini e maiali.

Ora, per continuare a progredire, chiedetevi se solve potrebbe essere scritto in modo più efficiente. Chiaramente non esiste una soluzione se il numero di gambe è inferiore al doppio del numero di capi, ovvero più di quattro volte il numero di teste, o dispari - forse solve potrebbe provare per coloro caso e tornare [None, None] immediatamente. Potrebbe codice che ...?

Può non essere ovvio, ma ogni altra combinazione di numeri di teste e gambe ha una soluzione - e c'è un modo per trovarlo semplicemente aritmetico, senza loop. Pensateci, magari con l'aiuto di algebra elementare, scuola media ...

Answer 2

Alex Martelli allude ad 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 di grandi dimensioni numero di gambe e teste: -)

Let:

• H sia il numero di teste;
• L essere il numero delle gambe;
• C sia il numero di pulcini; e
• P essere il numero di suini.

C Given e P, siamo in grado di calcolare le altre due variabili con:

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

Ti dettaglio tutti passaggio 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 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)

Answer 3

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.

Answer 4

Essenzialmente, solve viene iterazione attraverso 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 essere NumHeads-NumChickens.

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

Answer 5

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):code 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, esso 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 e nessuna soluzione è stata trovata, allora la lista [Nessuno, None] viene restituito, il che significa che non c'è alcuna soluzione per questo ingresso.