Recursion की मूल बातें
Recursive functions
Recursion की मूल बातें, CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
पुनरावर्तन क्या है
पुनरावर्तन वह प्रक्रिया है जिसमें कोई फ़ंक्शन उसी समस्या के छोटे रूप को हल करने के लिए स्वयं को कॉल करता है। यह कार्यात्मक प्रोग्रामिंग के लिए स्वाभाविक है और कई लूपों की जगह स्वयं-संदर्भित परिभाषाएँ देता है।
दो आवश्यक भाग
हर सही पुनरावर्ती फ़ंक्शन में ये होने चाहिए:
- एक आधार स्थिति, जो पुनरावर्तन रोकती है।
- एक पुनरावर्ती स्थिति, जो आधार स्थिति की ओर आगे बढ़ती है।
यदि आधार स्थिति तक पहुँचना संभव न हो, तो पुनरावर्तन अनंत समय तक चलता रहेगा।
फैक्टोरियल
क्लासिक उदाहरण: n! = n * (n-1)!, जिसमें 0! = 1 आधार स्थिति है।
object Main {
def factorial(n: Int): Int =
if (n <= 1) 1
else n * factorial(n - 1)
def main(args: Array[String]): Unit = {
println(factorial(5))
}
}कॉल का अनुक्रम देखना
हर पुनरावर्ती कॉल रुककर अंदरूनी परिणाम की प्रतीक्षा करती है। factorial(3) का विस्तार 3 * (2 * (1)) होता है। गुणा कॉल के वापस लौटने पर होता है।
object Main {
def factorial(n: Int): Int = {
println(s"entering factorial($n)")
if (n <= 1) 1 else n * factorial(n - 1)
}
def main(args: Array[String]): Unit = {
println("result = " + factorial(3))
}
}सूची का योग
सूची पर पुनरावर्तन: योग, पहले तत्व और शेष सूची के योग का जोड़ होता है; रिक्त सूची का योग शून्य होता है।
object Main {
def sum(xs: List[Int]): Int = xs match {
case Nil => 0
case h :: t => h + sum(t)
}
def main(args: Array[String]): Unit = {
println(sum(List(1, 2, 3, 4)))
}
}सूची की लंबाई
इसी पैटर्न से लंबाई भी निकाली जा सकती है: रिक्त सूची की लंबाई 0 होती है, अन्यथा शेष सूची की लंबाई में 1 जोड़ा जाता है।
object Main {
def length[A](xs: List[A]): Int = xs match {
case Nil => 0
case _ :: t => 1 + length(t)
}
def main(args: Array[String]): Unit = {
println(length(List("a", "b", "c")))
}
}कॉल स्टैक
हर लंबित पुनरावर्ती कॉल एक स्टैक फ़्रेम का उपयोग करती है। गहरा पुनरावर्तन कई फ़्रेम जमा कर देता है। बहुत बड़े इनपुट के लिए इससे स्टैक समाप्त हो सकता है और StackOverflowError उत्पन्न हो सकता है।
फिबोनाची
कुछ समस्याएँ कई पुनरावर्ती कॉलों में शाखित हो जाती हैं। Fibonacci स्वयं को दो बार कॉल करता है; यह सुंदर है, लेकिन इसकी लागत घातांकीय होती है।
object Main {
def fib(n: Int): Int =
if (n < 2) n
else fib(n - 1) + fib(n - 2)
def main(args: Array[String]): Unit = {
println(fib(10))
}
}सूची को उलटना
पुनरावर्तन नई संरचनाएँ भी बना सकता है: reverse, शेष सूची को उलटने के बाद पहले तत्व को अंत में जोड़ता है।
object Main {
def reverse[A](xs: List[A]): List[A] = xs match {
case Nil => Nil
case h :: t => reverse(t) :+ h
}
def main(args: Array[String]): Unit = {
println(reverse(List(1, 2, 3)))
}
}पुनरावर्तन बनाम पुनरावृत्ति
लूप काउंटर में परिवर्तन करते हैं; पुनरावर्तन समस्या को घोषणात्मक रूप में व्यक्त करता है। दोनों मान्य हैं। वृक्षाकार डेटा और विभाजित-कर-विजय समस्याओं के लिए पुनरावर्तन उपयोगी है, लेकिन बड़े रैखिक इनपुट पर साधारण पुनरावर्तन से स्टैक समाप्त होने का जोखिम रहता है।
महत्तम समापवर्तक
यूक्लिड का एल्गोरिदम स्वाभाविक रूप से पुनरावर्ती है और तेज़ी से परिणाम तक पहुँचता है।
object Main {
def gcd(a: Int, b: Int): Int =
if (b == 0) a else gcd(b, a % b)
def main(args: Array[String]): Unit = {
println(gcd(48, 18))
}
}त्वरित जाँच
पुनरावर्तन की अपनी बुनियादी समझ जाँचें।
पुनरावलोकन
आपने पुनरावर्तन की बुनियादी बातें सीखीं:
- हर पुनरावर्ती फ़ंक्शन को आधार स्थिति और पुनरावर्ती स्थिति की आवश्यकता होती है।
- हर लंबित कॉल एक स्टैक फ़्रेम का उपयोग करती है; गहरे पुनरावर्तन से स्टैक समाप्त हो सकता है।
- पुनरावर्तन सूची और वृक्ष एल्गोरिदम को स्वाभाविक रूप से व्यक्त करता है।
आगे आप @tailrec एनोटेशन से पुनरावर्तन को स्टैक-सुरक्षित बनाएँगे।
एआई शिक्षक के साथ Scala सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 39
- पाठ
- 143
अक्सर पूछे जाने वाले प्रश्न
क्या “Recursion की मूल बातें” पाठ निःशुल्क है?
हाँ—“Recursion की मूल बातें” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“Recursion की मूल बातें” में मैं क्या सीखूँगा?
Recursive functions आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।
“Recursion की मूल बातें” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- Recursion की मूल बातें
- tailrec Annotation
- Accumulator Pattern
- Trampolining