Python एल्गोरिदम

Python में Recursive Factorial

Recursive function से n! निकालें।

  • मध्यम
  • 2 मिनट में पढ़ें
  • 1 चलाने योग्य उदाहरण

में Recursive Factorial क्या है?

समस्या क्या है

कुछ समस्याओं को उनके ही छोटे रूप से समझाया जा सकता है: फ़ोल्डर के अंदर फ़ोल्डर होते हैं, फ़ैमिली ट्री के अंदर छोटे फ़ैमिली ट्री होते हैं, और n! का मतलब है n गुणा (n - 1)!। Recursion (function का ख़ुद को कॉल करना) से आप ऐसा code लिख सकते हैं जो इन परिभाषाओं को सीधे फ़ॉलो करे।

ऐसे समझें

Recursion ऐसा है जैसे लोगों की एक लाइन में एक सवाल आगे बढ़ाया जा रहा हो। 6! जानने के लिए पहला व्यक्ति अगले से 5! पूछता है और इंतज़ार करता है। वह अगले से 4! पूछता है, और ऐसे ही चलता रहता है, जब तक किसी से 1! नहीं पूछा जाता, जिसका जवाब वह तुरंत दे देता है। फिर हर जवाब लाइन में वापस लौटता है, और हर व्यक्ति उसमें अपना नंबर गुणा कर देता है।

लोगों की लाइन से code तक
factorial(6)🙋 पहला व्यक्ति: 6 × वह जवाब जिसका वह इंतज़ार कर रहा है
number * factorial(number - 1)➡️ अगले व्यक्ति से वही सवाल, छोटे नंबर के साथ पूछिए
if number <= 1: return 1🛑 आख़िरी व्यक्ति तुरंत जवाब देता है: 1
720⬅️ जवाब लाइन में वापस लौटते हैं: 720
हर कॉल एक छोटी कॉल का इंतज़ार करती है, जब तक base case जवाब न दे।
एक वाक्य में

Recursive function ख़ुद को छोटे इनपुट के साथ कॉल करता है, जब तक वह ऐसे base case तक न पहुँचे जिसका जवाब सीधे दिया जा सके। यहाँ factorial(n) = n × factorial(n - 1) और factorial(1) = 1।

मुख्य बातें

  1. if number <= 1: return 1 base case है; इसके बिना कॉल कभी नहीं रुकेंगी।
  2. return number * factorial(number - 1) वही function छोटी संख्या के साथ कॉल करता है।
  3. factorial(6) factorial(5) का इंतज़ार करता है, जो factorial(4) का इंतज़ार करता है, नीचे factorial(1) तक।
  4. raise ValueError(...) negative संख्याओं को रोक देता है, क्योंकि वे वरना कभी base case तक नहीं पहुँचतीं।

इसका उपयोग कब करें?

  • ऐसी समस्याएँ जो अपने छोटे रूपों से बताई जाती हैं: tree, फ़ोल्डर, nested डेटा।
  • Merge sort जैसे divide-and-conquer algorithm।
  • यह सीखना कि call stack कैसे काम करता है।

कब ज़रूरत नहीं

  • असली code में factorial जैसा सीधा दोहराव: loop या math.factorial ज़्यादा तेज़ है और उसकी कोई depth limit नहीं।
  • बहुत बड़े इनपुट, जिनमें कॉल बहुत गहरी हो जाइए: Python करीब 1,000 nested कॉल पर RecursionError देकर रुक जाता है।

देखें यह कैसे काम करता है

हर कॉल को देखने के लिए अगला चरण दबाएँ। नई कॉल कॉल स्टैक पर जाती हैं, और हर कॉल अपना मान उसे लौटाती है जिसने उसे बुलाया था।

उदाहरण कोड

कोड चलाएँ →
main.py
def factorial(number):
    if number < 0:
        raise ValueError("Factorial is undefined for negative numbers")
    if number <= 1:
        return 1
    return number * factorial(number - 1)

print(factorial(6))
इस उदाहरण के लिए Run बटन बनाएँ

अपेक्षित आउटपुट

720

यह कैसे काम करता है

हर call n घटाता है; समय और call-stack depth दोनों O(n) हैं।

मान बदलें और Python इंस्टॉल किए बिना CodeUtility ऑनलाइन Python कंपाइलर में प्रोग्राम चलाएँ।

अभ्यास के कार्य

बड़े dataset पर जाने से पहले input बदलें और edge cases की जाँच करें।

  1. खाली input, एक element और duplicate values जाँचें।
  2. हर चरण के बाद state दिखाएँ।
  3. Performance को दूसरे solution से तुलना करें।
Python IDE में चलाएँ →

आम गलतियाँ

Base case भूल जाना

function ख़ुद को तब तक कॉल करता रहता है जब तक Python RecursionError न दे।

समस्या
def factorial(number):
    return number * factorial(number - 1)
सुधार
def factorial(number):
    if number <= 1:
        return 1
    return number * factorial(number - 1)

यह पाठ पूरा कर लिया?

अपनी प्रगति ट्रैक करने के लिए इसे सीखा हुआ मार्क करें।

चैलेंज से अभ्यास करें

इस पाठ में सीखी बात से एक असली समस्या हल करें। हर चैलेंज ब्राउज़र में चलता है, तुरंत टेस्ट और AI रिव्यू के साथ।

सभी चैलेंज