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

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

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

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

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

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

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

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

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

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

81% प्रतिभागियों ने कहा कि बूटकैंप में भाग लेने के बाद उन्हें अपनी तकनीकी नौकरी की संभावनाओं के बारे में अधिक आत्मविश्वास महसूस हुआ। आज ही एक बूटकैंप से मिलान करें।

बूटकैंप शुरू करने से लेकर अपनी पहली नौकरी खोजने तक, औसत बूटकैंप ग्रेड ने करियर संक्रमण में छह महीने से भी कम समय बिताया।

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

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

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

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

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 को नई संख्या के बराबर सेट करते हैं। इसके बाद, हम अपने गिने हुए चर में 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 के बराबर या उससे कम है या नहीं। यदि ऐसा है, तो वह संख्या बिना किसी गणना के वापस कर दी जाती है। अन्यथा, हम सूची में पिछले दो मदों के योग की गणना करने के लिए दो बार कैलकुलेट_नंबर () फ़ंक्शन को कॉल करते हैं।

अंत में, हमें एक मुख्य प्रोग्राम लिखना होगा जो हमारे कार्य को निष्पादित करता है:

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

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

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

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

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

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

निष्कर्ष

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

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

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