क्या आप कभी ऐसे अंतहीन चक्र में फंस गए हैं जहां एक समस्या छोटे-छोटे टुकड़ों में बंटती रहती है?
यदि ऐसा है, तो आप रिकर्सन की मोहक दुनिया में आ गए होंगे। हालांकि यह समझने में चुनौतीपूर्ण लग सकता है, चिंता न करें! इस पोस्ट में, हम पुनरावर्तन के प्रकारों के बारे में जानने के लिए एक दिलचस्प यात्रा पर चलेंगे।
इसलिए कमर कस लें क्योंकि हम कई पुनरावर्ती दृष्टिकोणों का पता लगाते हैं। पुनरावर्तन के आकर्षक क्षेत्र में प्रवेश करने की तैयारी करें और जटिल मुद्दों को हल करने में इसकी उल्लेखनीय क्षमता का निरीक्षण करें।
रिकर्सन वास्तव में क्या हैं?
मूल शब्दों में, पुनरावर्तन एक शक्तिशाली प्रोग्रामिंग तकनीक है जिसमें निष्पादन के दौरान स्वयं को कॉल करने वाला फ़ंक्शन शामिल होता है। यह एक दर्पण में घूरने और एक छवि के अंदर एक छवि देखने जैसा है, जिसके परिणामस्वरूप एक आत्म-संदर्भ चक्र होता है।
हम बड़े मुद्दों को छोटे, अधिक प्रबंधनीय उप-समस्याओं में विभाजित करके पुनरावर्तन का उपयोग करके निपट सकते हैं।
यह एक जिग्स को एक साथ रखने के समान है, जहां एक टुकड़ा दूसरे हिस्सों से पूरी तस्वीर बनाने के लिए लिंक करता है। पुनरावर्तन हमें विभिन्न इनपुट के साथ निर्देशों के समान सेट को दोहराकर एक सुरुचिपूर्ण और कुशल तरीके से मुद्दों को हल करने की अनुमति देता है।
1-डायरेक्ट रिकर्सन
प्रत्यक्ष पुनरावर्तन सबसे बुनियादी प्रकार का पुनरावर्तन है, जिसमें एक फ़ंक्शन स्वयं को सीधे कॉल करता है। यह एक समस्याग्रस्त समस्या को छोटे उप-समस्याओं में तब तक विभाजित करने पर जोर देता है जब तक कि एक आधार मामला प्राप्त नहीं हो जाता है, जो समाप्ति की ओर ले जाता है।
रिकर्सिव फ़ंक्शन स्वयं को विभिन्न इनपुट के साथ कॉल करता है, जिससे निर्देशों के समान सेट को दोहराया जा सकता है। प्रत्येक मंगलाचरण पहले वाले पर बनता है, उत्तरोत्तर बेस केस के करीब पहुंचता है जिससे पुनरावर्तन समाप्त हो जाता है।
आइए इस उदाहरण की जाँच करें।
def countdown(n):
if n <= 0:
return
print(n)
countdown(n - 1)
countdown(5)
आउटपुट:
5
4
3
2
1
2-अप्रत्यक्ष पुनरावर्तन
अप्रत्यक्ष पुनरावर्तन पुनरावर्ती पथ में एक पेचीदा मोड़ जोड़ता है। प्रत्यक्ष पुनरावर्तन के विपरीत, जिसमें एक फ़ंक्शन स्पष्ट रूप से स्वयं को कॉल करता है, अप्रत्यक्ष पुनरावर्तन में फ़ंक्शन कॉल की एक श्रृंखला शामिल होती है।
एक फ़ंक्शन दूसरे को कॉल करता है, जो तब मूल फ़ंक्शन या किसी अन्य फ़ंक्शन को कॉल कर सकता है जो अंत में मूल पर वापस जाता है। फ़ंक्शन कॉल का यह आपस में जुड़ा हुआ वेब एक आकर्षक नृत्य उत्पन्न करता है जिसमें कई फ़ंक्शन एक समस्या को ठीक करने के लिए सहयोग करते हैं।
उदाहरण:
def function_A(n):
if n > 0:
print("A:", n)
function_B(n - 1)
def function_B(n):
if n > 0:
print("B:", n)
function_A(n - 1)
function_A(3)
आउटपुट:
A: 3
B: 2
A: 1
3-रैखिक पुनरावर्तन
जब तक आप अपने उद्देश्य पर नहीं पहुंच जाते, तब तक एक सीधे रास्ते पर एक यात्रा पर विचार करें, एक समय में एक कदम। यह अनुक्रमिक तकनीक रैखिक पुनरावर्तन द्वारा सन्निहित है, जिसमें एक फ़ंक्शन प्रत्येक फ़ंक्शन पुनरावृत्ति में एक एकल पुनरावर्ती कॉल करता है।
प्रत्येक पुनरावर्ती कॉल के साथ, पुनरावर्ती प्रक्रिया मुद्दे के आकार को कम करके आधार मामले के करीब जाती है। यह एक स्पष्ट और रैखिक तरीके से आगे बढ़ता है, अंतिम उत्तर तक पहुंचने तक उप-समस्याओं को एक समय में हल करता है।
उदाहरण:
def factorial(n):
if n == 0:
return 1
return n * factorial(n - 1)
result = factorial(5)
print(result)
आउटपुट:
120
4-ट्री रिकर्सन
जब कोई फंक्शन कई रिकर्सिव कॉल्स में ब्रांच करता है, तो हम ट्री रिकर्सन की दुनिया में प्रवेश करते हैं। ट्री रिकर्सन में एक फ़ंक्शन कई पुनरावर्ती कॉल उत्पन्न करता है, जिनमें से प्रत्येक एक अलग उपसमस्या को हल करता है, ठीक वैसे ही जैसे एक पेड़ की शाखाएं करती हैं।
यह शाखाओं वाली संरचना कई मार्गों की एक साथ जांच की अनुमति देती है, जटिल मुद्दों को छोटे, परस्पर संबंधित घटकों में प्रभावी रूप से तोड़ती है।
उदाहरण:
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
result = fibonacci(6)
print(result)
आउटपुट:
8
5-नेस्टेड रिकर्सन
नेस्टेड पुनरावर्तन पुनरावर्ती ब्रह्मांड में जटिलता की एक रोमांचक डिग्री जोड़ता है। पुनरावर्तन के इस रूप में, एक फ़ंक्शन एक पुनरावर्ती कॉल को एक अन्य पुनरावर्ती कॉल के भीतर एक तर्क के रूप में शामिल करता है।
आंतरिक पुनरावर्ती कॉल एक मान पर कार्य करता है जो बाहरी पुनरावर्ती कॉल पर निर्भर होता है। जटिलता प्रत्येक नेस्टेड आह्वान के साथ बढ़ती है, नेस्टेड पुनरावर्ती कॉल के एक पेचीदा पैटर्न में परिणत होती है।
उदाहरण:
def nested_recursion(n):
if n > 100:
return n - 10
return nested_recursion(nested_recursion(n + 11))
result = nested_recursion(95)
print(result)
रिजल्ट:
91
6-टेल रिकर्सन
पूंछ पुनरावर्तन पुनरावर्ती एल्गोरिदम के लिए एक अनुकूलन तकनीक है जो उनके प्रदर्शन में सुधार कर सकता है। पुनरावर्ती कॉल पूंछ पुनरावर्तन के साथ एक फ़ंक्शन की अंतिम क्रिया के रूप में प्रकट होता है, बनाना।
चूंकि पुनरावर्ती कॉल के बाद कोई उत्कृष्ट संचालन नहीं होता है, इसलिए संकलक या दुभाषिया एक साधारण छलांग के साथ पुनरावृत्ति को सरल बना सकते हैं।
टेल कॉल ऑप्टिमाइज़ेशन के रूप में जाना जाने वाला यह ऑप्टिमाइज़ेशन दृष्टिकोण, स्टैक फ़्रेम को बनाए रखने के लिए प्रत्येक पुनरावर्ती कॉल की आवश्यकता को कम करता है, जिसके परिणामस्वरूप गति और कम मेमोरी उपयोग में वृद्धि होती है।
उदाहरण:
def tail_factorial(n, result=1):
if n == 0:
return result
return tail_factorial(n - 1, result * n)
result = tail_factorial(5)
print(result)
बाहर बाहर:
120
7-नॉन-टेल रिकर्सन
पूंछ रिकर्सन के विपरीत, गैर-पूंछ रिकर्सन में फ़ंक्शन के भीतर रिकर्सिव कॉल के बाद की जाने वाली अतिरिक्त गतिविधियां शामिल होती हैं। इससे पहले कि कोई और कार्रवाई की जा सके, प्रत्येक पुनरावर्ती कॉल को पूरा करना होगा और वापस लौटना होगा।
नतीजतन, जब तक आधार मामला नहीं पहुंच जाता है और रिकर्सन समाप्त हो जाता है, बकाया संचालन का ढेर बनाए रखा जाता है। नॉन-टेल रिकर्सन अक्सर अधिक मेमोरी का उपयोग करता है और टेल रिकर्सन की तुलना में कम कुशल होता है, लेकिन यह अभी भी विभिन्न मुद्दों से निपटने के लिए एक सहायक उपकरण है।
उदाहरण:
def non_tail_sum(n):
if n == 0:
return 0
return n + non_tail_sum(n - 1)
result = non_tail_sum(5)
print(result)
आउटपुट:
15
लपेटें
प्रोग्रामिंग में रिकर्सन एक दिलचस्प अवधारणा है। यह हमें पुनरावर्ती, आत्म-संदर्भित तरीके से जटिल समस्याओं से निपटने की अनुमति देता है।
यह समस्याओं के बारे में सोचने और उन्हें हल करने का एक अलग तरीका प्रदान करता है, उन्हें छोटे, अधिक प्रबंधनीय हिस्सों में तोड़ देता है। हालांकि, रिकर्सन के साथ काम करते समय, कुछ बिंदुओं पर ध्यान देना महत्वपूर्ण है।
आपको उपयुक्त आधार मामलों की पहचान करनी चाहिए जो रिकर्सन को समाप्त करने की अनुमति देते हैं। यदि वे मौजूद नहीं हैं, तो फ़ंक्शन स्वयं को हमेशा के लिए कॉल करना जारी रख सकता है।
दूसरा, वर्तमान परिदृश्य के आधार पर, उपयुक्त प्रकार के पुनरावर्तन का चयन करने से अधिक कुशल और सुरुचिपूर्ण समाधान प्राप्त हो सकते हैं। हाथ में समस्या के लिए सबसे अच्छा काम करने का प्रयास करें। विशाल पुनरावर्ती गहराई के साथ काम करते समय, स्टैक ओवरफ्लो जैसे संभावित खतरों से अवगत रहें।
एक जवाब लिखें