C बुनियाद पुनराभ्यास

पाठ 6 / 1317 मिनटPDF नोट्समुफ़्त

हर प्रोग्राम का ट्रेस उसके वर्तमान पूर्णांक मानों से करें। कॉल में caller के चरों को helper के पैरामीटर और स्थानीय चरों से अलग रखें। लूप में अंत में गलत होने वाली जाँच भी लिखें। उत्तर के साथ अवस्था का छोटा ट्रेस बनाएँ, ताकि बाद में तर्क जाँच सकें।

यह पाँच C बुनियादी पाठों का निःशुल्क, बिना समय-सीमा वाला पुनराभ्यास है। इसमें 12 प्रश्न हैं; प्रत्येक 1 अंक का है, कुल 12 अंक। सही उत्तर पर +1 और गलत या छोड़े गए उत्तर पर 0 मिलता है। न ऋणात्मक अंक हैं, न आंशिक अंक, न उत्तीर्ण होने की कोई सीमा। यह इसी सीमित C बुनियाद का अभ्यास है, पूरा GATE CS पाठ्यक्रम या पूर्ण GATE प्रश्नपत्र नहीं।

MCQ: ठीक एक विकल्प चुनें।
MSQ: सभी सही विकल्प चुनें। चुना गया समुच्चय उत्तर से पूरी तरह मिलना चाहिए; कोई सही विकल्प छूटने या अतिरिक्त गलत विकल्प चुनने पर 0 मिलेगा। विकल्प चुनने का क्रम मायने नहीं रखता।
NAT: माँगा गया पूर्णांक लिखें। इन तीन प्रश्नों के उत्तर सटीक पूर्णांक हैं।
प्रश्न आज़माने के बाद हल देखें। संबंधित अवस्था-ट्रेस फिर पढ़ें और बिना टाइमर दोबारा प्रयास करें; अंक सीखने की प्रतिक्रिया हैं, चयन या योग्यता की भविष्यवाणी नहीं।

सभी प्रश्नों में C11 उपयोग करें। हर दिखाया code block पूरा और स्वतंत्र प्रोग्राम है: उसके अपने शुरुआती मानों से फिर शुरू करें। यहाँ गणना के सभी मान पोर्टेबल signed int सीमा -32767 से 32767 में आते हैं। हर मूल्यांकित भाग में भाजक गैर-शून्य है और भागफल निरूपित हो सकता है। कॉल से पहले प्रकार सहित फ़ंक्शन-परिभाषा दी गई है और हर पहुँचने वाले रास्ते पर helper पूर्णांक लौटाता है। int की कोई खास बिट-चौड़ाई नहीं मानी गई है। %d से छपने वाले मान पूर्णांक हैं और \n आउटपुट पंक्ति समाप्त करता है।

प्रश्न

प्रश्न 1 · MCQ · 1 अंक

कौन-सी जोड़ी छपती है? ठीक एक विकल्प चुनिए।

#include <stdio.h>

int main(void) {
    int a=5,b=8;
    a=b-a;
    b=b+a;
    printf("%d %d\n",a,b);
    return 0;
}

A. 3 11
B. 3 8
C. 5 13
D. 3 3

प्रश्न 2 · NAT · 1 अंक

छपने वाला पूर्णांक लिखिए।

#include <stdio.h>

int main(void) {
    int total=58,group=9;
    int leftover=total-group*(total/group);
    printf("%d\n",leftover);
    return 0;
}

प्रश्न 3 · MCQ · 1 अंक

n, left, right के क्रम में कौन-से तीन मान छपते हैं? ठीक एक विकल्प चुनिए।

#include <stdio.h>

int main(void) {
    int n=2;
    int left=n++;
    int right=++n;
    printf("%d %d %d\n",n,left,right);
    return 0;
}

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

प्रश्न 4 · MSQ · 1 अंक

int p=-17 और q=5 पर सभी सही कथन चुनिए।

#include <stdio.h>

int main(void) {
    int p=-17,q=5;
    printf("%d %d %d\n",p/q,p%q,(p/q)*q+p%q);
    return 0;
}

A. p/q का मान -3 है
B. p%q का मान 3 है
C. (p/q)*q+p%q का मान p है
D. p/q का मान -4 है

प्रश्न 5 · MCQ · 1 अंक

tag का कौन-सा मान छपता है? ठीक एक विकल्प चुनिए।

#include <stdio.h>

int main(void) {
    int c=7,tag=0;
    if(c<5){tag=1;}else if(c%2==1){tag=2;}else{tag=3;}
    printf("%d\n",tag);
    return 0;
}

A. 1
B. 2
C. 3
D. 0

प्रश्न 6 · MSQ · 1 अंक

int a=0 और b=6 पर किन व्यंजकों का मान 1 है? सभी सही विकल्प चुनिए।

#include <stdio.h>

int main(void) {
    int a=0,b=6;
    printf("%d %d %d %d\n",!a,a||(b>4),a&&(b>0),!(b==6));
    return 0;
}

A. !a
B. a || (b > 4)
C. a && (b > 0)
D. !(b == 6)

प्रश्न 7 · NAT · 1 अंक

body के चलने की संख्या लिखिए।

#include <stdio.h>

int main(void) {
    int count=0;
    for(int k=3;k<=12;k+=3){count++;}
    printf("%d\n",count);
    return 0;
}

प्रश्न 8 · MCQ · 1 अंक

कौन-सा पूर्णांक छपता है? हर भाग और शेषफल का ट्रेस कीजिए। ठीक एक विकल्प चुनिए।

#include <stdio.h>

int main(void) {
    int n=19,sum=0;
    while(n>0){sum+=n%3;n/=3;}
    printf("%d\n",sum);
    return 0;
}

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

प्रश्न 9 · MSQ · 1 अंक

इस for लूप के सभी सही कथन चुनिए। अंतिम असफल जाँच भी गिनिए।

#include <stdio.h>

int main(void) {
    int sum=0,i;
    for(i=0;i<4;i++){sum+=2*i;}
    printf("%d %d\n",sum,i);
    return 0;
}

A. body 4 बार चलती है
B. शर्त 4 बार जाँची जाती है
C. अंतिम sum 12 है
D. अपडेट i++ 4 बार चलता है

प्रश्न 10 · MCQ · 1 अंक

कौन-सी जोड़ी छपती है? ठीक एक विकल्प चुनिए।

#include <stdio.h>

int bump(int x){x+=3;return x;}

int main(void) {
    int v=4;
    int result=bump(v);
    printf("%d %d\n",v,result);
    return 0;
}

A. 7 7
B. 4 7
C. 4 4
D. 7 4

प्रश्न 11 · NAT · 1 अंक

अंत में छपने वाला पूर्णांक लिखिए।

#include <stdio.h>

int accumulate(int n){int s=1;for(int k=1;k<=n;k++){s+=2*k;}return s;}

int main(void) {
    int r=accumulate(3);
    int t=accumulate(1);
    printf("%d\n",r-t);
    return 0;
}

प्रश्न 12 · MSQ · 1 अंक

केवल -3 से 3 तक के input लें। choose के सभी सही कथन चुनिए।

#include <stdio.h>

int choose(int n){if(n<0){return -n;}return n+1;}

int main(void) {
    int a=choose(-3);
    int b=choose(0);
    int c=choose(2);
    int value=-2;
    int result=choose(value);
    printf("%d %d %d %d %d\n",a,b,c,value,result);
    return 0;
}

A. choose(-3) का लौटाया मान 3 है
B. choose(0) का लौटाया मान 0 है
C. choose(2) का लौटाया मान 3 है
D. choose(value) की कॉल caller के int चर value को नहीं बदलती

उत्तर और पूरे हल

नीचे दिए तर्क से केवल अंतिम संख्याएँ नहीं, अवस्थाएँ भी मिलाएँ।

प्रश्न 1

उत्तर: A

शुरू में a = 5, b = 8 हैं।
a = b - a वर्तमान 8 और 5 पढ़कर 3 निकालता है और उसे a में रखता है। अवस्था: a = 3, b = 8।
b = b + a अब 8 और अपडेट हुआ 3 पढ़ता है, इसलिए b = 11।
आउटपुट क्रम a, b है, इसलिए 3 11 छपता है।

विकल्पों की जाँच

A: सही। दोनों असाइनमेंट क्रम से लागू किए गए हैं।
B: गलत। 3 8 पहली असाइनमेंट के बाद रुक जाता है और b का अपडेट छोड़ता है।
C: गलत। 5 13 पुराने a = 5 को बनाए रखता है और दूसरी असाइनमेंट में उपयोग करता है, जबकि a पहले ही 3 हो चुका है।
D: गलत। b = b + a में 8 और 3 जुड़ते हैं; यह a को b में कॉपी नहीं करता।

प्रश्न 2

उत्तर: 4

total / group के दोनों operands पूर्णांक हैं: 58 / 9 से 6 पूरे समूह मिलते हैं।
समूह के आकार को भागफल से गुणा करें: 9 * 6 = 54।
कुल में से समूहों में लगी संख्या घटाएँ: 58 - 54 = 4।
अतः leftover = 4 और उत्तर पूर्णांक 4 है। जाँच: 6 * 9 + 4 = 58, जहाँ 0 <= 4 और 4 < 9 दोनों सही हैं।

6 भागफल है, बची मात्रा नहीं। 54 पूरे समूहों में रखी संख्या है। 0 तब आएगा जब भाग को वास्तविक संख्याओं वाला सटीक भागफल माना जाए; C का पूर्णांक भाग गुणा से पहले ही भिन्न भाग हटा चुका है।

प्रश्न 3

उत्तर: C

शुरू में n = 2 है।
left = n++ में व्यंजक का मान पुराना 2 है, इसलिए left = 2; इस कथन के अंत तक n = 3 हो जाता है।
right = ++n पहले n को 3 से 4 करता है, फिर 4 देता है, इसलिए right = 4।
printf से पहले दोनों अलग कथन पूरे हो चुके हैं। माँगे गए n, left, right क्रम में 4 2 4 छपता है।

विकल्पों की जाँच

A: गलत। left = 3 मानने पर postfix n++ को बढ़ा हुआ मान देने वाला समझ लिया गया है।
B: गलत। दो बढ़ोतरी वास्तव में चलती हैं, इसलिए n का अंतिम मान 3 नहीं है; right को 4 मिलता है।
C: सही। रखे गए मान 2 और 4 हैं, जबकि अंतिम n का मान 4 है।
D: गलत। right = 3 मानने पर prefix ++n को पुराना मान देने वाला समझ लिया गया है।

प्रश्न 4

उत्तर: A, C

गणितीय भागफल -3.4 है। C11 का पूर्णांक भाग भिन्न भाग हटाकर शून्य की ओर जाता है, इसलिए p / q = -3।
पुनर्निर्माण पहचान उपयोग करें: -17 = (-3) * 5 + r, इसलिए r = -2। अतः p % q = -2।
C के दोनों परिणाम रखने पर (p / q) * q + p % q = (-3) * 5 + (-2) = -17, जो p के बराबर है।
इसलिए चुना गया समुच्चय ठीक A और C होना चाहिए।

विकल्पों की जाँच

A: सही। -3.4 को शून्य की ओर काटने पर -3 मिलता है।
B: गलत। धनात्मक शेषफल 3 भागफल -4 के साथ मेल खाता है, पर यहाँ C11 का भागफल -4 नहीं है। C का शेषफल -2 है।
C: सही। भाजक शून्य नहीं है और भागफल निरूपित हो सकता है, इसलिए दी गई पहचान लागू होती है और -17 मिलता है।
D: गलत। -4 ऋणात्मक अनंत की ओर नीचे का मान है; C11 का पूर्णांक भाग शून्य की ओर जाता है।

प्रश्न 5

उत्तर: B

शुरू में c = 7, tag = 0 हैं।
पहली शर्त c < 5 गलत है, इसलिए tag = 1 छोड़ दिया जाता है।
फिर c % 2 का मान 1 है, इसलिए c % 2 == 1 सही है। tag = 2 चलता है।
पिछली शाखा चुनी जा चुकी है, इसलिए अंतिम else छोड़ दिया जाता है। आउटपुट 2 है।

विकल्पों की जाँच

A: गलत। 1 का असाइनमेंट उस शाखा में है जिसकी शर्त गलत है।
B: सही। विषम संख्या वाली शर्त की शाखा चुनी जाती है।
C: गलत। सही else if शाखा के बाद अंतिम else नहीं चलता।
D: गलत। चलने वाला tag = 2 असाइनमेंट शुरुआती 0 को बदल देता है।

प्रश्न 6

उत्तर: A, B

a का मान 0 है, इसलिए तार्किक जाँच में वह गलत है। b का मान 6 है।
!a अर्थात !0 का मान 1 है।
a || (b > 4) में बायाँ operand गलत है, इसलिए दायाँ operand जाँचा जाता है। 6 > 4 सही है और तार्किक OR का मान 1 है।
a && (b > 0) में बायाँ operand गलत है, इसलिए दायाँ operand छोड़ दिया जाता है और तार्किक AND का मान 0 है।
!(b == 6) में समानता सही है और उसका मान 1 है; उसे नकारने पर 0 मिलता है। केवल A और B का मान 1 है।

विकल्पों की जाँच

A: सही। तार्किक निषेध शून्य को 1 में बदलता है।
B: सही। कम से कम एक operand सही है, इसलिए || का मान 1 है, गैर-शून्य चर का मान 6 नहीं।
C: गलत। बायाँ operand गलत होने पर && दाएँ operand को जाँचे बिना 0 देता है।
D: गलत। समानता b == 6 सही है, इसलिए उसका निषेध 0 है।

प्रश्न 7

उत्तर: 4

आरंभीकरण से count = 0 और लूप का k = 3 होता है।
k = 3 पर शर्त सही है: count 1 होता है; अपडेट से k = 6।
k = 6 पर शर्त सही है: count 2 होता है; अपडेट से k = 9।
k = 9 पर शर्त सही है: count 3 होता है; अपडेट से k = 12।
k = 12 पर भी शर्त सही है क्योंकि अंतिम सीमा शामिल है: count 4 होता है; अपडेट से k = 15।
k = 15 पर शर्त गलत है। चार body और चार अपडेट हुए, पर शर्त पाँच बार जाँची गई। माँगी गई body की संख्या 4 है।

3 में शामिल अंतिम मान 12 छोड़ दिया गया है। 5 में अंतिम असफल शर्त को भी body चलने जैसा गिना गया है। 10 में 3-3 की दूरी वाले वास्तविक मानों के बजाय 3 से 12 तक हर पूर्णांक गिना गया है।

प्रश्न 8

उत्तर: D

शुरू में n = 19, sum = 0; 19 > 0 सही है।
पहली body: 19 % 3 = 1, इसलिए sum = 1; फिर n /= 3 से 19 / 3 = 6 रखा जाता है।
दूसरी जाँच 6 > 0 सही है। 6 % 3 = 0, इसलिए sum 1 रहता है; पूर्णांक भाग से n = 2।
तीसरी जाँच 2 > 0 सही है। 2 % 3 = 2, इसलिए sum = 3; पूर्णांक भाग से n = 0।
0 > 0 गलत है, इसलिए लूप समाप्त होता है। तीन body और चार जाँच हुईं; छपने वाली मात्रा शेषफलों का योग 3 है।

विकल्पों की जाँच

A: गलत। 4 शर्त की जाँचों की संख्या है, शेषफलों का योग नहीं। अंतिम असफल जाँच कुछ नहीं जोड़ती।
B: गलत। 6 पहली बार अपडेट हुए n का मान है, sum से छपने वाला अंतिम मान नहीं।
C: गलत। शुरुआती 19 को sum में नहीं जोड़ा जाता; हर body में केवल n % 3 जुड़ता है।
D: सही। जुड़े शेषफल 1, 0 और 2 हैं, जिनका योग 3 है।

प्रश्न 9

उत्तर: A, C, D

sum = 0 से शुरू करें, फिर i = 0 आरंभ होता है।
i = 0 पर शर्त 0 < 4 सही है। 2 * 0 = 0 जोड़ने पर sum = 0 रहता है; अपडेट से i = 1।
i = 1 पर शर्त 1 < 4 सही है। 2 जोड़ने पर sum = 2; अपडेट से i = 2।
i = 2 पर शर्त 2 < 4 सही है। 4 जोड़ने पर sum = 6; अपडेट से i = 3।
i = 3 पर शर्त 3 < 4 सही है। 6 जोड़ने पर sum = 12; अपडेट से i = 4।
i = 4 पर शर्त 4 < 4 गलत है। न पाँचवीं body चलती है, न पाँचवाँ अपडेट। body की संख्या 4, अपडेट की संख्या 4 और जाँच की संख्या 5 है। आउटपुट 12 4 है; सही कथन A, C और D हैं।

विकल्पों की जाँच

A: सही। body i = 0, 1, 2, 3 पर चलती है।
B: गलत। चार सफल जाँच और एक अंतिम गलत जाँच मिलकर पाँच होती हैं।
C: सही। जमा योग 0 + 2 + 4 + 6 = 12 है।
D: सही। हर पूरी हुई body के बाद अपडेट चलता है; 3 से 4 करने वाला अपडेट भी इन चार में शामिल है।

प्रश्न 10

उत्तर: B

caller में v = 4 है। bump(v) का आर्ग्युमेंट व्यंजक 4 देता है।
helper का अलग पैरामीटर x = 4 से शुरू होता है। x += 3 से helper का x = 7 होता है।
return x helper समाप्त करके 7 लौटाता है। caller इसे result में रखता है।
caller के v को कोई नया मान असाइन नहीं हुआ; वह 4 रहता है। आउटपुट क्रम v, result है, इसलिए जोड़ी 4 7 है।

विकल्पों की जाँच

A: गलत। 7 7 मानता है कि helper के पैरामीटर का अपडेट caller के v को बदल देता है।
B: सही। आर्ग्युमेंट की कॉपी मिलती है और लौटा 7 result में रखा जाता है।
C: गलत। 4 4 caller का मान सही रखता है, लेकिन return से पहले helper का जोड़ छोड़ देता है।
D: गलत। इसमें असाइनमेंट के बिना caller का v बदल दिया गया है और पुराने मान को लौटे परिणाम के रूप में रखा गया है।

प्रश्न 11

उत्तर: 10

पहली कॉल: पैरामीटर n = 3; initializer के अनुसार स्थानीय s का शुरुआती मान 1 है।
k = 1, 2, 3 पर 2, 4, 6 जोड़ें। s के क्रमिक मान 3, 7, 13 हैं। k = 4 पर शर्त गलत है, इसलिए 13 लौटता है और r = 13 रखा जाता है।
दूसरी कॉल: पैरामीटर n = 1; इस कॉल का नया स्थानीय s फिर 1 से शुरू होता है।
k = 1 पर 2 जोड़ने से s = 3। अपडेट से k = 2; शर्त गलत है। 3 लौटता है और t = 3 रखा जाता है।
caller में r - t = 13 - 3 = 10 छपता है। उत्तर पूर्णांक 10 है।

13 पहली कॉल के बाद रुककर छपने वाले घटाव को छोड़ देता है। -2 तब आएगा जब दूसरी बार s को गलत ढंग से 13 से आगे बढ़ाकर 15 निकाला जाए और उसे 13 से घटाया जाए। 12 में दूसरी कॉल के लौटे 3 के बजाय उसका शुरुआती 1 घटाया गया है। केवल संख्या लिखना यह नहीं दिखाता कि दोनों स्थानीय आरंभीकरण का ट्रेस किया गया है।

प्रश्न 12

उत्तर: A, C, D

दिए गए -3 से 3 तक हर पूर्णांक के लिए n < 0 जाँचें। ऋणात्मक input पर return -n चलता है; शून्य और धनात्मक input पर return n + 1। ऋणात्मक शाखा का return कॉल समाप्त करता है, इसलिए बाद का return भी साथ नहीं चलता।
choose(-3) ऋणात्मक शाखा लेकर 3 लौटाता है।
choose(0) में ऋणात्मक होने की शर्त गलत है और 0 + 1 = 1 लौटता है।
choose(2) भी अंतिम return तक पहुँचता है और 2 + 1 = 3 देता है।
caller में value = -2 होने पर helper के अलग पैरामीटर को -2 मिलता है और वह 2 लौटाता है। caller का value -2 रहता है; result 2 होता है। इसलिए दिखाया गया प्रोग्राम 3 1 3 -2 2 छापता है।
सही कथन ठीक A, C और D हैं। बताए गए inputs -3, -2, -1, 0, 1, 2, 3 पर क्रमशः outputs 3, 2, 1, 1, 2, 3, 4 हैं; पूरी अंकगणित दिए गए छोटे पूर्णांकों की सीमा में है।

विकल्पों की जाँच

A: सही। -3 पर n < 0 सही है और -n का मान 3 है।
B: गलत। शून्य ऋणात्मक नहीं है; वह return n + 1 तक पहुँचकर 1 लौटाता है।
C: सही। धनात्मक 2 गैर-ऋणात्मक रास्ते से 3 लौटाता है।
D: सही। helper को आर्ग्युमेंट का पूर्णांक मान मिलता है; गणना लौटाने से caller के value में असाइनमेंट नहीं होता। बताई गई पूरी input सीमा में यह सही है।

किस बात का फिर अभ्यास करें

प्रश्न 1–प्रश्न 2: वर्तमान अवस्था और पूर्णांक अंकगणित। प्रश्न 3–प्रश्न 4: व्यंजक के मान और signed भाग। प्रश्न 5–प्रश्न 6: चुनी गई शाखाएँ और तार्किक जाँच। प्रश्न 7–प्रश्न 9: लूप की सटीक अवस्थाएँ और गिनती। प्रश्न 10–प्रश्न 12: पैरामीटर, स्थानीय आरंभीकरण और return। गलत प्रश्न में वह पहली अवस्था सुधारें जहाँ आपका ट्रेस अलग हुआ, फिर वहाँ से आगे दोबारा चलें।

स्रोत टिप्पणी

C11 के अर्थ-नियमों का संदर्भ WG14 का N1570 समिति मसौदा है। असाइनमेंट, अंकगणित, तार्किक ऑपरेटर, लूप और फ़ंक्शन के लिए §§6.5, 6.8.4–6.8.6 और 6.9.1 देखें।

उदाहरण से समझें

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

सूत्र और नियम

12 प्रश्न, 12 अंक; निःशुल्क और बिना समय-सीमा; सही पर +1, गलत या खाली पर 0।
MCQ: एक विकल्प। MSQ: ठीक पूरा सही समुच्चय, कोई आंशिक अंक नहीं। NAT: सटीक पूर्णांक।
न ऋणात्मक अंक, न उत्तीर्ण सीमा। आगे किस बात का अभ्यास करना है, यह हल से पहचानें।
हर प्रोग्राम उसके अपने शुरुआती मानों से शुरू करें; पिछले प्रश्न उसकी अवस्था नहीं बदलते।
असाइनमेंट वर्तमान अवस्था उपयोग करता है। अलग बढ़ोतरी वाले कथन अगले कथन से पहले पूरे होते हैं।
C11 का signed पूर्णांक भाग शून्य की ओर कटता है; शेषफल से भाज्य का पुनर्निर्माण होता है।
&& और || short-circuit करते हैं। तार्किक परिणाम 0 या 1 होते हैं।
सफल body, शर्त की जाँच और अपडेट अलग-अलग गिनें।
पूर्णांक पैरामीटर caller के चर से अलग है। दिखाया हर स्थानीय initializer अपनी कॉल में फिर चलता है।
printf के आर्ग्युमेंट बताए आउटपुट क्रम में पढ़ें; इस क्रम को मूल्यांकन के सामान्य क्रम की गारंटी न समझें।

इस पाठ के नोट्स

GATE CS C बुनियाद पुनराभ्यास28 पेज

प्रगति सहेजने के लिए साइन इन करें। साइन इन

ParikshaPDF Editorial Team · अपडेट: 1 अक्टूबर 2026