Comprendre un exemple

Il est Itère toutes les combinaisons possibles des porcs et des poulets (avec le nombre de têtes) jusqu'à ce qu'il en trouve un qui a le nombre correct de jambes, puis retourne le nombre de porcs et des poulets. Si elle passe à travers chaque combinaison sans trouver une réponse valable, elle retourne [None, None] pour indiquer l'échec.

Pour l' essentiel, solveest itérer toutes les combinaisons possibles des poulets et des porcs, et quand il trouve une correspondance, il.) Retour

NumChickens + NumPigs doit être égal NumHeads, il vérifie tous les NumChickens de 0 à NumHeads (c'est ce qui for range(0,NumHeads+1)fait), et définit NumPigs pour être NumHeads-NumChickens.

A partir de là, juste une question de multiplier le nombre de pieds, et de voir si elles correspondent.

En fait, il essaie de trouver la réponse au problème, « Combien de poulets et cochons sont là , dans une basse - cour s'il y a des têtes X et Y jambes dans la basse - cour? » Le for numChicks in range(0, numHeads + 1):code crée une des variables numChicks et cycles à travers elle de numChicks = 0 à numChicks = numHeads. (Remarque: la fonction de gamme ne comprend pas la valeur la plus élevée).

Pour chaque numéro de numChicks, il vérifie si ce numChicks et les valeurs de numPigs correspondantes arrive avec la valeur correcte de numLegs. numHeads sera toujours correcte depuis numChicks + numPigs = numHeads, mais numLegs varie en fonction de la distribution - d'où la boucle. Si à tout moment la solution est trouvée (quand totLegs == numLegs), cette valeur est renvoyée. Si la boucle entière se fait et aucune solution n'a été trouvée, la liste [None, None] est retourné, ce qui signifie qu'il n'y a pas de solution pour cette entrée.

Alex Martelli fait allusion à une solution algébrique que je rajouterais ici pour être complet. Il peut être élaboré avec l'utilisation d'équations simultanées. Être une solution mathématique simple, il est peut - être plus rapide, au moins pour un grand nombre de jambes et la tête :-)

Laisser:

• H le nombre de têtes;
• L le nombre de branches;
• Cle nombre de poussins; et
• P le nombre de porcs.

Compte tenu Cet P, nous pouvons calculer les deux autres variables avec:

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

Je détaillerai chaque étape dans les calculs ci - dessous. Le sans doute peut mathématiquement incliné indiquer que des mesures pourraient être combinées , mais je préférerais être explicite. A partir de (1), nous pouvons calculer:

   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)

et que substitut dans (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)

Maintenant , vous avez deux formules, qui permet de calculer le nombre de poussins de la tête et les jambes (4), l'autre qui peut calculer le nombre de porcs de poussins et des têtes (3).

Voici donc le code Python pour le faire, avec des contrôles appropriés pour vous assurer de ne pas autoriser certaines des solutions mathématiques plus bizarres, comme 2 têtes et 7 pieds nous donnant un cochon et demi avec un demi-poussin, ou 1 tête et 12 jambes donnant 5 porcs et -4 poussins :-)

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]

Bien sûr, si vous passez des nombres fractionnaires de tête ou les jambes, les paris sont ouverts. Voici un programme de test complet afin que vous puissiez essayer différentes valeurs pour assurer que les deux méthodes renvoient les mêmes valeurs:

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)