रिकर्शन में ऐरे के सीमित प्रीफ़िक्स को पढ़ना

हर कॉल का हिस्सा साफ़ तय करें

ऐरे पर काम करने वाले रिकर्सिव helper को यह जानना होता है कि कहाँ से पढ़ना है और कितने तत्वों तक पढ़ना है। इस पाठ में हर कॉल एक ही ऐरे के पहले n तत्वों पर काम करेगी, ठीक उन्हीं के लिए परिणाम लौटाएगी और अगला तत्व पढ़ने की कोशिश से पहले खाली प्रीफ़िक्स पर रुक जाएगी। प्रीफ़िक्स का अर्थ यहाँ ऐरे का शुरुआती हिस्सा है। हम पढ़े गए तत्वों और लौटे मानों का ट्रेस बनाएँगे; यह नहीं मानेंगे कि रिकर्शन ऐरे की प्रतियाँ बनाता है या उसे वास्तव में छोटा करता है।

पहले ये पाठ इसी क्रम में पढ़ें:

1. रिकर्शन: आधार स्थिति और कॉल स्टैक: अलग-अलग कॉल और caller के सुरक्षित रहने वाले स्थानीय मान।
2. रिकर्शन का समापन और आधार स्थिति का चुनाव: अनुमत इनपुट, घटता हुआ गैर-ऋणात्मक माप और असुरक्षित क्रिया से पहले रुकने की शर्त।
3. रिकर्शन: लौटे मान और बची हुई गणना: अंदर वाली कॉल का लौटाया परिणाम और caller का बाकी काम।

सामान्य int चर, आर्ग्युमेंट के मान की कॉपी, if, return, शुरुआती मान दिए गए निश्चित आकार के ऐरे और शून्य से शुरू होने वाले इंडेक्स भी आने चाहिए। int a[4] के तत्वों के इंडेक्स 0, 1, 2 और 3 होते हैं। इस पाठ के लिए जितना ऐरे-पैरामीटर व्यवहार चाहिए, वह यहीं समझाया गया है; पहले से पॉइंटर अंकगणित जानना ज़रूरी नहीं। दायरा छोटे, केवल पढ़ने वाले ऐसे रिकर्शन तक है जिसमें हर गैर-आधार कॉल एक अंदर वाली कॉल करती है। ऐरे बदलना, पॉइंटर अंकगणित, डायनैमिक मेमोरी, शाखाओं वाला रिकर्शन और जटिलता का औपचारिक विश्लेषण इस पाठ में नहीं हैं।

ऐरे और लंबाई की स्पष्ट शर्तें

सभी दिखाए गए प्रोग्राम C11 में हैं। इस पाठ के हर helper के लिए:

• caller पहले से मौजूद int ऐरे देता है जिसकी वास्तविक क्षमता 1 से 6 तक है। क्षमता, यानी capacity, उस ऐरे में वास्तव में मौजूद तत्वों के स्थानों की संख्या है।
• हर तत्व को शुरुआती मान दिया गया है और वह -9 से 9 तक है। पूरी कॉल और उसकी अंदर वाली कॉलों के दौरान ऐरे मौजूद रहता है और उसके तत्व नहीं बदलते।
• लंबाई n एक पूर्णांक है जिसके लिए 0 <= n <= capacity है। n > 0 होने पर यह a[0] से a[n - 1] तक का शुरुआती हिस्सा चुनता है।
• n == 0 पर चुना हुआ हिस्सा खाली है। उसमें कोई तत्व नहीं है और ऐरे से कुछ पढ़ना आवश्यक नहीं। हम तब भी पहले से मौजूद ऐरे ही पास करते हैं। शून्य लंबाई का C ऐरे घोषित नहीं करते; null पॉइंटर वाले आर्ग्युमेंट इस पाठ की शर्तों में शामिल नहीं हैं।
• हर गैर-आधार कॉल उसी ऐरे और लंबाई n - 1 के साथ ठीक एक अंदर वाली कॉल करती है। कोई अंदर वाली कॉल ऐरे के तत्व या शुरुआती पॉइंटर नहीं बदलती।

क्षमता वास्तविक ऐरे ऑब्जेक्ट की है; n काम के लिए चुनी गई लंबाई है। चार तत्वों वाले ऐरे से लंबाई 0, 1, 2, 3 या 4 का प्रीफ़िक्स चुना जा सकता है। लंबाई 3 का अर्थ इंडेक्स 3 चुनना नहीं है। इसका अर्थ तीन तत्व चुनना है, जिनका आखिरी इंडेक्स 2 है।

ये शर्तें caller को पूरी करनी हैं; इनकी अपने आप रन-टाइम जाँच नहीं होती। helper को क्षमता अलग से नहीं दी गई है और C, a[] पैरामीटर देखकर यह सीमा पता लगाकर लागू नहीं करता। ऋणात्मक लंबाई, क्षमता से बड़ी लंबाई या पढ़ने के लिए अनुपयुक्त जगह, दिए गए वादे के बाहर हैं। भरोसेमंद आउटपुट खोजने के लिए ऐसी कॉल न चलाएँ।

इन सीमाओं में हर प्रीफ़िक्स का योग -54 से 54 तक और हर गिनती 0 से 6 तक रहती है। ये मान C द्वारा आवश्यक न्यूनतम int सीमा में भी समा जाते हैं। मान लें कि इन छोटी कॉल शृंखलाओं के लिए पर्याप्त निष्पादन संसाधन हैं। यह मनमाने इनपुट आकार या सामान्य रूप से सुरक्षित रिकर्शन गहराई का दावा नहीं है।

कोड से पहले लौटे मान का अर्थ तय करें

prefix_sum(a, n) को ठीक पहले n तत्वों का योग लौटाना है। खाली योग 0 है। धनात्मक n के लिए चुने हुए हिस्से को दो भागों में बाँटें:

• पहले n - 1 तत्व, जिनका काम अंदर वाली कॉल करेगी;
• बचा हुआ एक तत्व a[n - 1], जिसका काम मौजूदा कॉल करेगी।

इन दोनों भागों में कोई तत्व दोबारा नहीं आता और चुना हुआ कोई तत्व छूटता भी नहीं। इसलिए इस कॉल को child + last लौटाना है। उसे n नहीं जोड़ना, सारे तत्व फिर से नहीं जोड़ने और पहले बाहर छूटे तत्व a[n] को शामिल नहीं करना है।

अनुमान लगाएँ कि यह प्रोग्राम कौन-से दो पूर्णांक छापेगा।

#include <stdio.h>

int prefix_sum(const int a[], int n) {
    if (n == 0) {
        return 0;
    }
    int last = a[n - 1];
    int child = prefix_sum(a, n - 1);
    return child + last;
}

int main(void) {
    int values[4] = {4, -1, 7, 3};
    int used = 3;
    int answer = prefix_sum(values, used);
    printf("%d %d\n", answer, used);
    return 0;
}

आउटपुट 10 3 है। उत्तर 4 + (-1) + 7 = 10 है; ऐरे में मौजूद चौथा तत्व 3, माँगे गए प्रीफ़िक्स के बाहर है। main का चर used, 3 ही रहता है।

हल किया ट्रेस नीचे जाते समय पढ़ना और लौटते समय जोड़ना

हर कॉल की अपनी लंबाई और जिस परिणाम की वह प्रतीक्षा कर रही है, उसे लिखें। इस फ़ंक्शन में last को अंदर वाली कॉल से पहले पढ़ते हैं; जोड़ अंदर वाली कॉल के लौटने के बाद होता है।

पढ़े गए इंडेक्स का क्रम 2, 1, 0 है। आधार स्थिति से ऊपर लौटते प्रीफ़िक्स योग 0, 4, 3, 10 हैं। इन दोनों क्रमों को न मिलाएँ और घटती लंबाई को लौटता योग न समझें। प्रतीक्षा कर रही कॉल अपना पहले से भरा हुआ last और अपना n बनाए रखती है।

लंबाई 3 से शुरू करने पर helper की चार कॉल होती हैं, जिनमें खाली प्रीफ़िक्स वाली आधार कॉल भी शामिल है, और तीन तत्व पढ़े जाते हैं। ये कोड का ट्रेस बनाते समय की गिनतियाँ हैं; इनसे वास्तविक स्टैक के बाइट या कंपाइलर के अनुकूलन तय नहीं होते। ऊपर दिए पूरे प्रोग्राम में केवल main छापता है।

ऐरे वही रहता है और हर लंबाई की अलग प्रति मिलती है

फ़ंक्शन के पैरामीटर में const int a[] को C पॉइंटर पैरामीटर के रूप में समायोजित करता है। इन कॉलों में उसका मान caller के ऐरे के पहले तत्व को संदर्भित करता है। उस पॉइंटर मान की कॉपी दी जाती है और हर रिकर्सिव कॉल वही मान आगे देती है। इस घोषणा या रिकर्सिव कॉल से ऐरे के सभी तत्वों की प्रति नहीं बनती।

सामान्य int n का मान भी कॉपी होता है। अंदर वाली कॉल को उसकी अपनी लंबाई n - 1 मिलती है; इससे बाहर वाली कॉल का n या main का used नहीं बदलता। लंबाई 3 वाली बाहर की कॉल, अंदर की लंबाई 2 वाली कॉल के काम करते समय भी लंबाई 3 वाली ही रहती है। ऐरे के लिए ली गई जगह और उसमें रखे तत्व छोटे नहीं हो जाते।

यहाँ const इस पैरामीटर के रास्ते किसी तत्व में नया मान लिखने से रोकता है। यह ऐरे की निजी प्रति नहीं बनाता और मूल ऐरे को हर दूसरे रास्ते से बदलना असंभव नहीं करता। हमारी शर्त अलग से कहती है कि गणना के दौरान ऐरे के तत्व नहीं बदलेंगे; दिखाए गए helper केवल उन्हें पढ़ते हैं। लिखने की अनुमति वाला उपयुक्त पैरामीटर हो तो कोई दूसरा helper उसी साझा ऐरे के तत्व बदल सकता है। यह अभी हमारे दायरे के बाहर है।

पहला तत्व पढ़ना सुरक्षित क्यों है

लौटाई जाने वाली गणना से अलग सुरक्षा जाँचें:

1. n == 0 पर return 0, a[n - 1] तक पहुँचने से पहले चल जाता है। इंडेक्स -1 पढ़ने की कोशिश नहीं होती।
2. अन्यथा इनपुट की शर्त और असफल आधार जाँच से 1 <= n <= capacity मिलता है। इसलिए 0 <= n - 1 < capacity है। इस कॉल का पढ़ा इंडेक्स ऐरे के भीतर और चुने हुए प्रीफ़िक्स के भीतर है।
3. अंदर वाली कॉल को वही मौजूद ऐरे और 0 से capacity - 1 तक की लंबाई मिलती है। वह भी वही शर्तें पूरी करती है। उसका प्रीफ़िक्स ठीक एक तत्व छोटा है।
4. गैर-ऋणात्मक पूर्णांक लंबाई हर अंदर वाली कॉल पर 1 घटती है और 0 पर रुकती है। अंदर वाली कॉल लौटने के बाद एक छोटा जोड़ caller का ठीक वही वादा किया गया योग पूरा करता है।

ऐरे पढ़ने वाला कथन शून्य लंबाई की जाँच से पहले न ले जाएँ। ऐसा करने पर खाली प्रीफ़िक्स वाली कॉल लौटने से पहले इंडेक्स -1 पढ़ने की कोशिश करेगी। a[n - 1] की जगह a[n] न रखें। n == capacity पर उससे ऐरे के एक स्थान आगे पढ़ने की कोशिश होगी। n < capacity पर वह वास्तविक ऐरे के भीतर हो सकता है, पर चुने हुए प्रीफ़िक्स के बाहर है और काम का बँटवारा गलत करता है। इन दोषपूर्ण बदलावों को हम चलाए बिना समझते हैं।

पहले लौटने वाली जाँच केवल उन्हीं व्यंजकों से बचाती है जिन्हें वह चलने नहीं देती। caller वास्तविक क्षमता से बड़ी लंबाई दे तो यह जाँच उसे ठीक नहीं करती। इसी तरह कॉल शृंखला का 0 तक पहुँच जाना पर्याप्त नहीं है, अगर रास्ते में अवैध इंडेक्स पढ़ लिया गया हो।

उसी चार तत्वों वाले ऐरे की सीमा जाँच

values = {4, -1, 7, 3} के लिए:

लंबाई -1 और 5 इस ऐरे की शर्तों के बाहर हैं; इन्हें टेस्ट में चलाना नहीं है। ध्यान दें, लंबाई 0 का अर्थ मान 0 वाला तत्व नहीं है। इसका अर्थ कोई तत्व चुना ही नहीं गया है। लंबाई 1 के प्रीफ़िक्स में मान 0 हो, तब भी एक तत्व पढ़ा जाएगा और आधार स्थिति वाली अंदर की कॉल होगी।

हल किया ट्रेस उसी प्रीफ़िक्स के धनात्मक तत्व गिनना

अब count_positive(a, n) को पहले n स्थानों में धनात्मक तत्वों की संख्या लौटानी है। आधार गिनती 0 है। आखिरी तत्व धनात्मक हो तो वह 1 जोड़ता है; शून्य या ऋणात्मक हो तो 0 जोड़ता है। अंदर वाली कॉल अब भी ठीक पहले n - 1 स्थान सँभालती है।

#include <stdio.h>

int count_positive(const int a[], int n) {
    if (n == 0) {
        return 0;
    }
    int last = a[n - 1];
    int child = count_positive(a, n - 1);
    if (last > 0) {
        return child + 1;
    }
    return child;
}

int main(void) {
    int values[5] = {0, -2, 5, 0, 3};
    printf("%d\n", count_positive(values, 5));
    return 0;
}

प्रोग्राम 2 छापता है। पाँच तत्वों के प्रीफ़िक्स में धनात्मक मान 5 और 3 हैं। लौटे मान गिनतियाँ हैं, उन मानों के योग नहीं।

हर पंक्ति तय किए गए लौटे मान के अर्थ का पालन करती है। आखिरी तत्व धनात्मक न हो तो अंदर से मिली गिनती बिना बदले लौटाना सही है। प्रीफ़िक्स लंबा हुआ, पर गिनती नहीं बढ़ी। सुरक्षा का तर्क वही ऐरे, लंबाई और पढ़ने से पहले लौटने की शर्तें इस्तेमाल करता है जो prefix_sum में थीं।

एक सटीक उपमा

मान लें मेज़ पर नंबर लगे छह डिब्बे एक कतार में हैं। काम की एक पर्ची कहती है, “केवल पहले चार डिब्बे लें।” छोटी पर्ची कहती है, “केवल पहले तीन लें।” डिब्बे उसी मेज़ पर रहते हैं; नई पर्ची किसी डिब्बे को हटाती या उसकी प्रति नहीं बनाती। प्रतीक्षा करती हर पर्ची अपनी माँगी गई संख्या और पहले पढ़ा हुआ एक मान सुरक्षित रखती है। किसी भी डिब्बे की माँग न करने वाली पर्ची, कोई डिब्बा खोले बिना 0 वापस भेज देती है।

यह उपमा ऐरे की साझा जगह, अलग-अलग कॉपी हुई लंबाइयों और खाली प्रीफ़िक्स को समझाती है। यह वास्तविक स्टैक का विन्यास, एक साथ काम करते लोग या लंबाई अपने आप लागू करने वाली रोक नहीं बताती।

याद रखने की पेटी जगह लंबाई और परिणाम अलग रखें

• जगह: मूल मौजूद ऐरे; इन कॉलों के दौरान उसकी क्षमता नहीं घटती।
• लंबाई: इस कॉल का कॉपी हुआ n; धनात्मक होने पर यह 0 से n - 1 तक के इंडेक्स चुनता है।
• खाली प्रीफ़िक्स: लंबाई 0; कोई भी तत्व पढ़ने से पहले लौटें।
• अंदर वाली कॉल का काम: उसी ऐरे के पहले n - 1 तत्व।
• लौटे मान का अर्थ: इस प्रीफ़िक्स का ठीक योग या गिनती; वह ज़रूरी नहीं कि लंबाई या आखिरी मान के बराबर हो।
• सुरक्षा: पढ़ा गया इंडेक्स वैध हो और अंदर वाली कॉल भी शर्तें पूरी करे। केवल समापन पर्याप्त नहीं है।
• const इस पैरामीटर से केवल पढ़ने का समर्थन करता है; ऐरे की प्रति नहीं बनाता।

छह मौलिक अभ्यास प्रश्न

हर प्रश्न में चार में से ठीक एक विकल्प चुनें। ये सामान्य अभ्यास के मौलिक प्रश्न हैं, आधिकारिक पिछले वर्षों के प्रश्न या पूरा परीक्षा मॉक नहीं। जहाँ helper का नाम दिया है, ऊपर की ठीक वही परिभाषा इस्तेमाल करें और हर जगह तय सीमित शर्तें मानें। प्रश्न 6 एक अलग पूरा C11 प्रोग्राम देता है। उसमें void फ़ंक्शन कोई मान नहीं लौटाता और return; केवल उसकी कॉल समाप्त करता है।

प्रश्न 1

पहले हल किए उदाहरण की prefix_sum परिभाषा बिना बदले इस्तेमाल करें। int values[4] = {4, -1, 7, 3} के लिए prefix_sum(values, 3) क्या लौटाता है?

A. 13 B. 3 C. 10 D. 9

प्रश्न 2

उसी prefix_sum का उपयोग करें। int box[1] = {8} दिया है। prefix_sum(box, 0) के बारे में कौन-सा कथन सही है?

A. यह 0 लौटाता है, ऐरे का कोई तत्व नहीं पढ़ता और कोई अंदर वाली रिकर्सिव कॉल नहीं करता। B. यह box[0] पढ़ने के बाद 0 लौटाता है। C. यह 8 लौटाता है क्योंकि ऐरे में एक तत्व है। D. यह 0 लौटाने से पहले n = -1 वाली अंदर की कॉल करता है।

प्रश्न 3

पहले पूरे प्रोग्राम में main, used = 3 रखकर prefix_sum(values, used) बुलाता है। लंबाई के आर्ग्युमेंट और ऐरे की जगह के बारे में कौन-सा कथन सही है?

A. सभी कॉल एक ही n ऑब्जेक्ट साझा करती हैं, इसलिए used का मान 0 हो जाता है। B. हर अंदर वाली कॉल को प्रीफ़िक्स के तत्वों की प्रतियों वाला एक नया छोटा ऐरे मिलता है। C. const हर कॉल के लिए ऐरे की निजी प्रति बनाता है और मूल ऐरे को हर दूसरे रास्ते से भी बदलने से रोक देता है। D. हर कॉल के पास n की अपनी प्रति होती है; ये सभी कॉल ऐरे की उसी जगह को संदर्भित करती हैं। used का मान 3 रहता है और तत्व नहीं बदलते।

प्रश्न 4

capacity ऐरे में मौजूद तत्वों की वास्तविक संख्या है और केवल 0 <= n <= capacity स्वीकार है। कौन-सा तर्क हर अनुमत n के लिए prefix_sum में सुरक्षित इंडेक्स इस्तेमाल होना स्थापित करता है?

A. a[n] हमेशा आखिरी वैध तत्व है क्योंकि n लंबाई है। B. n == 0 पर किसी भी तत्व को पढ़ने से पहले return हो जाता है। अन्यथा 0 <= n - 1 < capacity है, और अंदर वाली कॉल उसी ऐरे का छोटा वैध प्रीफ़िक्स लेती है। C. पैरामीटर में a[] लिखने से C हर एक्सेस से पहले लंबाई अपने आप जाँचता है। D. ऋणात्मक n भी सुरक्षित हैं क्योंकि बार-बार 1 घटाने पर कभी न कभी 0 आ ही जाएगा।

प्रश्न 5

दूसरे हल किए उदाहरण की count_positive परिभाषा बिना बदले इस्तेमाल करें। int values[5] = {2, 0, -3, 4, -1} के लिए count_positive(values, 4) क्या लौटाता है?

A. 3 B. 2 C. 4 D. 6

प्रश्न 6

यह प्रोग्राम पूर्णांकों का कौन-सा क्रम छापता है? अंत का स्पेस और नई पंक्ति न गिनें। ऐरे और लंबाई की वही शर्तें लागू हैं। void फ़ंक्शन कोई मान नहीं लौटाता; return; केवल उस कॉल को समाप्त करता है।

#include <stdio.h>

void show_prefix(const int a[], int n) {
    if (n == 0) {
        return;
    }
    show_prefix(a, n - 1);
    printf("%d ", a[n - 1]);
}

int main(void) {
    int values[4] = {4, 2, 5, 9};
    show_prefix(values, 3);
    printf("\n");
    return 0;
}

A. 5 2 4 B. 4 2 5 9 C. 0 1 2 D. 4 2 5

उत्तर और हर विकल्प की वजह

उत्तर 1: C

A गलत है। 13 में ऐरे के चारों तत्व जुड़ गए हैं। लंबाई 3 होने पर values[3] का मान 3 चुने हुए हिस्से में शामिल नहीं होता।

B गलत है। 3 दी गई लंबाई है, चुने हुए तत्वों का योग नहीं।

C सही है। चुने हुए इंडेक्स 0, 1 और 2 हैं, इसलिए 4 + (-1) + 7 = 10 लौटता है।

D गलत है। 9 पाने के लिए 4 + (-1) + 7 में फिर से 1 घटा दिया गया है; ऋणात्मक तत्व दो बार गिना गया। हर चुना हुआ तत्व केवल एक बार जुड़ता है।

उत्तर 2: A

A सही है। पहली शर्त सत्य है, इसलिए return 0 इस कॉल को ऐरे पढ़ने और रिकर्सिव कॉल करने से पहले ही समाप्त कर देता है।

B गलत है। पढ़ने वाला कथन उस return के बाद है जो चल चुका है। इसलिए box[0] सहित कोई भी तत्व नहीं पढ़ा जाता।

C गलत है। ऐरे के लिए जगह मौजूद होने पर भी चुने हुए शुरुआती हिस्से की लंबाई 0 है। उसका योग 0 है।

D गलत है। आधार स्थिति, कहीं भी n - 1 भेजने से पहले लौट जाती है। कॉल की शृंखला 0 पर समाप्त होती है।

उत्तर 3: D

A गलत है। सामान्य int आर्ग्युमेंट का मान कॉपी करके दिया जाता है। अंदर वाली कॉल को 0 मिलने से प्रतीक्षा कर रहे caller का n या main का used नहीं बदलता।

B गलत है। इस पैरामीटर घोषणा से ऐरे के तत्व कॉपी नहीं होते। केवल चुने हुए शुरुआती हिस्से की लंबाई छोटी होती है।

C गलत है। const int a[] इस पैरामीटर के रास्ते तत्वों में मान लिखने से रोकता है। यह ऐरे की प्रति नहीं बनाता और मूल ऐरे को हर दूसरे रास्ते से स्थायी रूप से अपरिवर्तनीय नहीं बनाता।

D सही है। पहले तत्व को संदर्भित करने वाला पॉइंटर मान और n, दोनों कॉपी होते हैं। जिस ऐरे को पढ़ा जा रहा है वह वही रहता है, और यह helper उसे केवल पढ़ता है।

उत्तर 4: B

A गलत है। प्रीफ़िक्स के इंडेक्स n - 1 पर खत्म होते हैं। n == capacity पर a[n] ऐरे के एक स्थान आगे होगा और उसे पढ़ना वैध नहीं है। छोटे n पर भी वह चुने हुए प्रीफ़िक्स से बाहर है।

B सही है। धनात्मक अनुमत n से आखिरी वैध इंडेक्स मिलता है और n - 1, 0 तथा capacity की सीमा में रहता है। आधार स्थिति को किसी तत्व की ज़रूरत नहीं है। यही तर्क हर अंदर वाली कॉल पर फिर लागू होता है।

C गलत है। इस ऐरे पैरामीटर में लंबाई की स्वचालित जाँच नहीं होती। caller को इनपुट की शर्त पूरी करनी है और कोड को उसकी सीमा में काम करना है।

D गलत है। ऋणात्मक लंबाइयाँ तय दायरे के बाहर हैं। 1 घटाने से ऋणात्मक पूर्णांक 0 से और दूर जाता है, और उससे पहले होने वाला ऐरे एक्सेस भी उचित नहीं है। ऐसी कॉल न चलाएँ।

उत्तर 5: B

A गलत है। 3 में दो धनात्मक तत्वों के साथ शून्य भी गिन लिया गया है। जाँच last > 0 है, इसलिए शून्य गिनती नहीं बढ़ाता।

B सही है। चुना हुआ प्रीफ़िक्स {2, 0, -3, 4} है; केवल 2 और 4 धनात्मक हैं। n = 0 से 4 तक लौटती गिनतियाँ 0, 1, 1, 1, 2 हैं।

C गलत है। 4 चुने हुए हिस्से की लंबाई है, धनात्मक तत्वों की संख्या नहीं।

D गलत है। 6 धनात्मक मानों 2 और 4 का योग है। यह फ़ंक्शन धनात्मक तत्व मिलने पर 1 जोड़ता है, उस तत्व का मान नहीं।

उत्तर 6: D

A गलत है। यह तत्वों का उलटा क्रम है। यहाँ printf अंदर वाली कॉल के बाद चलता है, इसलिए सबसे छोटा गैर-खाली प्रीफ़िक्स पहले छपता है।

B गलत है। लंबाई 3 होने पर ऐरे में मौजूद चौथा तत्व 9 शामिल नहीं है।

C गलत है। ये चुने हुए इंडेक्स हैं। printf को तत्व a[n - 1] मिलता है, इंडेक्स n - 1 नहीं।

D सही है। n = 0 वाली कॉल कुछ नहीं छापती। लौटते समय n = 1, 2 और 3 वाली कॉल क्रम से a[0] = 4, a[1] = 2 और a[2] = 5 छापती हैं।

आगे बढ़ने से पहले

अतिरिक्त तत्व जोड़ दिया हो तो ट्रेस से पहले प्रीफ़िक्स के वैध इंडेक्स लिखें। बाहर वाली कॉल की लंबाई 0 कर दी हो तो एक बिना बदले ऐरे के बगल में हर कॉल का अलग n बनाएँ। तत्वों की गिनती की जगह उनके मान जोड़ दिए हों तो हर पंक्ति के ऊपर लौटे परिणाम का तय अर्थ लिखें। खाली कॉल ने तत्व पढ़ने की कोशिश की हो तो जाँचें कि आधार स्थिति की शर्त से पहले क्या चल सकता है।

नए helper के लिए पहले ऐरे की जगह और लंबाई की शर्तें, खाली प्रीफ़िक्स का परिणाम, अंदर वाली कॉल का ठीक काम और caller के लिए बचा एक तत्व तय करें। पहले खाली, एक तत्व वाले और पूरे प्रीफ़िक्स जाँचें; फिर धनात्मक, शून्य और ऋणात्मक मानों के मिश्रण जाँचें। उत्तर सही दिखने से अवैध इंडेक्स पढ़ना सही नहीं हो जाता।

यह GATE CS की तैयारी का एक शुरुआती चरण है। इससे पूरा C, डेटा स्ट्रक्चर या रिकर्शन पूरा नहीं हो जाता। शाखाओं वाला रिकर्शन तथा recurrence या संसाधनों का औपचारिक विश्लेषण आगे के पाठों में करना होगा।

स्रोत और दायरे की जानकारी

पहले समीक्षा किए गए पाठों ने 13 अक्टूबर 2026 को आधिकारिक GATE 2027 CS पाठ्यक्रम जाँचा था और Programming and Data Structures में रिकर्शन की प्रासंगिकता दर्ज की थी। यह ऑफलाइन अगला पाठ उसी पाठ्यक्रम संदर्भ का उपयोग करता है; नई लाइव जाँच का दावा नहीं करता। यहाँ की व्याख्याएँ, प्रोग्राम और छह प्रश्न मौलिक शिक्षण सामग्री हैं। C11 शिक्षण के लिए चुना गया है, आधिकारिक परीक्षा का भाषा-संस्करण बताने के लिए नहीं। किसी आधिकारिक पिछले वर्ष के प्रश्न को दोहराया या ऐसा होने का दावा नहीं किया गया है।