Résultat inattendu dans un exemple simple

Question

def solve(numLegs, numHeads): 
     for numSpiders in range(0, numHeads + 1): 
      for numChicks in range(0, numHeads - numSpiders + 1): 
       numPigs = numHeads - numChicks - numSpiders 
       totLegs = 4*numPigs + 2*numChicks + 6*numSpiders 
       if totLegs == numLegs: 
        return [numPigs, numChicks, numSpiders] 
     return [None, None, None] 

    def barnYard(heads, legs): 
     pigs, chickens, spiders = solve(legs, heads) 
     if pigs == None: 
      print "There is no solution." 
     else: 
      print 'Number of pigs: ', pigs 
      print 'Number of Chickens: ', chickens 
      print 'Number of Spider: ', spiders 

    barnYard(20,56) # 8 pigs - 12 chickens 
    barnYard(21,62) # 10 pig - 11 chickens 

20 têtes et 56 retours jambes 8 cochons et 12 poulets, donc je l'ai fait 21 et 62 d'ajouter une araignée, mais il retourne toujours des cochons et des poulets, ce qui est erroné dans le code?

Merci!

Answer 1

Votre code est correct - dans la première itération de la boucle for la plus à l'extérieur, numChicks est 0. Puisque solve renvoie dès qu'il trouve une correspondance valide, une autre correspondance valide possible ne sera pas tentée.

Vous pouvez modifier l'instruction return en une instruction yield et parcourir les résultats de solve pour obtenir toutes les combinaisons possibles.

Par exemple:

def solve(numLegs, numHeads): 
    for numBees in range(0, numHeads + 1): 
      for numChicks in range(0, numHeads - numBees + 1): 
        numPigs = numHeads - numChicks - numBees 
        totLegs = 4*numPigs + 2*numChicks + 6*numBees 
        if totLegs == numLegs: 
          yield [numPigs, numChicks, numBees] 

def barnYard(heads, legs): 
    for pigs, chickens, bees in solve(legs, heads): 
      print 'Number of pigs: ', pigs 
      print 'Number of chickens: ', chickens 
      print 'Number of bees: ', bees 

barnYard(20,56) 

va afficher:

Number of pigs: 8 
Number of chickens: 12 
Number of bees: 0 

Number of pigs: 6 
Number of chickens: 13 
Number of bees: 1 

Number of pigs: 4 
Number of chickens: 14 
Number of bees: 2 

Number of pigs: 2 
Number of chickens: 15 
Number of bees: 3 

Number of pigs: 0 
Number of chickens: 16 
Number of bees: 4 

Answer 2

Il n'y a absolument aucun problème avec votre code. C'est un résultat complètement valide. Avec 10 cochons et 11 poulets, vous obtenez 10+11=21 têtes, et 10*4 + 11*2 = 62 jambes.

Il renvoie donc un résultat correct.

Maintenant, si vous changez cela en 10 têtes et 62 jambes, et changez aussi le code pour avoir 8 pattes pour une araignée comme ils ont tendance à le faire, alors vous obtenez le résultat 3 cochons, 1 poulet et 6 araignées.

Votre code essaie simplement les araignées en dernier, donc vous n'obtiendrez pas d'araignées sauf si a pour être des araignées.

Answer 3

Un système linéaire avec 2 équations et 3 variables est sous-déterminé - il peut y avoir plusieurs solutions pour un ensemble donné de paramètres; et c'est effectivement le cas pour le code que vous montrez. Rien de mal avec le code, si ce que vous voulez est d'obtenir la solution (le cas échéant) avec le moins d'araignées possible.

Si vous voulez obtenir la solution (le cas échéant) avec autant araignées que possible, essayez de « beaucoup d'araignées » d'abord, par exemple changer la boucle extérieure, qui est maintenant

for numSpiders in range(0, numHeads + 1): 

-à-dire, essaie d'abord d'obtenir du tout une solution sans araignées, alors si cela échoue tente avec un, et ainsi de suite, être à la place:

for numSpiders in reversed(range(0, numHeads + 1)): 

qui va dans l'autre sens (c'est ce que le reversed est pour) et va essayer numHeads araignées d'abord, puis numHeads-1, et ainsi de suite. (Vos équations sont réellement diophantiennes, c'est-à-dire strictement basées sur des entiers, ce qui a des implications importantes par rapport aux équations linéaires ordinaires qui admettent des solutions fractionnaires, mais votre problème ici n'est pas lié aux problèmes d'équation diophantienne, juste à la peu sur les systèmes linéaires sous-déterminés).