एक उदाहरण को समझना

यह (सिर की निर्दिष्ट संख्या के साथ) सूअर और मुर्गियों के हर संभव संयोजन के माध्यम से पुनरावृत्ति जब तक यह एक पैर की सही संख्या है, और फिर सूअर और मुर्गियों की संख्या देता है कि पाता है। यह एक वैध उत्तर ढूंढना बिना एक संयोजन के माध्यम से हो जाता है, यह [कोई नहीं, कोई नहीं] विफलता का संकेत करने के लिए देता है।

अनिवार्य रूप से, solveमुर्गियों और सूअरों के हर संभव संयोजन के माध्यम से पुनरावृत्ति है, और जब यह एक मैच पाता है, यह लौटने।)

NumChickens + NumPigs NumHeads के बराबर होना चाहिए, तो यह NumHeads 0 से हर NumChickens (वो क्या है की जाँच करता है for range(0,NumHeads+1)करता है), और NumHeads-NumChickens होने की NumPigs सेट।

वहाँ से, अपने बस पैर की संख्या का पता गुणा, और देख अगर वे से मेल की बात।

असल में, यह समस्या है, का जवाब यह पता लगाने की कोशिश कर रहा है "अगर वहाँ बाड़े में एक्स और वाई सिर पैर हैं कितने मुर्गियों और सूअरों एक बाड़े में देखते हैं?" for numChicks in range(0, numHeads + 1):कोड numChicks = numHeads को numChicks = 0 से इसके माध्यम से एक चर numChicks, और चक्र पैदा करता है। (नोट: सीमा समारोह उच्चतम मूल्य शामिल नहीं है)।

numChicks से प्रत्येक संख्या के लिए, यह देखने के लिए कि कि numChicks और इसी numPigs मूल्यों numLegs का सही मूल्य के साथ आता है की जाँच करता है। numHeads हमेशा सही के बाद से numChicks + numPigs = numHeads होगा, लेकिन numLegs वितरण के आधार पर भिन्न - इसलिए पाश। किसी भी बिंदु पर समाधान पाया जाता है (जब totLegs == numLegs) तो वह मान दिया है। पूरे पाश किया जाता है और कोई समाधान नहीं मिला था, तो सूची [कोई नहीं, कोई नहीं] लौटा दिया जाता है, जिसका अर्थ है इस इनपुट के लिए कोई समाधान उपलब्ध न हो।

एलेक्स मार्टेली एक बीजीय समाधान जो मैं यहाँ संपूर्णता के लिए शामिल करेंगे की तरफ इशारा करता। यह युगपत समीकरण के उपयोग के साथ बाहर काम किया जा सकता है। एक सरल गणितीय समाधान होने के नाते, यह संभवतः सबसे तेज़ है कम से कम के लिए बड़े पैर और सिर की संख्या :-)

करते हैं:

• H सिर की संख्या हो;
• L पैरों की संख्या हो;
• Cचूजों की संख्या हो; तथा
• P सूअरों की संख्या हो।

यह देखते हुए Cऔर P, हम साथ अन्य दो चर की गणना कर सकते हैं:

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

मैं विस्तार करेंगे हर नीचे गणना में कदम। गणितीय इच्छुक कोई संदेह नहीं है का कहना है कि कर सकते हैं चरणों जोड़ा जा सकता है, लेकिन मैं स्पष्ट रखना पसंद किया है। से (1), हम गणना कर सकते हैं:

   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)

और स्थानापन्न कि में (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)

अब आपके पास दो सूत्र, एक है कि सिर और पैर से चूजों की संख्या की गणना कर सकते हैं (4)अन्य जो चूजों और सिर से सूअरों की संख्या की गणना कर सकते हैं, (3)।

तो यहाँ यह करने के लिए पायथन कोड, उपयुक्त चेकों के साथ सुनिश्चित करने के लिए आप अधिक विचित्र गणितीय समाधान के कुछ की अनुमति नहीं है 2 सिर और 7 पैरों हमें एक सुअर और आधे से एक लड़की के साथ एक आधा, या 1 सिर दे रही है की तरह है, और 12 पैरों 5 सूअर और -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]

बेशक, अगर आप सिर या पैर की आंशिक संख्या में पारित, सभी दांव बंद कर रहे हैं। यहां एक संपूर्ण परीक्षण कार्यक्रम ताकि आप सुनिश्चित करने के लिए दोनों तरीकों का एक ही मान विभिन्न मूल्यों की कोशिश कर सकते हैं:

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)