Python में फ़िबोनाची सीरीज़: सीखें और कोडिंग तकनीकों का अन्वेषण करें

फ़िबोनाची सीरीज़ Python का अभ्यास करते रहने का एक रोचक तरीका है। इस लेख में, आप विभिन्न Python तकनीकों का उपयोग करके Python में फ़िबोनाची सीरीज़ लागू करना सीखेंगे—कुशल फ़ंक्शन लिखने और रिकर्शन संभालने से लेकर अधिक अनुकूलित समाधानों के लिए ऑब्जेक्ट-ओरिएंटेड सिद्धांतों तक। 

जब आप सब कुछ पूरा कर लें, तो हमारे Writing Functions in Python कोर्स से स्कोपिंग और एरर हैंडलिंग जैसे कॉन्सेप्ट्स को मजबूत करें, या हमारे Intermediate Object-Oriented Programming in Python कोर्स के साथ इनहेरिटेंस और बेस क्लासेज़ के बारे में जानें। अब, फ़िबोनाची सीरीज़ आज़माते हैं।

त्वरित उत्तर

फ़िबोनाची सीरीज़ 0 और 1 से शुरू होती है, और हर अगली संख्या उससे पहले की दो संख्याओं का योग होती है। Python में इसे जनरेट करने का सबसे सरल तरीका लूप है:

n = 10
a, b = 0, 1

fibonacci_numbers = []

for _ in range(n):  
    fibonacci_numbers.append(str(a)) 
    a, b = b, a + b

print(' '.join(fibonacci_numbers))

# This prints the first 10 Fibonacci numbers
# 0 1 1 2 3 5 8 13 21 34संचालित द्वारा

फ़िबोनाची सीरीज़ क्या है?

फ़िबोनाची सीरीज़ एक गणितीय अवधारणा है जो विज्ञान और प्रकृति के कई क्षेत्रों में दिखाई देती है। यह संख्याओं की एक श्रेणी है जिसमें हर संख्या उससे पहले की दो संख्याओं का योग होती है, और यह 0 तथा 1 से शुरू होती है। यह पैटर्न कंप्यूटर साइंस और वित्त जैसे क्षेत्रों में अनुप्रयोगों का आधार बनता है। 

फ़िबोनाची सीरीज़ को दो मुख्य पहलू परिभाषित करते हैं: सीरीज़ की रिकर्सिव संरचना और इसका गोल्डन रेशियो से संबंध।

फ़िबोनाची सीरीज़ का रिकर्सिव स्वभाव

फ़िबोनाची सीरीज़ 0 और 1 से शुरू होती है। हर नई संख्या उससे पहले की दो संख्याओं का योग होती है। उदाहरण के लिए:

0 + 1 = 1

1 + 1 = 2

1 + 2 = 3

2 + 3 = 5

3 + 5 = 8

5 + 8 = 13

और आगे भी ऐसे ही। 

गणितीय रूप से, इसे F(n) = F(n-1) + F(n-2) के रूप में लिखते हैं। सीरीज़ अपने आखिरी दो नंबरों को जोड़ते हुए आगे बढ़ती है। शुरुआती दो नंबर, 0 और 1, प्रारंभिक बिंदु या बेस केस होते हैं। इनके बिना सीरीज़ काम नहीं करेगी।

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

गोल्डन रेशियो से जुड़ाव 

फ़िबोनाची सीरीज़ का गोल्डन रेशियो से घनिष्ठ संबंध है, जो एक अपरिमेय संख्या है और φ द्वारा दर्शाई जाती है (इसका मान लगभग 1.618 है)। यदि आप किसी फ़िबोनाची संख्या को उससे ठीक पहले वाली संख्या से भाग दें, तो यह अनुपात φ के और पास आता जाता है। उदाहरण के लिए:

5 ÷ 3 ≈ 1.666

8 ÷ 5 ≈ 1.6

13 ÷ 8 ≈ 1.625

जैसे-जैसे आप आगे बढ़ते हैं, यह 1.618 के और करीब आता जाता है। यह संयोग नहीं है — यह अनुपात संख्याओं के बढ़ने के तरीके के कारण फ़िबोनाची सीरीज़ में स्वाभाविक रूप से दिखाई देता है।

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

कला में गोल्डन रेशियो। स्रोत

फ़िबोनाची सीरीज़ के व्यावहारिक अनुप्रयोग

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

प्रकृति में फ़िबोनाची

आप प्रकृति में हर जगह फ़िबोनाची सीरीज़ देख सकते हैं। फूलों को देखें — पंखुड़ियों की संख्या अक्सर फ़िबोनाची संख्याएँ होती हैं। उदाहरण के लिए, डेज़ी में 34, 55 या 89 पंखुड़ियाँ हो सकती हैं, और लिली में प्रायः 3, 5 या 8। ये पैटर्न पौधों को ऐसे ढंग से बढ़ने में मदद करते हैं जो सूर्य के प्रकाश और वर्षा का अधिकतम लाभ उठाते हैं।

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

कंप्यूटर साइंस में फ़िबोनाची

फ़िबोनाची सीरीज़ एल्गोरिद्म और डेटा स्ट्रक्चर्स में भी महत्वपूर्ण भूमिका निभाती है। उदाहरण के लिए, सर्च एल्गोरिद्म में समस्याओं को कुशलता से छोटे हिस्सों में बांटने के लिए फ़िबोनाची संख्याओं का उपयोग किया जाता है। यह Fibonacci heaps के पीछे भी है—एक प्रकार का डेटा स्ट्रक्चर जो कुछ ऑपरेशन्स, जैसे नेटवर्क में सबसे छोटा पथ ढूंढना, को तेज करता है।

यहाँ Python में फ़िबोनाची सीरीज़ जनरेट करने का एक सरल उदाहरण है:

def fibonacci(n):
	if n <= 1:
		return n
	return fibonacci(n - 1) + fibonacci(n - 2)

# Example usage
fibonacci_numbers = []

for i in range(10):
	fibonacci_numbers.append(str(fibonacci(i)))

print(' '.join(fibonacci_numbers))

# 0 1 1 2 3 5 8 13 21 34संचालित द्वारा

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

क्रिप्टोग्राफ़ी में, फ़िबोनाची संख्याएँ सुरक्षित कुंजियाँ जनरेट करने में मदद कर सकती हैं। और आर्टिफिशियल इंटेलिजेंस में, वे न्यूरल नेटवर्क्स को अनुकूलित करके एल्गोरिद्म के सीखने और अनुकूलन को बेहतर बनाती हैं। 

अन्य सामान्य उदाहरण

यहाँ कुछ और उदाहरण हैं कि यह सीरीज़ रोज़मर्रा की ज़िंदगी और विशिष्ट क्षेत्रों में कैसे दिखाई देती है:

• कला में: कलाकारों और वास्तुकारों ने सदियों से फ़िबोनाची सीरीज़ का उपयोग किया है। पार्थेनन जैसी प्रसिद्ध संरचनाएँ इन अनुपातों को दर्शाती हैं क्योंकि वे आँखों को स्वाभाविक रूप से आकर्षक लगते हैं।
• संगीत में: संगीतकार रिद्म और मेलोडीज़ बनाने के लिए फ़िबोनाची संख्याओं का उपयोग करते हैं। उदाहरण के लिए, वे 1 को होल नोट, 2 को हाफ नोट और 3 को क्वार्टर नोट देकर सुरीले पैटर्न बनाते हैं।
• ट्रेडिंग में: स्टॉक ट्रेडर्स बाज़ार के रुझानों का विश्लेषण करने के लिए फ़िबोनाची संख्याओं का उपयोग करते हैं। वे संभावित प्राइस स्तरों का अनुमान लगाने के लिए इन्हें लागू करते हैं जहाँ स्टॉक्स रिवर्स हो सकते हैं, जिससे खरीदने या बेचने के फ़ैसले में मदद मिलती है।
• भौतिकी में: क्वांटम फिज़िक्स में, कणों की पारस्परिक क्रियाओं और व्यवहार में फ़िबोनाची पैटर्न देखे गए हैं, जो दिखाते हैं कि ये अनुक्रम प्रकृति के सबसे छोटे पैमाने पर भी प्रकट होते हैं।

Python में फ़िबोनाची सीरीज़ लागू करना

क्योंकि Python फ़िबोनाची सीरीज़ जनरेट करने के कई तरीके प्रदान करता है, मैंने सबसे आम तरीकों को उदाहरणों के साथ चरण-दर-चरण समझाया है।

इटरेटिव विधि का उपयोग

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

मैं दो वेरिएबल, a और b, को 0 और 1. पर सेट करता/करती हूँ। ये सीरीज़ की पहली दो संख्याएँ दर्शाते हैं। फिर, मैं अगले नंबरों की गणना के लिए for लूप का उपयोग करता/करती हूँ। मैं a को b का मान दे देता/देती हूँ, और b पिछले a और b का योग बन जाता है।

इसके लिए Python कोड यह है:

n = 10
a, b = 0, 1

fibonacci_numbers = []

for _ in range(n):
    fibonacci_numbers.append(str(a))
    a, b = b, a + b

print(' '.join(fibonacci_numbers))

# 0 1 1 2 3 5 8 13 21 34संचालित द्वारा

यदि आप for लूप की जगह while लूप का उपयोग करना चाहते हैं, तो कोड ऐसे लिख सकते हैं:

# Number of terms to print in the Fibonacci series
n = 10

# Initialize the first two terms
a, b = 0, 1
i = 0

fibonacci_numbers = []

while i < n:
	fibonacci_numbers.append(str(a))
	# Update the terms
	a, b = b, a + b
	i += 1

print(' '.join(fibonacci_numbers))

# 0 1 1 2 3 5 8 13 21 34संचालित द्वारा

दोनों तरीके समझने में बहुत आसान हैं, इसलिए ये शुरुआती लोगों के लिए बिल्कुल उपयुक्त हैं। 

रिकर्सिव विधि का उपयोग

रिकर्सिव विधि फ़िबोनाची संख्याएँ जनरेट करने का एक और तरीका है। बड़ी सीरीज़ के लिए यह इटरेटिव विधि जितनी तेज़ नहीं है, लेकिन यह समझने के लिए बेहतरीन है कि सीरीज़ कैसे बनती है।

उदाहरण के लिए, मैं fibonacci_recursive नाम का एक फ़ंक्शन बनाता/बनाती हूँ। यह फ़ंक्शन इनपुट के रूप में संख्या n लेता है। यदि n 0 या 1 है, तो फ़ंक्शन n ही लौटाता है। ये बेस केस हैं जो रिकर्शन को रुकने का संकेत देते हैं। अन्य किसी भी संख्या के लिए, फ़ंक्शन खुद को कॉल करता है ताकि पिछली दो संख्याएँ निकाली जा सकें और उन्हें जोड़ा जा सके।

इसके लिए कोड यह है:

def fibonacci_recursive(n):
	if n <= 1:
		return n
	else:
		return fibonacci_recursive(n-1) + fibonacci_recursive(n-2)

num_terms = 10
fibonacci_numbers = []
for i in range(num_terms):
	fibonacci_numbers.append(str(fibonacci_recursive(i)))

print(' '.join(fibonacci_numbers))

# 0 1 1 2 3 5 8 13 21 34संचालित द्वारा

यह तरीका छोटी सीरीज़ के लिए अच्छा काम करता है, लेकिन जैसे-जैसे सीरीज़ बढ़ती है यह धीमा हो सकता है क्योंकि यह वही मान कई बार दोबारा गणना करता है।

कैशिंग के साथ अनुकूलित रिकर्सिव विधि

साधारण रिकर्शन की अक्षम्यता को दूर करने के लिए, मैं अक्सर कैशिंग का उपयोग करता/करती हूँ। Python का lru_cache पहले से गणना किए गए मानों को संग्रहीत करता है ताकि फ़ंक्शन को दोबारा काम न करना पड़े।

मैं इसे ऐसे करता/करती हूँ:

from functools import lru_cache

@lru_cache(maxsize = None)
def fib_cache(n):
    if n == 0:
        return 0  
    elif n == 1:
        return 1
    else:
        return fib_cache(n-1) + fib_cache(n-2)

print(f"The Fibonacci Number is {fib_cache(10)}")

# The Fibonacci Number is 55संचालित द्वारा

यह तरीका रिकर्शन की स्पष्टता को कैशिंग की दक्षता के साथ जोड़ता है।

Python में फ़िबोनाची करने के और उन्नत तरीके

यदि आप फ़िबोनाची संख्याएँ निकालने के अन्य तरीकों की तलाश में हैं, तो यहाँ कुछ और उन्नत तकनीकें हैं:

मैट्रिक्स घातांक

मैट्रिक्स घातांक n के बड़े मानों के लिए फ़िबोनाची संख्याएँ गणना करने के सबसे कुशल तरीकों में से एक है। बार-बार पदों की पुनर्गणना करने की बजाय, यह तरीका मैट्रिक्स गुणन का उपयोग करके लघुगणकीय समय में परिणाम प्राप्त करता है।

मैंने इसे Python में ऐसे लागू किया:

import numpy as np

def fibonacci_matrix(n):
	def matrix_power(matrix, power):
		return np.linalg.matrix_power(matrix, power)
	if n == 0:
		return 0
	matrix = np.array([[1, 1], [1, 0]])
	result = matrix_power(matrix, n-1)
	return result[0][0]

fibonacci_numbers = []

for i in range(10):
	fibonacci_numbers.append(str(fibonacci_matrix(i)))

print(' '.join(fibonacci_numbers))

# 0 1 1 2 3 5 8 13 21 34संचालित द्वारा

इस कोड में, यदि n 0 है, तो यह 0 बेस केस के रूप में लौटाता है। अन्य मानों के लिए, मैट्रिक्स को numpy के matrix_power फ़ंक्शन से (n-1) की घात तक बढ़ाया जाता है। स्थान n पर फ़िबोनाची संख्या परिणामी मैट्रिक्स के टॉप-लेफ़्ट एलिमेंट में मिलती है।

बिने का सूत्र (Binet's formula)

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

सूत्र यह है:

जहाँ:

• φ = (1 + √5) / 2​​, गोल्डन रेशियो।
• 1 - φ φ का कॉन्जुगेट है।

बिने के सूत्र के लिए Python कोड यह है:

import math

def fibonacci_binet(n):
    phi = (1 + math.sqrt(5)) / 2
    return round((phi ** n - (1 - phi) ** n) / math.sqrt(5))

# Find the 10th Fibonacci number
n = 10
result = fibonacci_binet(n)
print(f"The Fibonacci Number of {n}th term is {result}" )

# The Fibonacci Number of 10th term is 55संचालित द्वारा

इस कोड में, फ़ंक्शन fibonacci_binet(n) बिने के सूत्र का उपयोग करके nth फ़िबोनाची संख्या की गणना करता है। फ़ंक्शन के अंदर, मैं phi (गोल्डन रेशियो) को (1 + math.sqrt(5)) / 2 के रूप में निकालता/निकालती हूँ, जिसमें 5 का वर्गमूल लेने के लिए math.sqrt() का उपयोग होता है। फिर (phi ** n - (1 - phi) ** n) / math.sqrt(5) सूत्र सीधे nth फ़िबोनाची संख्या पाने के लिए लागू किया जाता है। उसके बाद, मैं किसी भी छोटे फ्लोटिंग-पॉइंट त्रुटि को संभालने के लिए round() फ़ंक्शन का उपयोग करता/करती हूँ।

एरेज़

आप पूरी फ़िबोनाची सीरीज़ को जनरेट और स्टोर करने के लिए एरेज़ का भी उपयोग कर सकते हैं। जब आपको एक साथ कई पदों की ज़रूरत हो, तब यह उपयोगी होता है।

इसके लिए कोड यह है:

def fibonacci(n):
    if n <= 0:
        return "Incorrect Output"
    data = [0, 1]  # Initialize list with first two Fibonacci terms: 0 and 1
    if n > 2:
        for i in range(2, n):  # Start loop from the third term
            data.append(data[i-1] + data[i-2])  # Calculate next term as sum of previous two
    return data[n-1]  # Return the nth term

print(f"Fibonacci Number: {fibonacci(10)}")

# Fibonacci Number: 34संचालित द्वारा

बैकट्रैकिंग

बैकट्रैकिंग एक और विकल्प है जिसका मैं उपयोग कर सकता/सकती हूँ, खासकर जब मैं बेहतर प्रदर्शन के लिए रिकर्शन को मेमोइज़ेशन के साथ जोड़ना चाहता/चाहती हूँ।

इसके लिए कोड यह है:

def fibonacci_backtracking(n, computed ={0: 0, 1: 1}):
    if n in computed:
        return computed[n]
    computed[n] = fibonacci_backtracking(n - 1) + fibonacci_backtracking(n - 2)
    return computed[n]

n = 10
result = fibonacci_backtracking(n)
print(f"The {n}th Fibonacci term is {result}")

# The 10th Fibonacci term is 55संचालित द्वारा

Python में फ़िबोनाची एल्गोरिद्म की जटिलता

हमने काफ़ी सारे उदाहरण देख लिए! अब समय और स्पेस जटिलता के संदर्भ में उनके अंतर देखें। जैसा कि हमने उल्लेख किया है, कुछ तरीके तेज़ हैं लेकिन अधिक मेमोरी का उपयोग करते हैं, जबकि अन्य धीमे हैं पर कम स्पेस लेते हैं। मैंने हर अप्रोच की दक्षता की तुलना के लिए यह तालिका तैयार की है।

ऊपर दी गई तालिका में, समय और स्पेस जटिलता का अर्थ यह है:

समय जटिलता

• O(n): एल्गोरिद्म सीरीज़ को एक बार इटरेट करता है और हर एलिमेंट के लिए निश्चित संख्या में ऑपरेशन्स करता है। समय इनपुट आकार n के साथ रैखिक रूप से बढ़ता है।

• O(1): बिना इटरेशन या रिकर्शन के निश्चित संख्या के ऑपरेशन्स से फ़िबोनाची संख्या निकाली जाती है।

• O(2ⁿ): एल्गोरिद्म हर इनपुट के लिए दो रिकर्सिव कॉल करता है, जिससे n बढ़ने पर फ़ंक्शन कॉल्स की संख्या घातीय रूप से बढ़ती है।

• O(log n): रनटाइम इनपुट आकार n के लघुगणक के अनुपात में बढ़ता है।

स्पेस जटिलता

• O(n): एल्गोरिद्म मेमोरी का उपयोग करता है जो इनपुट की संख्या n के साथ प्रत्यक्ष रूप से बढ़ता है। यहाँ प्रत्येक एलिमेंट निश्चित स्पेस लेता है।

• O(1): इनपुट आकार से स्वतंत्र होकर मेमोरी उपयोग स्थिर रहता है।

• O(2ⁿ): प्रत्येक शाखा के लिए नए स्टेट्स बनने के कारण घातीय स्पेस का उपयोग होता है।

• O(log n): मध्यवर्ती मैट्रिक्स गुणन लघुगणकीय मेमोरी का उपयोग करते हैं।

अंतिम विचार

जैसा कि आपने देखा, Python में आप साधारण लूप्स से लेकर मैट्रिक्स एक्सपोनेंशिएशन और बिने के सूत्र जैसी उन्नत तकनीकों तक कई तरीकों से फ़िबोनाची संख्याएँ निकाल सकते हैं। हर विधि की अपनी खूबियाँ और समझौते हैं।

आशा है आपने फ़िबोनाची सीरीज़ के साथ-साथ Python प्रोग्रामिंग के बारे में भी कुछ सीखा। यदि आप Python और संबंधित विषयों का अधिक अन्वेषण करना चाहते हैं, तो हमारा Introduction to Python कोर्स देखें। आप हमारा पूरा Python Developer करियर ट्रैक भी आज़मा सकते हैं, प्रोग्रामिंग तकनीकें सीखें और अपने स्वयं के पैकेज विकसित करना शुरू करें!