लोड हो रहा है...

रिकर्शन

एक मेथड लिखें जिसका नाम down हो और एक int नाम n ले। अगर n 0 या उससे कम है, सादे return; से रुक जाएँ। नहीं तो n लिखें, फिर उसी मेथड के अंदर से down(n - 1) बुलाएँ। Main से down(3); बुलाएँ। स्क्रीन पर तीन पंक्तियाँ दिखनी चाहिए: 3, फिर 2, फिर 1। मेथड छोटे नंबर के साथ खुद को बुलाती रहती है जब तक स्टॉप श्रृंखला खत्म न करे। यही स्वयं-कॉल और स्टॉप इस पेज का पाठ है। पब्लिक क्लास का नाम Pine रखें।

एक मेथड जो खुद को बुलाती है

स्कोप पेज पर mark एक बार चली और खत्म हुई। यहाँ down चलती है, फिर पहली कॉल पूरी तरह खत्म होने से पहले नए आर्ग्युमेंट के साथ एक और down शुरू करती है। हर कॉल का अपना n होता है। श्रृंखला तभी खत्म होती है जब कोई कॉल स्टॉप पर पहुँचे।
Pine फ़ाइल खोलें। क्लास का नाम Pine ही रहता है। यह पेज टाइप का नाम नहीं बदलता। अगर mark डेमो अभी भी Main में बचा है, उसे हटा दें। कोई भी बचा paint हटा दें। कोई भी ReadLine पंक्ति हटा दें। जो फ़ाइल आप रखते हैं वह टाइपिंग का इंतज़ार नहीं करती।
Main के बाहर, फिर भी क्लास के ब्रेसेस के अंदर, लिखें static void down(int n)। इस पेज पर void रखें: हर कदम लिखता है, और टाइप वाले return से कुछ वापस लाने की ज़रूरत नहीं। स्टॉप बिना वैल्यू के return; इस्तेमाल करता है — यह केवल इसी कॉल को खत्म करता है। चलाने से पहले फ़ाइल सेव करें। पूरा पहला प्रोग्राम अगले बॉक्स में है।

जो फ़ाइल आप रखते हैं

यह वह संस्करण है जिसे आप पहले चलाते हैं। Main एक कॉल रखता है। down स्टॉप, लिखने की पंक्ति, और स्वयं-कॉल रखता है।

down writes then calls itself

csharp 
using System;

public class Pine
{
    public static void Main()
    {
        down(3);
    }

    static void down(int n)
    {
        if (n <= 0)
        {
            return;
        }
        Console.WriteLine(n);
        down(n - 1);
    }
}

ऊपर से पढ़ें। using System; छोटे नाम तैयार करता है। public class Pine टाइप का नाम रखता है। public static void Main() वह जगह है जहाँ रनटाइम शुरू होता है। कॉल down(3) में n की वैल्यू 3 होती है। यह 0 से बड़ी है, इसलिए मेथड 3 लिखती है, फिर down(2) बुलाती है। दूसरी कॉल 2 लिखती है, फिर down(1) बुलाती है। तीसरी कॉल 1 लिखती है, फिर down(0) बुलाती है। 0 वाली कॉल if (n <= 0) पर लगती है और बिना लिखे लौटती है। श्रृंखला खत्म। स्क्रीन पर तीन पंक्तियाँ: 3, फिर 2, फिर 1।

dotnet run से चलाएँ। प्रोग्राम तीन पंक्तियाँ लिखता है और रुक जाता है। वह आपके टाइप करने का इंतज़ार नहीं करता। अगर dotnet run इंतज़ार करे, तो ReadLine अभी फ़ाइल में है। उस पंक्ति को हटाएँ और down(3); तथा ऊपर वाली down मेथड रखें। स्क्रीन 3, फिर 2, फिर 1 दिखाती है। अगर स्क्रीन केवल 4 दिखाए, तो बचा mark(4) कॉल अभी चल रहा है। अगर स्क्रीन अक्षर down दिखाए, तो किसी लिखने की पंक्ति में कोट्स हैं: Console.WriteLine("down");। गलत पंक्तियाँ दिखने पर आप .NET SDK दोबारा इंस्टॉल नहीं करते।

एक पूरी रन क्रम से चलें। C# Main से शुरू होता है। कॉल down(3) में n बराबर 3 होता है। यह 0 से बड़ा है, इसलिए मेथड 3 लिखती है, फिर down(2) बुलाती है। दूसरी कॉल 2 लिखती है, फिर down(1) बुलाती है। तीसरी कॉल 1 लिखती है, फिर down(0) बुलाती है। 0 वाली कॉल n <= 0 पर लगती है और बिना लिखे लौटती है। श्रृंखला खत्म। स्क्रीन तीन लिखी पंक्तियाँ रखती है।
इनमें से हर कॉल उसी मेथड टेक्स्ट से अलग पास है। पहला पास down(2) शुरू करने के बाद अभी भी काम बाकी रखता है — यानी अंदर की कॉल लौटने के बाद खत्म होना। आप चार अलग मेथड नाम नहीं लिखते। आप एक मेथड लिखते हैं और छोटा आर्ग्युमेंट स्टॉप की ओर प्रगति ले जाता है।
अगर शुरू को down(2); कर दें, स्क्रीन को 2 फिर 1 दिखाना चाहिए। मेथड बॉडी वही रहती है; केवल पहला आर्ग्युमेंट बदलता है, इसलिए श्रृंखला छोटी होती है। down(4); से शुरू करने पर चार पंक्तियाँ दिखनी चाहिए: 4, 3, 2, 1। फिर बॉडी नहीं बदलती; केवल Main पहली वैल्यू चुनता है।

स्टॉप पहले रखें

स्टॉप को लिखने की पंक्ति और स्वयं-कॉल से पहले जाँचना चाहिए। अगर आप पहले लिखें और कभी n न जाँचें, या हमेशा उसी वैल्यू से down(n) बुलाएँ, प्रोग्राम खत्म नहीं होता। इस शुरुआती आकार पर मेथड के ऊपर if (n <= 0) ब्लॉक रखें।

stop checked before write

csharp 
using System;

public class Pine
{
    public static void Main()
    {
        down(2);
    }

    static void down(int n)
    {
        if (n <= 0)
        {
            return;
        }
        Console.WriteLine(n);
        down(n - 1);
    }
}

यह दूसरी फ़ाइल है। यह छोटे शुरू के साथ वही बॉडी सिखाती है। dotnet run चलाएँ। स्क्रीन 2 फिर 1 दिखाती है। जब n 0 पहुँचता है स्टॉप अभी भी श्रृंखला खत्म करता है। down(n - 1) की जगह down(n) लिखना वही नंबर बार-बार भेजता है। फिर प्रोग्राम तब तक चल सकता है जब तक सिस्टम न रोके। छोटा आर्ग्युमेंट विचार का हिस्सा है: हर कॉल को स्टॉप की ओर बढ़ना चाहिए।
स्टॉप को बाहर निकलने का दरवाज़ा समझें। लिखने की पंक्ति इस कदम का काम है। स्वयं-कॉल अगला कदम है। अगर दरवाज़ा गायब हो, हर कदम बिना अंत के दूसरा कदम खोलता है। अगर अगला कदम वही n इस्तेमाल करे, आप दरवाज़े की ओर कभी नहीं चलते। दोनों गलतियाँ सोर्स में अलग दिखती हैं, पर दोनों इस शुरुआती आकार पर साफ़ खत्म होने से इनकार करती हैं। 2 फिर 1 देखने के बाद, अगर वह आकार सेव करना हो तो रखी down(3) फ़ाइल वापस रख दें।

स्क्रीन के साथ कॉल श्रृंखला

एक शुरू कॉल को उन पंक्तियों के साथ पढ़ें जो वह बनाती है। टेबल की हर पंक्ति down की एक यात्रा है जो अभी लिखती है।

📊 down call chain for down(3)

Call Value of n Screen line
first down(3) 3 3
then down(2) 2 2
then down(1) 1 1
then down(0) 0 (no line — stop)

एक आम गलती स्टॉप छोड़ देना है। तब हर कॉल लिखती है और हमेशा के लिए फिर बुलाती है। दूसरी गलती रिकर्सिव कॉल के बाद लिखना है, पहले नहीं। इस पेज पर लिखने की पंक्ति पहले आती है, इसलिए स्क्रीन काउंटडाउन करती है। अगर आप Console.WriteLine को down(n - 1) के नीचे ले जाएँ, पंक्तियों का क्रम बदल जाता है — यहाँ दिखाए काउंटडाउन के लिए लिखने की पंक्ति स्वयं-कॉल के ऊपर रखें।
पिछले पेज का स्कोप थोड़ा अभी भी मायने रखता है: हर कॉल का n उसी कॉल का पैरामीटर है। बाहरी कॉल का n अंदर की कॉल चलने पर खुद नहीं बदलता। अंदर की कॉल का अलग n होता है। जब अंदर की कॉल लौटती है, बाहरी कॉल स्वयं-कॉल के बाद की पंक्ति से जारी रहती है — और इस पेज पर वह बस मेथड का अंत है।
बचा mark डेमो उसी फ़ाइल में रह सकता है और स्क्रीन भ्रमित कर सकता है अगर Main अभी भी mark बुलाए। इस पेज सीखते हुए Main को down(3); या down(2); तक साफ़ रखें। down को Main के ब्रेसेस के अंदर नेस्ट न करें। मेथड्स क्लास के अंदर, Main के बगल में बैठती हैं।
Main में Console.WriteLine("down"); लिखना शब्द down लिखता है। यह श्रृंखला शुरू नहीं करता। तीन काउंटडाउन पंक्तियाँ चाहिए तो down(3); रखें।

एक और आकार: स्टॉप कुछ नहीं लिखता

आपने देखा कि 0 वाली कॉल चुपचाप लौटती है। आप शुरू वैल्यू 1 भी अभ्यास कर सकते हैं। स्क्रीन पर एक ही पंक्ति दिखनी चाहिए: 1। फिर अगली कॉल down(0) है, जो रुकती है।

down starting at one

csharp 
using System;

public class Pine
{
    public static void Main()
    {
        down(1);
    }

    static void down(int n)
    {
        if (n <= 0)
        {
            return;
        }
        Console.WriteLine(n);
        down(n - 1);
    }
}

यह तीसरी फ़ाइल है। dotnet run चलाएँ। स्क्रीन एक पंक्ति दिखाती है: 1। वही मेथड बॉडी down(3), down(2), और down(1) को ढकती है। केवल Main में पहला आर्ग्युमेंट बदलता है। इस शुरुआती पेज के लिए इतना काफी है। रिकर्शन से योग लौटाने जैसे गहरे विचार बाद के कोर्स के लिए हैं; यहाँ लक्ष्य स्वयं-कॉल, छोटा आर्ग्युमेंट, और स्टॉप है।
अगर स्क्रीन कुछ भी न दिखाए, जाँचें कि Main अभी भी कुछ और बुला रहा है या नहीं, या स्टॉप टेस्ट गलत है — उदाहरण के लिए if (n >= 0) सकारात्मक n से शुरू करने पर किसी भी लिखने से पहले रोक देगा। शांत निकास के रूप में n <= 0 रखें, और Main में सकारात्मक शुरू रखें ताकि कम से कम एक पंक्ति दिख सके।

आप down(int n) लिख सकते हैं, जब n 0 या कम हो रुकें, n लिखें, फिर down(n - 1) बुलाएँ। Main से एक कॉल पूरी श्रृंखला शुरू करती है। स्क्रीन काउंटडाउन पंक्तियाँ दिखाती है। जो मेथड कभी स्टॉप की ओर न बढ़े वह खत्म नहीं होती। अगला पेज classes है, जहाँ आप इन static मेथड पेजों से आगे फ़ील्ड वाले टाइप बनाना शुरू करते हैं।

स्क्रीन काउंटडाउन रखती है

जो फ़ाइल आप रखते हैं, जब Main down(3); बुलाता है तो 3, फिर 2, फिर 1 लिखती है। स्वयं-कॉल down के अंदर है, और अक्षर down स्क्रीन पर प्रिंटेड लेबल नहीं हैं जब तक आपने उन्हें कोट न किया हो। Main के अंदर down नेस्ट करना इस पाठ का आकार नहीं है।

🧠 अपने ज्ञान की परीक्षा करें

शुरू करने के लिए तैयार

अपने ज्ञान की परीक्षा करें

इस इंटरैक्टिव क्विज़ के साथ अपनी चुनौती लें और देखें कि आप विषय को कितनी अच्छी तरह समझते हैं

❓
5
प्रश्न
🎯
70%
पास करने के लिए
♾️
∞
समय
🔄
∞
प्रयास

📝 निर्देश

  • हर प्रश्न को ध्यान से पढ़ें
  • हर प्रश्न के लिए सबसे अच्छा उत्तर चुनें
  • आप जितनी बार चाहें क्विज़ दोबारा दे सकते हैं
  • आपकी प्रगति शीर्ष पर दिखाई जाएगी
विषय 30 का 33
C-Sharp ट्यूटोरियल