पायथन में फाइबोनैचि अनुक्रम कैसे कोड करें

फाइबोनैचि अनुक्रम गणित में सबसे प्रसिद्ध अनुक्रमों में से एक है। इसकी गणना करना काफी सरल है: अनुक्रम में प्रत्येक संख्या पिछली दो संख्याओं का योग होती है।

इस अनुक्रम ने प्रोग्रामिंग में अपनी जगह बनाई है। अक्सर, इसका उपयोग डेवलपर्स को एल्गोरिदम और लूप पर प्रशिक्षित करने के लिए किया जाता है।

इस गाइड में, हम बात करेंगे कि पायथन में फाइबोनैचि अनुक्रम को कैसे कोड किया जाए। हम फाइबोनैचि अनुक्रम को लागू करने के लिए दो दृष्टिकोण देखेंगे: इटरेटिव और रिकर्सिव।

फाइबोनैचि अनुक्रम क्या है?

फाइबोनैचि अनुक्रम संख्याओं की एक श्रृंखला है। प्रत्येक संख्या अनुक्रम में पिछली दो संख्याओं का योग होती है। अनुक्रम इस तरह शुरू होता है:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34

यह तब तक चलता रहता है जब तक आप नई संख्याओं की गणना करना बंद नहीं करते। अनुक्रम में अगली संख्या की गणना करने का नियम है:

x(n) = x(n-1) + x(n-2)

x(n) अनुक्रम में अगली संख्या है। x(n-1) पिछला पद है। x(n-2) अंतिम से पहले का पद है।

पायथन फाइबोनैचि अनुक्रम: इटरेटिव दृष्टिकोण

आइए फाइबोनैचि श्रृंखला को लागू करने के इटरेटिव दृष्टिकोण के बारे में बात करके शुरू करते हैं।

यह दृष्टिकोण एक "व्हाइल" लूप का उपयोग करता है जो अगली संख्या की गणना करता है जब तक कि एक विशेष स्थिति पूरी नहीं हो जाती। हर बार व्हाइल लूप चलता है, हमारा कोड इटरेट करता है। यही कारण है कि इस दृष्टिकोण को इटरेटिव कहा जाता है।

आइए कुछ प्रारंभिक मान सेट करके शुरू करते हैं:

terms_to_calculate = 9
n1, n2 = 0, 1
counted = 0

हमने चार वेरिएबल घोषित किए हैं।

पहला वेरिएबल ट्रैक करता है कि हम कितने मान गणना करना चाहते हैं। अगले दो वेरिएबल, n1 और n2, सूची में पहले दो आइटम हैं। हमें इन मानों को बताने की आवश्यकता है अन्यथा हमारा प्रोग्राम नहीं जान पाएगा कि कहां से शुरू करना है। ये मान बदल जाएंगे जैसे ही हम नई संख्याओं की गणना शुरू करेंगे।

अंतिम वेरिएबल हमारे पायथन प्रोग्राम में गणना किए गए पदों की संख्या को ट्रैक करता है।

आइए एक लूप लिखते हैं जो एक फाइबोनैचि संख्या की गणना करता है:

while counted < terms_to_calculate:
    print(n1)
    new_number = n1 + n2
    n1 = n2
    n2 = new_number
    counted += 1

यह व्हाइल लूप तब तक चलता है जब तक कि हमारे द्वारा गणना किए गए मानों की संख्या कुल संख्याओं के बराबर नहीं हो जाती जिन्हें हम गणना करना चाहते हैं। लूप n1 के मान को शेल पर प्रिंट करता है। फिर यह पिछली संख्या को उससे पहले की संख्या में जोड़कर अगली संख्या की गणना करता है।

हम n1 के मान को n2 के बराबर स्वैप करते हैं। यह n1 को नई संख्या के बाद पहली संख्या बनाता है। फिर हम n2 को नई संख्या के बराबर सेट करते हैं। अगला, हम अपने counted वेरिएबल में 1 जोड़ने के लिए += ऑपरेटर का उपयोग करते हैं।

हमारा कोड लौटाता है:

हमारे प्रोग्राम ने फाइबोनैचि अनुक्रम में पहले नौ मानों की सफलतापूर्वक गणना की है!

पायथन फाइबोनैचि अनुक्रम: रिकर्सिव दृष्टिकोण

फाइबोनैचि अनुक्रम की गणना रिकर्सन के लिए एक आदर्श उपयोग मामला है। एक रिकर्सिव फ़ंक्शन एक ऐसा फ़ंक्शन है जो किसी समस्या को हल करने के लिए स्वयं पर निर्भर करता है।

रिकर्सिव फ़ंक्शन एक समस्या को छोटी समस्याओं में तोड़ते हैं और इसे हल करने के लिए स्वयं का उपयोग करते हैं। आइए एक वेरिएबल को इनिशियलाइज़ करके शुरू करते हैं जो ट्रैक करता है कि हम कितनी संख्याएं गणना करना चाहते हैं:

terms_to_calculate = 9

इस प्रोग्राम को केवल एक वेरिएबल इनिशियलाइज़ करने की आवश्यकता है। अगला, हम एक फ़ंक्शन बना सकते हैं जो अनुक्रम में अगली संख्या की गणना करता है:

def calculate_number(number):
    if number <= 1:
        return number
    else:
        return(calculate_number(number-1) + calculate_number(number-2))

यह फ़ंक्शन जांचता है कि इसमें पास की गई संख्या 1 के बराबर या कम है या नहीं। यदि हां, तो वह संख्या बिना किसी गणना के वापस कर दी जाती है। अन्यथा, हम सूची में पिछले दो आइटम का योग गणना करने के लिए calculate_number() फ़ंक्शन को दो बार कॉल करते हैं।

अंत में, हमें एक मेन प्रोग्राम लिखने की आवश्यकता है जो हमारे फ़ंक्शन को निष्पादित करता है:

for number in range(terms_to_calculate):
    print(calculate_number(number))

यह लूप terms_to_calculate के मान के बराबर संख्या में निष्पादित होगा। दूसरे शब्दों में, हमारा लूप 9 बार निष्पादित होगा। यह लूप अनुक्रम में अगली संख्या की गणना करने के लिए calculate_number() मेथड को कॉल करता है। यह इस संख्या को कंसोल पर प्रिंट करता है।

हमारा कोड लौटाता है:

इस कोड का आउटपुट हमारे पहले के उदाहरण के समान है।

अंतर हमारे द्वारा उपयोग किए गए दृष्टिकोण में है। हमने एक रिकर्सिव फ़ंक्शन परिभाषित किया है जो अनुक्रम में अगली संख्या की गणना करने के लिए स्वयं को कॉल करता है। रिकर्सिव दृष्टिकोण आमतौर पर इटरेटिव दृष्टिकोण पर पसंद किया जाता है क्योंकि यह समझने में आसान होता है।

यह कोड हमारे इटरेटिव उदाहरण की तुलना में काफी कम लाइनों का उपयोग करता है। क्या अधिक है, हमें इस प्रोग्राम को काम करने के लिए केवल एक वेरिएबल इनिशियलाइज़ करना होगा; हमारे इटरेटिव उदाहरण के लिए हमें चार वेरिएबल इनिशियलाइज़ करने की आवश्यकता थी।

निष्कर्ष

फाइबोनैचि अनुक्रम को या तो इटरेटिव या रिकर्सिव दृष्टिकोण का उपयोग करके उत्पन्न किया जा सकता है।

इटरेटिव दृष्टिकोण अनुक्रम में अगली संख्याओं की गणना करने के लिए एक व्हाइल लूप पर निर्भर करता है। रिकर्सिव दृष्टिकोण में एक फ़ंक्शन को परिभाषित करना शामिल है जो अनुक्रम में अगली संख्या की गणना करने के लिए स्वयं को कॉल करता है।

अब आप पायथन में एक विशेषज्ञ की तरह फाइबोनैचि अनुक्रम की गणना करने के लिए तैयार हैं!