RBSE Solutions Class 11 Computer Science Chapter 1 ‘सी’ भाषा का परिचय

RBSE Class 11 Computer Science Chapter 1 पाठ्यपुस्तक के प्रश्न

RBSE Class 11 Computer Science Chapter 1 बहुचयनात्मक

 

Question 1. if (1) printf("True"); else printf("false"); उपर्युक्त कथन प्रिन्ट करेगा
(अ) true
(ब) false
(स) कथन गलत है
(द) इनमें से कोई नहीं
Answer: (अ) true
In simple words: C भाषा में, if(1) का मतलब है कि कंडीशन सही है (true). इसलिए, प्रोग्राम "True" प्रिंट करेगा.

🎯 Exam Tip: याद रखें कि C भाषा में कोई भी नॉन-ज़ीरो मान (जैसे 1) को 'true' माना जाता है, जबकि 0 को 'false' माना जाता है.

 

Question 3. 'C' भाषा में प्रत्येक कथन को पृथक करने के काम में आता है?
(अ) &
(ब) !
(स) ;
(द) "
Answer: (स) ;
In simple words: C प्रोग्रामिंग में, हर एक स्टेटमेंट को सेमीकोलन (;) से खत्म किया जाता है ताकि कंपाइलर जान सके कि एक कमांड कहाँ खत्म हो रही है.

🎯 Exam Tip: सेमीकोलन लगाना एक सामान्य गलती होती है, इसलिए हमेशा सुनिश्चित करें कि हर स्टेटमेंट के बाद सेमीकोलन लगा हो.

 

Question 4. 'C' भाषा के सभी प्रोग्राम में किसका लिखना अति आवश्यक है
(अ) ग्लोबल चर
(ब) main() फलन
(स) पॉइन्टर
(द) फलन
Answer: (ब) main() फलन
In simple words: C प्रोग्राम में `main()` फंक्शन सबसे जरूरी होता है क्योंकि यह वो जगह है जहाँ से प्रोग्राम चलना शुरू होता है. इसके बिना प्रोग्राम काम नहीं कर सकता.

🎯 Exam Tip: `main()` फंक्शन ही प्रोग्राम का एंट्री पॉइंट होता है, इसलिए सभी C प्रोग्राम में इसका होना अनिवार्य है.

 

Question 5. ऐसे शब्द जिनका उपयोग व अर्थ पहले से ही निश्चित होता है
(अ) चर
(ब) अचर
(स) अभिज्ञानक
(द) आरक्षित शब्द
Answer: (द) आरक्षित शब्द
In simple words: प्रोग्रामिंग भाषा में कुछ शब्द ऐसे होते हैं जिनका खास मतलब होता है और उन्हें किसी और काम के लिए इस्तेमाल नहीं किया जा सकता. इन शब्दों को आरक्षित शब्द कहते हैं.

🎯 Exam Tip: आरक्षित शब्दों को कीवर्ड्स भी कहा जाता है और उन्हें वेरिएबल या फंक्शन के नाम के रूप में उपयोग नहीं करना चाहिए.

 

Question 7. निम्न में से वैध अचर है
(अ) 4, 78
(ब) 0X23A
(स) 177A
(द) 5.7,632
Answer: (ब) 0X23A
In simple words: 0X23A एक वैध हेक्साडेसिमल अचर है, जिसका मतलब यह है कि यह C भाषा में एक सही संख्या है.

🎯 Exam Tip: C भाषा में, हेक्साडेसिमल संख्याएँ '0x' या '0X' से शुरू होती हैं, उसके बाद 0-9 और A-F (या a-f) अक्षर आते हैं. यह एक महत्वपूर्ण प्रारूप है जिसे याद रखना चाहिए.

 

Question 8. इसमें से कौन-सा अभिज्ञानक वैध नहीं है
(अ) 5XYZ
(ब) total_subject
(स) Stud_mark
(द) XSXY
Answer: (अ) 5XYZ
In simple words: C भाषा में किसी भी नाम (जैसे वेरिएबल का नाम) की शुरुआत में अंक नहीं आ सकता. इसलिए, "5XYZ" एक गलत नाम है.

🎯 Exam Tip: अभिज्ञानक (identifier) हमेशा किसी अक्षर (A-Z, a-z) या अंडरस्कोर (_) से शुरू होना चाहिए, उसके बाद अक्षर, अंक या अंडरस्कोर हो सकते हैं.

 

Question 9. long double डाटा प्रकार के लिए printf में कन्ट्रोल स्ट्रिंग होगी
(अ) %d
(ब) %if
(स) % Id.
(द) %Lf
Answer: (द) %Lf
In simple words: `long double` एक बहुत बड़ी दशमलव संख्या को स्टोर करने के लिए इस्तेमाल होता है, और इसे प्रिंट करने के लिए `printf` में `%Lf` का उपयोग किया जाता है.

🎯 Exam Tip: अलग-अलग डेटा प्रकारों के लिए सही फॉर्मेट स्पेसिफायर (जैसे `%d`, `%f`, `%Lf`) का उपयोग करना बहुत महत्वपूर्ण है, नहीं तो गलत आउटपुट मिल सकता है.

 

Question 11. यदि i=8 तथा b = -i+3 तो b का मान होगा
(अ) 11
(ब) 10
(स) 9
(द) 12
Answer: (ब) 10
In simple words: यदि `i` का मान 8 है, तो `b = -8 + 3` का मतलब `b = -5` होता है.

🎯 Exam Tip: C प्रोग्रामिंग में, `-i` का मतलब `i` का नकारात्मक मान है, न कि डिक्रीमेंट (घटाना). ऑपरेटर प्रेसीडेंस (operator precedence) का भी ध्यान रखें.

 

Question 12. लूप का निष्पादन रोकने के लिए कौन-सा कथन उपयोग में लाया जाता है
(अ) break
(ब) stop
(स) end
(द) इनमें से कोई नहीं
Answer: (अ) break
In simple words: `break` स्टेटमेंट का उपयोग लूप या `switch` स्टेटमेंट को तुरंत बंद करने के लिए किया जाता है.

🎯 Exam Tip: `break` का उपयोग अक्सर किसी खास कंडीशन के पूरा होने पर लूप से बाहर निकलने के लिए किया जाता है.

 

Question 13. for (i = 0; i < = 5; i ++); for (j = i; j < = 5; j ++); Print f ("India"); उपर्युक्त प्रोग्राम में India कितनी बार प्रिन्ट होगा
(अ) 6
(ब) 21
(स) 36
(द) 30
Answer: (ब) 21
In simple words: इस प्रोग्राम में, बाहर वाला लूप (i) 0 से 5 तक चलता है, और अंदर वाला लूप (j) हर बार i के मान से 5 तक चलता है. जब हम इन सभी संभावनाओं को जोड़ते हैं, तो "India" कुल 21 बार प्रिंट होगा.

🎯 Exam Tip: नेस्टेड लूप्स (nested loops) में, बाहरी लूप के प्रत्येक इटिरेशन (iteration) के लिए आंतरिक लूप (inner loop) पूरा चलता है. आउटपुट की गणना के लिए दोनों लूप की सीमाओं को ध्यान से समझें.

 

Question 15. नीड़ित लूप संरचना में सबसे पहले समाप्त होने वाला लूप होगा
(अ) बाहर वाला लूप
(ब) अन्दर वाला लूप
(स) दोनों एक साथ
(द) इनमें से कोई नहीं
Answer: (ब) अन्दर वाला लूप
In simple words: जब एक लूप दूसरे लूप के अंदर होता है, तो अंदर वाला लूप पहले अपना काम पूरा करता है और खत्म होता है, फिर बाहर वाले लूप का अगला चरण शुरू होता है.

🎯 Exam Tip: नेस्टेड लूप्स में, आंतरिक लूप (inner loop) हर बार बाहरी लूप (outer loop) के एक पुनरावृति (iteration) के लिए पूरी तरह से निष्पादित होता है.

RBSE Class 11 Computer Science Chapter 1 अतिलघु उत्तरीय प्रश्न

 

Question 1. आरक्षित शब्द क्या होते हैं?
Answer: ऐसे शब्द जिनका अर्थ और उपयोग 'C' भाषा के लिए पहले से तय होता है, उन्हें आरक्षित शब्द कहते हैं. इन शब्दों को किसी वेरिएबल, फंक्शन या किसी अन्य पहचानकर्ता (identifier) के नाम के रूप में उपयोग नहीं किया जा सकता है.
In simple words: आरक्षित शब्द C भाषा के खास शब्द होते हैं, जिनका मतलब पहले से तय होता है और हम उन्हें अपने प्रोग्राम में किसी और नाम के लिए इस्तेमाल नहीं कर सकते.

🎯 Exam Tip: आरक्षित शब्दों को कीवर्ड्स (keywords) भी कहा जाता है; उन्हें याद रखना ज़रूरी है ताकि प्रोग्रामिंग में गलती न हो.

 

Question 2. प्राचल कितने प्रकार के होते हैं?
Answer: प्राचल (parameters) दो प्रकार के होते हैं:
1. **फॉर्मल प्राचल (Formal Parameters):** ये वे प्राचल होते हैं जो फंक्शन की परिभाषा में लिखे जाते हैं.
2. **एक्चुअल प्राचल (Actual Parameters):** ये वे प्राचल होते हैं जो फंक्शन को कॉल करते समय पास किए जाते हैं.
In simple words: फंक्शन को जानकारी देने के लिए दो तरह के तरीके होते हैं: एक जो फंक्शन बनाते समय बताया जाता है (फॉर्मल) और दूसरा जो फंक्शन को चलाते समय दिया जाता है (एक्चुअल).

🎯 Exam Tip: फ़ॉर्मल प्राचल प्लेसहोल्डर (placeholder) होते हैं, जबकि एक्चुअल प्राचल वे वास्तविक मान होते हैं जो फ़ंक्शन को भेजे जाते हैं.

 

Question 3. 'C' भाषा में main() फलन का उपयोग कितनी बार किया जाता है?
Answer: 'C' भाषा में `main()` फलन का उपयोग केवल एक ही बार किया जाता है. यह प्रोग्राम का मुख्य एंट्री पॉइंट होता है, जहाँ से प्रोग्राम का निष्पादन शुरू होता है.
In simple words: `main()` फंक्शन C प्रोग्राम में सिर्फ एक बार होता है क्योंकि यहीं से प्रोग्राम चलना शुरू करता है.

🎯 Exam Tip: एक C प्रोग्राम में `main()` फंक्शन का होना अनिवार्य है, और यह केवल एक ही होना चाहिए.

 

Question 4. ++ संकारक का क्या उपयोग है?
Answer: `++` संकारक को इन्क्रीमेंट ऑपरेटर (Increment Operator) कहते हैं. इसका उपयोग किसी चर (variable) के मान को 1 से बढ़ाने के लिए किया जाता है. उदाहरण के लिए, `x++` का मतलब `x = x + 1` होता है.
In simple words: `++` का मतलब है कि किसी भी संख्या को एक बढ़ाना है, जैसे `x++` का मतलब `x` में एक जोड़ना.

🎯 Exam Tip: `++` ऑपरेटर के दो रूप होते हैं - प्री-इन्क्रीमेंट (`++x`) और पोस्ट-इन्क्रीमेंट (`x++`), जिनके काम करने का तरीका थोड़ा अलग होता है, खासकर जब उन्हें किसी एक्सप्रेशन में उपयोग किया जाता है.

 

Question 6. आउटपुट किस फलन के द्वारा दिया जा सकता है?
Answer: C भाषा में आउटपुट `printf()` फलन के द्वारा दिया जा सकता है. `printf()` फंक्शन का उपयोग कंसोल (स्क्रीन) पर टेक्स्ट, वेरिएबल के मान या किसी अन्य जानकारी को प्रिंट करने के लिए किया जाता है.
In simple words: हम `printf()` फंक्शन का इस्तेमाल करके अपने प्रोग्राम की जानकारी स्क्रीन पर दिखा सकते हैं.

🎯 Exam Tip: `printf()` एक बहुत ही बहुमुखी (versatile) फंक्शन है और इसका सही उपयोग आउटपुट को फॉर्मेट करने में मदद करता है.

 

Question 7. default कथन किस संरचना में उपयोग किया जाता है?
Answer: `default` कथन का उपयोग `switch` कथन संरचना में किया जाता है. जब `switch` स्टेटमेंट में किसी भी `case` से मिलान नहीं होता, तो `default` ब्लॉक में लिखा गया कोड निष्पादित होता है.
In simple words: `default` कमांड `switch` स्टेटमेंट में इस्तेमाल होती है. जब कोई भी मैच नहीं मिलता, तो `default` वाला काम होता है.

🎯 Exam Tip: `default` केस का उपयोग करना अच्छा अभ्यास है ताकि `switch` स्टेटमेंट में कोई भी अनपेक्षित इनपुट (unexpected input) हैंडल किया जा सके.

 

Question 8. नीड़ित if else कथन कैसे लिखते हैं?
Answer: नीड़ित `if else` कथन (Nested `if-else` statement) में एक `if-else` कथन के अंदर दूसरा `if-else` कथन लिखा जाता है. यह तब उपयोग किया जाता है जब हमें एक से अधिक कंडीशन की जांच करनी होती है, और एक कंडीशन का परिणाम दूसरी कंडीशन की जांच को प्रभावित करता है.
In simple words: `Nested if-else` का मतलब है कि एक `if-else` के अंदर एक और `if-else` कमांड डालना, ताकि एक के बाद एक कई शर्तें जांची जा सकें.

🎯 Exam Tip: `nested if-else` में, इंडेंटेशन (indentation) का सही उपयोग करना बहुत महत्वपूर्ण है ताकि कोड को पढ़ना और समझना आसान हो सके.

 

Question 9. continue कथन का उपयोग कहाँ किया जाता है?
Answer: `continue` कथन का उपयोग लूप (जैसे `for`, `while`, `do-while`) के अंदर किया जाता है. जब `continue` कथन निष्पादित होता है, तो लूप के वर्तमान पुनरावर्तन (iteration) का शेष कोड छोड़ दिया जाता है और लूप का अगला पुनरावर्तन शुरू हो जाता है. यह लूप को पूरी तरह से नहीं रोकता, बल्कि सिर्फ वर्तमान चरण को छोड़ देता है.
In simple words: `continue` कमांड लूप में काम आता है. जब यह आता है, तो लूप का मौजूदा काम रुक जाता है और वह सीधे अगले चक्र (next cycle) पर चला जाता है.

🎯 Exam Tip: `continue` का उपयोग तब करें जब आप लूप के भीतर किसी विशेष स्थिति के लिए कुछ कोड को छोड़ना चाहते हैं, लेकिन आप लूप को पूरी तरह से बंद नहीं करना चाहते हैं.

 

Question 10. 'C' भाषा में कितनी लूप संरचनाएँ हैं?
Answer: 'C' भाषा में तीन मुख्य लूप संरचनाएँ होती हैं, जिनका उपयोग कोड के ब्लॉक को बार-बार निष्पादित करने के लिए किया जाता है:

• `for` लूप
• `while` लूप
• `do-while` लूप

ये तीनों लूप एक ही उद्देश्य को पूरा करते हैं (कोड को दोहराना), लेकिन उनके सिंटेक्स और कंडीशन चेक करने के तरीके में अंतर होता है.
In simple words: C भाषा में तीन तरह के लूप होते हैं - `for`, `while`, और `do-while`. ये सभी कोड को बार-बार चलाने के काम आते हैं.

🎯 Exam Tip: `for` लूप का उपयोग तब करें जब आप जानते हों कि लूप कितनी बार चलना है; `while` और `do-while` का उपयोग तब करें जब कंडीशन पूरी होने तक लूप चलना हो.

 

Question 11. do while संरचना को उदाहरण सहित समझाइये।
Answer: `do-while` लूप एक कंट्रोल स्टेटमेंट है जो `while` लूप के समान है, लेकिन इसमें कंडीशन की जाँच लूप बॉडी के निष्पादन के बाद होती है. इसका मतलब यह है कि `do-while` लूप कम से कम एक बार जरूर निष्पादित होता है, भले ही कंडीशन पहली बार में ही गलत क्यों न हो. `do-while` लूप का सामान्य स्वरूप नीचे दिया गया है:
`do { // लूप काया (Loop body) } while (कंडीशन);`
**उदाहरण:**
`{ printf("%d", i); i++; } while (i < 10);`
इस उदाहरण में, `printf` स्टेटमेंट कम से कम एक बार चलेगा, चाहे `i` का मान 10 से कम न हो. यह `i` के मान को प्रिंट करेगा और फिर `i` को 1 से बढ़ाएगा, उसके बाद ही `i < 10` की कंडीशन चेक करेगा.
In simple words: `do-while` लूप पहले अपना काम करता है, फिर कंडीशन चेक करता है. इसलिए, यह कम से कम एक बार तो जरूर चलता है.

🎯 Exam Tip: `do-while` लूप उन स्थितियों के लिए आदर्श है जहाँ लूप बॉडी को कम से कम एक बार निष्पादित करना आवश्यक हो, जैसे यूजर से इनपुट लेना.

RBSE Class 11 Computer Science Chapter 1 लघु उत्तरीय प्रश्न

 

Question 1. एल्गोरिथम से क्या तात्पर्य है?
Answer: एल्गोरिथम किसी समस्या को हल करने के लिए स्टेप-बाय-स्टेप निर्देशों का एक निश्चित और उचित सेट होता है. ये स्टेप्स एक खास क्रम में होते हैं. अगर हम इसे आसान शब्दों में कहें, तो किसी भी समस्या को हल करने के लिए क्रमबद्ध तरीके से लिखे गए निर्देशों के समूह को एल्गोरिथम कहते हैं. यह एक प्रकार का ब्लूप्रिंट होता है जो प्रोग्राम लिखने से पहले तैयार किया जाता है.
In simple words: एल्गोरिथम का मतलब है किसी भी समस्या को सुलझाने के लिए एक के बाद एक दिए गए निर्देशों का सेट, जिसे हम एक लिस्ट की तरह लिखते हैं.

🎯 Exam Tip: एल्गोरिथम हमेशा स्पष्ट, सीमित और प्रभावी होना चाहिए, ताकि हर बार एक ही इनपुट के लिए एक ही सही आउटपुट मिले.

 

Question 2. अचर किसे कहते हैं?
Answer: अचर (Constant) ऐसे पहचानकर्ता (identifiers) होते हैं जिनका मान पूरे प्रोग्राम के निष्पादन के दौरान स्थिर रहता है, यानी उनके मान को बदला नहीं जा सकता. अचर तीन मुख्य प्रकार के होते हैं:

अचर मान डेटा को सुरक्षित रखने में मदद करते हैं, जो प्रोग्राम के रन होने के दौरान नहीं बदलना चाहिए.
In simple words: अचर वो होते हैं जिनकी वैल्यू पूरे प्रोग्राम में एक जैसी रहती है, उन्हें बदला नहीं जा सकता. जैसे कि कोई फिक्स नंबर या टेक्स्ट.

🎯 Exam Tip: `const` कीवर्ड का उपयोग करके अचरों को घोषित किया जाता है. इन्हें प्रोग्राम की शुरुआत में परिभाषित करना सबसे अच्छा होता है.

 

Question 4. स्टिंग चर और करैक्टर चर में अन्तर बताइये।
Answer: **कैरेक्टर चर (Character Variable):**
कैरेक्टर चर का मतलब केवल एक कैरेक्टर होता है, जैसे 'a', '2', 'd', '='. इसे हमेशा सिंगल कोट्स (`' '`) में दर्शाया जाता है. यह मेमोरी में एक बाइट (byte) जगह लेता है.
**स्ट्रिंग चर (String Variable):**
स्ट्रिंग चर कई कैरेक्टरों का एक समूह होता है. इसे हमेशा डबल कोट्स (`" "`) में दर्शाया जाता है, जैसे "hello", "computer", "book". स्ट्रिंग वास्तव में कैरेक्टरों का एक ऐरे (array) होती है जो `\0` (नल कैरेक्टर) से समाप्त होती है. यह मेमोरी में उसके अंदर कैरेक्टरों की संख्या के आधार पर जगह लेता है.
In simple words: कैरेक्टर चर सिर्फ एक अक्षर (जैसे 'A') होता है, जिसे सिंगल कोट्स में लिखते हैं, जबकि स्ट्रिंग चर कई अक्षरों का समूह (जैसे "hello") होता है, जिसे डबल कोट्स में लिखते हैं.

🎯 Exam Tip: याद रखें कि C में स्ट्रिंग को हैंडल करने के लिए `char` ऐरे का उपयोग किया जाता है, और उन्हें हमेशा नल कैरेक्टर (`\0`) से समाप्त करना होता है.

 

Question 5. अभिज्ञानक किसे कहते हैं?
Answer: अभिज्ञानक (Identifier) प्रोग्राम के विभिन्न तत्वों, जैसे चर (variable) का नाम, फलन (function) का नाम, और प्रतीकात्मक अचर (symbolic constant) का नाम, जिन्हें उपयोगकर्ता द्वारा दिया जाता है, को कहते हैं. अभिज्ञानक का पहला अक्षर हमेशा अंग्रेजी वर्णमाला का एक अक्षर (A-Z या a-z) या अंडरस्कोर (`_`) होना चाहिए. इसमें अधिकतम 31 अक्षर हो सकते हैं (कुछ कंपाइलर अधिक की अनुमति दे सकते हैं).
In simple words: अभिज्ञानक प्रोग्राम में दिए गए नाम होते हैं, जैसे वेरिएबल या फंक्शन के नाम. इनका पहला अक्षर हमेशा एक लेटर या अंडरस्कोर होना चाहिए.

🎯 Exam Tip: अभिज्ञानक बनाते समय, नाम सार्थक (meaningful) और कोड को समझने में आसान होना चाहिए. साथ ही, C के कीवर्ड्स को अभिज्ञानक के रूप में उपयोग करने से बचें.

 

Question 6. त्रिआधारी ऑपरेटर समझाइये।
Answer: त्रिआधारी संकारक (Ternary operator), जिसे कंडीशनल ऑपरेटर (`?:`) भी कहते हैं, C भाषा में एकमात्र ऑपरेटर है जो तीन ऑपरेंड (operands) पर काम करता है. इसका उपयोग किसी कंडीशन के आधार पर दो मानों में से एक को असाइन (assign) करने के लिए किया जाता है. इसका सामान्य स्वरूप निम्नलिखित है:
`variable = exp1 ? exp2 : exp3;`
यहाँ, `exp1` एक तार्किक एक्सप्रेशन (logical expression) है. सबसे पहले, `exp1` का मान परखा जाता है. यदि `exp1` सही (True) होता है, तो `exp2` का मान `variable` में स्टोर हो जाता है. अन्यथा, यदि `exp1` गलत (False) होता है, तो `exp3` का मान `variable` में स्टोर हो जाता है.
**उदाहरण:**
यदि `a = 5, b = 9`
`c = a > b ? a : b;`
इसमें `c` का मान 9 होगा, क्योंकि `a > b` (5 > 9) गलत है, इसलिए `exp3` का मान (जो कि `b` का मान 9 है) `c` में स्टोर होगा.
In simple words: त्रिआधारी ऑपरेटर एक शर्त की तरह काम करता है: अगर शर्त सही है, तो पहला काम होता है; अगर गलत है, तो दूसरा काम होता है.

🎯 Exam Tip: कंडीशनल ऑपरेटर (`?:`) `if-else` स्टेटमेंट का एक संक्षिप्त रूप है और यह अक्सर छोटे कंडीशनल असाइनमेंट के लिए उपयोग किया जाता है.

 

Question 8. संकारकों के लिए साहचर्य नियमों की आवश्यकता कब होती है?
Answer: संकारकों के लिए साहचर्य नियमों (Associativity rules) की आवश्यकता तब होती है जब एक व्यंजक (expression) में एक से अधिक संकारक (operators) होते हैं और उन संकारकों की प्राथमिकता (precedence) समान (equal) होती है. ऐसे में, साहचर्य नियम यह तय करता है कि कौन सा ऑपरेटर पहले निष्पादित होगा (बाएं से दाएं या दाएं से बाएं).

In simple words: जब किसी गणितीय सवाल में एक जैसे ताकत वाले दो निशान एक साथ आते हैं, तो साहचर्य नियम बताता है कि पहले कौन सा हल करना है, जैसे दाएं से बाएं या बाएं से दाएं.

🎯 Exam Tip: प्राथमिकता (precedence) यह तय करती है कि कौन सा ऑपरेटर पहले चलेगा (जैसे गुणा जोड़ से पहले), जबकि साहचर्यता (associativity) यह तय करती है कि समान प्राथमिकता वाले ऑपरेटरों को किस क्रम में निष्पादित किया जाएगा.

 

Question 10. नीड़ित लूप किसे कहते हैं?
Answer: नीड़ित लूप (Nested Loop) तब होता है जब एक लूप के अंदर दूसरा लूप चलता है (यानी 'लूप के अंदर लूप'). उदाहरण के लिए, एक `for` लूप के अंदर एक और `for` लूप होना. इसमें ध्यान रखने योग्य बात यह है कि बाहरी लूप का समापन बाद में होता है, जबकि अंदर वाले लूप का समापन पहले होता है.
**उदाहरण:**
`for (condition) { for (condition) { // लूप काया } }`
यह संरचना जटिल कार्यों के लिए उपयोगी होती है, जैसे मैट्रिक्स (matrix) को प्रिंट करना या मल्टी-डाइमेंशनल ऐरे (multi-dimensional array) को एक्सेस करना.
In simple words: नीड़ित लूप का मतलब है एक लूप के अंदर दूसरा लूप चलाना. जैसे, एक `for` लूप के अंदर दूसरा `for` लूप. अंदर वाला लूप पहले खत्म होता है.

🎯 Exam Tip: नेस्टेड लूप्स का उपयोग करते समय, सुनिश्चित करें कि आंतरिक लूप के लिए लूप वेरिएबल बाहरी लूप के वेरिएबल से अलग हो ताकि कोई संघर्ष न हो.

 

Question 11. do-while कथन को समझाइये।
Answer: `do-while` कथन में, लूप बॉडी (loop body) को पहले एक बार निष्पादित किया जाता है, और उसके बाद कंडीशन की जाँच की जाती है. इसका मतलब यह है कि `do-while` लूप कम से कम एक बार जरूर चलता है, भले ही कंडीशन पहली बार में ही गलत क्यों न हो. `do-while` लूप भी `while` लूप की तरह ही True कंडीशन पर निष्पादित होता रहता है. इसका सामान्य स्वरूप निम्नलिखित प्रकार होता है:
`do { // लूप काया (Loop body) } while (कंडीशन);`
**उदाहरण:**
`do { printf("Hello\n"); } while (0);` (यह "Hello" को एक बार प्रिंट करेगा, क्योंकि कंडीशन बाद में जाँची जाती है)
In simple words: `do-while` लूप पहले काम करता है, फिर शर्त देखता है. इसलिए, वह कम से कम एक बार तो जरूर चलता है, चाहे शर्त कुछ भी हो.

🎯 Exam Tip: `do-while` लूप उन स्थितियों के लिए सबसे अच्छा है जहाँ लूप के कोड को कम से कम एक बार निष्पादित करना आवश्यक हो, जैसे कि यूजर से इनपुट लेना और फिर उसकी वैधता (validity) की जांच करना.

 

Question 12. if कथन के सभी प्रकारों को लिखिये।
Answer: `if` कथन C भाषा में एक शक्तिशाली कंट्रोल स्टेटमेंट है जो कंडीशन के आधार पर कोड के ब्लॉक को निष्पादित करने के लिए उपयोग किया जाता है. `if` कथन के चार मुख्य प्रकार हैं:

• **साधारण `if` कथन (Simple `if` statement):** इस कथन में, सबसे पहले कंडीशन की जाँच की जाती है. यदि कंडीशन सही (True) होती है, तो `if` ब्लॉक के अंदर का कोड निष्पादित होता है; अन्यथा, कुछ भी नहीं होता.
• **`if-else` कथन (`if-else` statement):** यह कथन प्रोग्राम के कंट्रोल फ्लो को दो दिशाओं में नियंत्रित करता है. सबसे पहले कंडीशन की जाँच की जाती है. यदि कंडीशन सही होती है, तो `if` ब्लॉक का कोड चलता है; यदि कंडीशन गलत (False) होती है, तो `else` ब्लॉक का कोड निष्पादित होता है.
• **नीड़ित `if-else` कथन (Nested `if-else` statement):** इसमें एक `if-else` कथन के अंदर दूसरा `if-else` कथन लिखा जाता है. यह तब उपयोग किया जाता है जब हमें कई कंडीशनों की जाँच एक के बाद एक करनी होती है.
• **`else if` सोपान (`else if` stairs):** यह बहु-विकल्पी (multi-way) निर्णयों के लिए उपयोग किया जाता है. जब एक से अधिक कंडीशन की जाँच करनी होती है और हर कंडीशन के लिए एक अलग कार्रवाई करनी होती है, तो हम `else if` की एक श्रृंखला का उपयोग करते हैं.

In simple words: `if` कमांड के चार प्रकार होते हैं: `if` (एक शर्त), `if-else` (दो रास्ते), `nested if-else` (शर्त के अंदर शर्त), और `else if` (कई रास्तों में से एक चुनना).

🎯 Exam Tip: `if` कथनों का सही उपयोग प्रोग्राम के लॉजिक (logic) को स्पष्ट और व्यवस्थित बनाता है, जिससे गलतियों से बचा जा सकता है.

 

Question 13. switch कथन को फारमेट लिखिये।
Answer: `switch` कथन एक बहु-विकल्पी कंडीशनल कंट्रोल स्टेटमेंट है. यह `if-else` की तरह ही एक कंडीशन पर आधारित होता है. `switch` कथन में, एक व्यंजक (expression) या चर (variable) के मान के अनुसार विभिन्न कथन समूह निष्पादित किए जाते हैं. `switch` व्यंजक या चर का मान पूर्णांक (integer) या कैरेक्टर (character) ही होना चाहिए. इसका स्वरूप निम्नलिखित प्रकार होता है:
`switch (व्यंजक या चर) { case मान 1: कथन समूह 1; break; case मान 2: कथन समूह 2; break; // ... case मान n: कथन समूह n; break; default: कथन समूह; }`
`break` स्टेटमेंट का उपयोग `case` ब्लॉक के निष्पादन के बाद `switch` स्टेटमेंट से बाहर निकलने के लिए किया जाता है. यदि `break` का उपयोग नहीं किया जाता है, तो कंट्रोल अगले `case` पर चला जाता है (जिसे फॉल-थ्रू कहते हैं). `default` केस वैकल्पिक (optional) होता है और तब निष्पादित होता है जब कोई `case` मान से मेल नहीं खाता.
In simple words: `switch` कमांड एक व्यंजक के मान को देखता है और फिर उस मान से मेल खाते हुए `case` ब्लॉक के कोड को चलाता है. अगर कोई `case` नहीं मिलता, तो `default` वाला कोड चलता है.

🎯 Exam Tip: `switch` स्टेटमेंट में प्रत्येक `case` के बाद `break` स्टेटमेंट का उपयोग करना न भूलें, अन्यथा अनपेक्षित 'फॉल-थ्रू' व्यवहार (fall-through behavior) हो सकता है.

 

Question 15. नीचे लिखे प्रोग्राम का आउटपुट बताइये
(a)
`#include main () { int i = 1, x = 1 ; for (i = 1; i < 10, i++) { printf("%d\n", x + 1); x = x + 1; } }`
Answer: दिए गए प्रोग्राम का आउटपुट निम्नलिखित होगा:
2
4
6
8
10
12
14
16
18
**कारण:** लूप `i = 1` से शुरू होता है और `i < 10` होने तक चलता है, हर बार `i` को 1 से बढ़ाता है. `x` भी 1 से शुरू होता है. लूप के प्रत्येक पुनरावर्तन में `x + 1` प्रिंट होता है और फिर `x` का मान `x + 1` हो जाता है. इस प्रकार, `x` का मान हर बार 2 से बढ़ता है, और `x + 1` प्रिंट होने से हमें 2, 4, 6, आदि मिलते हैं. `i++` के साथ `i < 10` की कंडीशन में `i` का मान 1 से लेकर 9 तक जाता है, जिससे कुल 9 बार प्रिंटिंग होती है.
In simple words: प्रोग्राम एक लूप में चलता है. `x` का मान 1 से शुरू होता है और हर बार 2 से बढ़ता है, और हर बार `x + 1` को प्रिंट करता है, जिससे 2, 4, 6... जैसी संख्याएँ लाइन से प्रिंट होती हैं.

🎯 Exam Tip: `for` लूप की कंडीशन (`i < 10`) और इंक्रीमेंट (`i++`) को ध्यान से देखें ताकि यह पता चल सके कि लूप कितनी बार चलेगा. लूप के अंदर के परिवर्तनों (`x = x + 1`) पर भी ध्यान दें.

RBSE Class 11 Computer Science Chapter 1 निबंधात्मक प्रश्न

 

Question 1. 'C' भाषा के प्रोग्राम की संरचना बताइये।
Answer: 'C' भाषा का प्रोग्राम विभिन्न फलनों (functions) का एक समूह होता है. प्रत्येक फलन कुछ विशेष काम करता है. कंपाइलर `main()` फलन को सबसे पहले कॉल करता है. इसलिए, `main()` फलन प्रत्येक प्रोग्राम में होना जरूरी है. C भाषा में प्रोग्राम की संरचना हमें यह बताती है कि प्रोग्राम के विभिन्न हिस्सों को कहाँ लिखना चाहिए. एक सामान्य C प्रोग्राम की संरचना इस प्रकार होती है:
1. **प्री-प्रोसेसर डायरेक्टिव और हेडर फाइल (Pre-Processor Directive and Header file):**
ये `C` कंपाइलर को निर्देश देते हैं कि कंपाइलेशन से पहले कुछ काम किए जाएँ, जैसे हेडर फाइलों को जोड़ना (`#include`) या मैक्रोज़ को परिभाषित करना (`#define`).
**उदाहरण:** `#include `
2. **ग्लोबल चर और फलन प्रोटोटाइप (Global declarations of variables and Function Prototype):**
यहाँ उन चरों को घोषित किया जाता है जिन्हें प्रोग्राम के किसी भी फलन में उपयोग किया जा सकता है. फलन प्रोटोटाइप कंपाइलर को बताते हैं कि प्रोग्राम में कौन-कौन से फलन उपयोग किए जाएंगे और वे क्या इनपुट लेंगे और क्या आउटपुट देंगे.
**उदाहरण:** `int global_var; int sum(int a, int b);`
3. **`main()` फलन:**
यह किसी भी `C` प्रोग्राम का मुख्य फलन होता है. प्रोग्राम का निष्पादन यहीं से शुरू होता है. सभी `C` प्रोग्राम में `main()` फलन का होना जरूरी है.
**उदाहरण:** `int main() {`
4. **स्थानीय चर और फलन प्रोटोटाइप `main()` फलन के लिए (Local declarations of variables and Function Prototype of main function):**
`main()` फलन के अंदर घोषित चर और फलन प्रोटोटाइप केवल `main()` फलन के लिए ही उपलब्ध होते हैं.
**उदाहरण:** `int local_var;`
5. **एकल या मिश्रित वाक्य (Single or compound statements):**
ये प्रोग्राम के निष्पादन योग्य स्टेटमेंट होते हैं, जो किसी कार्य को करते हैं. मिश्रित वाक्य `{ }` के अंदर बंद किए जाते हैं.
**उदाहरण:** `printf("Hello");`
6. **`main()` फलन का समापन:**
`}`: यह `main()` फलन की सीमा को बंद करता है.
7. **अन्य फलन का हेडर और आर्गुमेंट के साथ (Header of other function with its arguments):**
`main()` फलन के बाद अन्य उपयोगकर्ता-परिभाषित फलन (`user-defined functions`) लिखे जा सकते हैं. इन फलनों के हेडर और आर्गुमेंट्स (parameters) यहाँ परिभाषित होते हैं.
**उदाहरण:** `int sum(int a, int b) { // फलन बॉडी }`
यह संरचना सुनिश्चित करती है कि C प्रोग्राम व्यवस्थित और कंपाइलर द्वारा समझने योग्य हो.
In simple words: C प्रोग्राम एक खास तरीके से बना होता है: सबसे पहले जरूरी फाइलें जोड़ते हैं, फिर पूरे प्रोग्राम में काम आने वाले नाम बताते हैं, फिर `main()` नाम का मुख्य हिस्सा आता है जहाँ से प्रोग्राम चलता है, और आखिर में बाकी छोटे-छोटे काम करने वाले हिस्से होते हैं.

🎯 Exam Tip: प्रोग्राम की संरचना को समझना कोड को डिबग (debug) करने और लॉजिक को व्यवस्थित रखने में बहुत मदद करता है. `main()` फंक्शन का महत्व और हेडर फाइलों की भूमिका को हमेशा याद रखें.

RBSE Class 11 Computer Science Chapter 1 निबंधात्मक प्रश्न

 

Question 2. प्रोग्राम संरचना से क्या तात्पर्य है?
Answer: किसी भी प्रोग्राम की संरचना उस तरीके को कहते हैं जिससे कंप्यूटर में प्रोग्राम को चलाने का क्रम तय होता है। 'C' भाषा में प्रोग्राम कई छोटे-छोटे हिस्सों (फंक्शन्स) का समूह होता है। हर हिस्सा कुछ खास काम करता है। कंपाइलर हमेशा 'main()' नाम के हिस्से को पहले चलाता है, इसलिए हर 'C' प्रोग्राम में 'main()' फंक्शन होना बहुत ज़रूरी है। 'C' भाषा के प्रोग्राम की संरचना को जानना इसलिए ज़रूरी है ताकि हमें पता चले कि प्रोग्राम के अलग-अलग हिस्सों को कहाँ लिखना चाहिए। प्रोग्राम की सामान्य संरचना इस प्रकार होती है:
1. प्री-प्रोसेसर डायरेक्टिव और हेडर फाइलें (Pre-Processor directive and Header file)
2. ग्लोबल चर और फंक्शन प्रोटोटाइप (Global declarations of variables and Function Prototype)
3. main() फंक्शन
4. { (यहां 'main()' फंक्शन की शुरुआत होती है)
5. 'main()' फंक्शन के लिए लोकल चर और फंक्शन प्रोटोटाइप (Local declarations of variables and Function Prototype of main function)
6. एकल या मिश्रित वाक्य (Single or compound statements)
7.} (यहां 'main()' फंक्शन खत्म होता है)
8. अन्य फंक्शन का हेडर आर्गुमेंट्स के साथ (Header of other function with its arguments)
9. { (यहां किसी अन्य फंक्शन की शुरुआत होती है)
10. फंक्शन के लोकल चर (Local variables of function)
11. एकल या मिश्रित वाक्य (Single or compound statements)
In simple words: प्रोग्राम की संरचना बताती है कि कोड को कैसे व्यवस्थित किया जाए। 'C' प्रोग्राम में 'main()' फंक्शन सबसे ज़रूरी होता है क्योंकि कंप्यूटर वहीं से प्रोग्राम चलाना शुरू करता है।

🎯 Exam Tip: प्रोग्राम की संरचना के मुख्य हिस्सों को याद रखें, जैसे प्री-प्रोसेसर, ग्लोबल डिक्लेरेशन, main() फंक्शन, और लोकल डिक्लेरेशन, क्योंकि यह 'C' प्रोग्रामिंग का आधार है।

 

आंकड़ों का प्रकार (Data Type)

 

Question 4. 'C' भाषा में काम आने वाले इनपुट/आउटपुट कथनों को समझाइये।
Answer: इनपुट/आउटपुट फंक्शन्स (Input-Output Functions) का उपयोग प्रोग्राम में डेटा को पढ़ने, उस पर काम करने और परिणाम दिखाने के लिए किया जाता है। ये तीन मुख्य काम हैं जो किसी भी प्रोग्राम में होते हैं। 'C' भाषा में डेटा इनपुट और आउटपुट के लिए कई इनपुट/आउटपुट फंक्शन्स होते हैं, जैसे `scanf()`, `printf()`, `getchar()`, और `putchar()`। ये फंक्शन्स दो तरह के होते हैं: संरूपित (formatted) और असंरूपित (unformatted)। `printf()` और `scanf()` संरूपित फंक्शन्स हैं, जबकि `putchar()` और `getchar()` असंरूपित फंक्शन्स हैं।
(i) आउटपुट फंक्शन printf (Output Function printf): `printf()` फंक्शन डेटा को कंप्यूटर मेमोरी से मानक आउटपुट डिवाइस (जैसे स्क्रीन) या किसी फाइल में भेजता है। 'C' भाषा में `printf()` फंक्शन डेटा को दिखाने के लिए इस्तेमाल होता है। इसे इस तरह लिखा जाता है:
`printf("नियन्त्रण स्ट्रिंग", चर1, चर2, चर3);`
चर1, चर2 और चर3 वे वेरिएबल हैं जिनके मान आउटपुट डिवाइस पर दिखाने हैं। नियंत्रण स्ट्रिंग को डबल कोट्स (`" "`) के अंदर लिखा जाता है। नियंत्रण स्ट्रिंग वेरिएबल के डेटा प्रकार के अनुसार लिखी जाती है। उदाहरण के लिए, इंटीजर डेटा के लिए `%d` लिखा जाता है।

उदाहरण:
`A= 20, B = 30`
`printf("%d %d", A, B)`
Output: `20 30`
यहां A और B इंटीजर प्रकार के वेरिएबल हैं, और नियंत्रण स्ट्रिंग के अनुसार A व B के मान प्रिंट होते हैं। `printf()` फंक्शन किसी भी स्ट्रिंग को वैसे ही प्रिंट करता है जैसे वह लिखी गई है।

(ii) putchar() फंक्शन: यह फंक्शन कंप्यूटर की मेमोरी से एक कैरेक्टर लेता है और उसे मॉनिटर पर दिखाता है। इसका सामान्य तरीका इस प्रकार है:
`putchar (कैरेक्टर वेरिएबल का नाम);`
इसमें कैरेक्टर वेरिएबल पहले से घोषित होना चाहिए जिसका मान मॉनिटर पर डिस्प्ले होगा।
उदाहरण:
`char a;`
`putchar (a);`
पहले कथन से 'a' कैरेक्टर प्रकार का वेरिएबल घोषित होता है। दूसरा कथन 'a' वेरिएबल के मान को आउटपुट डिवाइस पर भेजता है। `putchar(a)` और `printf("%c", a)` दोनों कथन एक ही काम करते हैं।

(iii) scanf() फंक्शन: `scanf()` फंक्शन का उपयोग डेटा को मानक इनपुट डिवाइस (कीबोर्ड) से लेकर प्रोग्राम के विभिन्न वेरिएबल में स्टोर करने के लिए किया जाता है। `scanf()` फंक्शन को इस प्रकार लिखा जाता है:
`scanf("नियन्त्रण स्ट्रिंग", &चर1, &चर2, &चर3)`
`scanf()` में `&चर1`, `&चर2` और `&चर3` उन वेरिएबल का एड्रेस बताते हैं जहाँ कीबोर्ड से प्राप्त डेटा को स्टोर करना है। वेरिएबल के पहले `&` का चिह्न यह दर्शाता है कि यह वेरिएबल का एड्रेस है, न कि उसका मान। नियंत्रण स्ट्रिंग में `%` चिह्न के साथ `printf()` की तरह ही अंग्रेज़ी वर्णमाला का अक्षर लिखा जाता है।

(iv) getchar() फंक्शन: यह फंक्शन इनपुट डिवाइस से एक कैरेक्टर लेता है और कंप्यूटर को देता है। इसका सामान्य तरीका इस प्रकार है:
`चर-नाम = getchar();`
उदाहरण:
`char c;`
`c = getchar();`
इस उदाहरण में पहली पंक्ति में 'c' नाम का कैरेक्टर वेरिएबल घोषित किया गया है। जब दूसरा कथन `c = getchar()` चलता है, तो कंप्यूटर कीबोर्ड से किसी कुंजी के दबने का इंतज़ार करता है (यदि डेटा बफर में नहीं है)। कुंजी दबने पर वह कैरेक्टर 'c' में स्टोर हो जाता है। अतः, `c = getchar()` और `scanf("%c", &c)` दोनों कथन एक ही काम करते हैं।
In simple words: इनपुट/आउटपुट फंक्शन्स हमें कंप्यूटर से जानकारी लेने और उसे वापस दिखाने में मदद करते हैं। `printf()` और `putchar()` जानकारी दिखाते हैं, जबकि `scanf()` और `getchar()` जानकारी लेते हैं।

🎯 Exam Tip: `printf()` और `scanf()` के लिए नियंत्रण स्ट्रिंग (`%d`, `%f`, `%s`, आदि) का सही उपयोग करना याद रखें, क्योंकि यह डेटा के प्रकार को बताने के लिए ज़रूरी है। `&` ऑपरेटर का उपयोग `scanf()` में वेरिएबल के पते के लिए किया जाता है।

 

Question 5. संकारकों की प्राथमिकता तथा साहचर्य नियम से आप क्या समझते हैं? उदाहरण सहित समझाइये।
Answer: जब किसी एक्सप्रेशन में एक से ज़्यादा ऑपरेटर होते हैं, तो यह जानना ज़रूरी हो जाता है कि उन्हें किस क्रम में हल किया जाएगा। इस क्रम को तय करने के लिए ऑपरेटरों की प्राथमिकता (precedence) निर्धारित की गई है। जिस ऑपरेटर की प्राथमिकता ज़्यादा होती है, उसे पहले हल किया जाता है। यदि किसी एक्सप्रेशन में दो ऑपरेटरों की प्राथमिकता समान हो, तो उन्हें साहचर्य नियम (associativity rule) के अनुसार सरल किया जाता है। साहचर्य नियम बताता है कि ऑपरेटरों को बाईं से दाईं ओर या दाईं से बाईं ओर हल किया जाएगा। इसलिए, जब किसी एक्सप्रेशन में एक से ज़्यादा ऑपरेटर होते हैं, तो उन्हें सरल करने के लिए साहचर्य नियमों की ज़रूरत पड़ती है।

उदाहरण: यदि `x = 7`, `y = 3.0`, `Z = 2`, `A = 2.5`, `B = 7` हो तो `X+Y/(2* A+ B/Z)` का हल:
\( X+Y/(2* A+ B/Z) \)
\( =7+3.0/(2*2.5 +7/2) \)
\( =7+3.0/(5.0+3.5) \)
\( =7+3.0/(5.0 + 3.5) \)
\( =7+3.0/8.5 \)
\( =7+0.35294 \)
\( =7.35294 \)
In simple words: ऑपरेटरों की प्राथमिकता तय करती है कि कौन सा ऑपरेशन पहले होगा (जैसे गुणा-भाग, फिर जोड़-घटाव)। अगर दो ऑपरेटरों की प्राथमिकता एक जैसी है, तो साहचर्य नियम बताता है कि उन्हें किस दिशा से हल करना है (जैसे बाईं से दाईं ओर या दाईं से बाईं ओर)।

🎯 Exam Tip: एक्सप्रेशंस को हल करते समय हमेशा ऑपरेटर की प्राथमिकता (PEMDAS/BODMAS जैसे नियम) और साहचर्यता का ध्यान रखें ताकि सही परिणाम मिल सके।

 

Question 6. सभी इनपुट फलनों को उदाहरण सहित समझाइये।
Answer: इनपुट फंक्शन्स का उपयोग प्रोग्राम में बाहरी स्रोतों (जैसे कीबोर्ड) से डेटा प्राप्त करने के लिए किया जाता है। 'C' भाषा में मुख्य इनपुट फंक्शन्स `scanf()` और `getchar()` हैं।

(i) इनपुट फंक्शन `scanf()`:
`scanf()` फंक्शन का उपयोग कीबोर्ड जैसे मानक इनपुट डिवाइस से डेटा पढ़कर प्रोग्राम के विभिन्न वेरिएबल में स्टोर करने के लिए किया जाता है। इसे इस प्रकार लिखा जाता है:
`scanf("नियन्त्रण स्ट्रिंग", &चर1, &चर2, &चर3);`
यहाँ, नियंत्रण स्ट्रिंग `"` के अंदर लिखी जाती है और यह वेरिएबल के डेटा प्रकार को बताती है (जैसे इंटीजर के लिए `%d`, फ्लोट के लिए `%f`)। `&` सिंबल वेरिएबल के पते को दर्शाता है, जहाँ डेटा स्टोर किया जाएगा।
उदाहरण:
`scanf("%d%d%d", &NUM1, &NUM2, &NUM3);`
यहाँ `NUM1`, `NUM2`, और `NUM3` इंटीजर प्रकार के वेरिएबल हैं। सभी वेरिएबल के लिए अलग-अलग नियंत्रण स्ट्रिंग का उपयोग किया जाता है।

तीन वास्तविक संख्याओं में से सबसे छोटी संख्या ज्ञात करने का प्रोग्राम:
`#include `
`int main() {`
`float a, b, c, small;` /* float वेरिएबल घोषित किए गए */
`printf ("Enter three float Numbers : \n");`
`scanf("%f %f %f", &a, &b, &c);` /* तीन float नंबर लिए गए */
`if (a < b) {`
`if (a < c) {`
`small = a;`
`} else {`
`small = c;`
`}`
`} else {`
`if (b < c) {`
`small = b;`
`} else {`
`small = c;`
`}`
`}`
`printf("\n The Smallest Number = %f", small);`
`return 0;`
`}`
इनपुट: Enter three float Numbers : `78.23 78.96 85.52`
आउटपुट: The Smallest Numbers : `78.23`

(ii) इनपुट फंक्शन `getchar()`:
`getchar()` फंक्शन कीबोर्ड जैसे इनपुट डिवाइस से एक कैरेक्टर पढ़ता है और उसे वापस करता है। यह कैरेक्टर को प्रोग्राम के वेरिएबल में स्टोर करने के लिए उपयोग होता है। इसका सामान्य स्वरूप इस प्रकार है:
`चर-नाम = getchar();`
उदाहरण:
`char c;`
`c = getchar();`
यहाँ, `c` नामक एक कैरेक्टर वेरिएबल घोषित किया गया है। जब `c = getchar()` कथन चलता है, तो प्रोग्राम उपयोगकर्ता से एक कैरेक्टर इनपुट करने के लिए इंतज़ार करता है। जैसे ही कोई कुंजी दबाई जाती है, उस कुंजी का कैरेक्टर `c` में स्टोर हो जाता है। `c = getchar()` और `scanf("%c", &c)` दोनों समान काम करते हैं।
In simple words: इनपुट फंक्शन्स जैसे `scanf()` और `getchar()` यूजर से जानकारी लेने में मदद करते हैं। `scanf()` कई तरह के डेटा पढ़ सकता है, जबकि `getchar()` सिर्फ एक कैरेक्टर पढ़ता है।

🎯 Exam Tip: `scanf()` का उपयोग करते समय, `&` ऑपरेटर के बिना वेरिएबल नाम लिखने की गलती से बचें, क्योंकि यह कंपाइलर त्रुटि (compiler error) का कारण बन सकता है। `getchar()` सिंगल कैरेक्टर इनपुट के लिए अच्छा है।

 

Question 7. आउटपुट फलनों के द्वारा किस प्रकार आउटपुट प्राप्त किया जाता है? उदाहरण सहित समझाइये।
Answer: आउटपुट फंक्शन्स वे फंक्शन्स होते हैं जो कंप्यूटर प्रोग्राम से परिणाम या डेटा को उपयोगकर्ता (user) तक या किसी फाइल में भेजने का काम करते हैं। 'C' भाषा में डेटा को दिखाने के लिए मुख्य रूप से `printf()` और `putchar()` फंक्शन्स का उपयोग किया जाता है।

(i) आउटपुट फंक्शन `printf()` (Output Function printf):
`printf()` फंक्शन का उपयोग डेटा को कंप्यूटर की मेमोरी से मानक आउटपुट डिवाइस (जैसे स्क्रीन) या किसी फाइल में भेजने के लिए किया जाता है। `printf()` फंक्शन को इस प्रकार लिखा जाता है:
`printf("नियन्त्रण स्ट्रिंग", चर1, चर2, चर3);`
यहाँ, `चर1`, `चर2` और `चर3` वे वेरिएबल हैं जिनके मान आउटपुट डिवाइस पर दिखाने हैं। नियंत्रण स्ट्रिंग को डबल कोट्स (`" "`) के अंदर लिखा जाता है। नियंत्रण स्ट्रिंग वेरिएबल के डेटा प्रकार के अनुसार लिखी जाती है (जैसे इंटीजर के लिए `%d`)।
उदाहरण:
`A= 20, B = 30`
`printf("%d %d", A, B)`
आउटपुट: `20 30`
यहाँ A और B इंटीजर प्रकार के वेरिएबल हैं, और नियंत्रण स्ट्रिंग के अनुसार A व B के मान प्रिंट होते हैं। `printf()` फंक्शन किसी भी स्ट्रिंग को वैसे ही प्रिंट करता है जैसे वह लिखी गई है।
उदाहरण:
`printf ("C is a good programming language.")`
आउटपुट: `C is a good programming language.`

(ii) आउटपुट फंक्शन `putchar()`:
`putchar()` फंक्शन कंप्यूटर की मेमोरी से एक कैरेक्टर लेता है और उसे मॉनिटर पर दिखाता है। इसका सामान्य स्वरूप इस प्रकार है:
`putchar (संप्रतीक चर का नाम);`
इसमें वह कैरेक्टर वेरिएबल आता है जो पहले से घोषित हो और जिसका मान मॉनिटर पर दिखाना है।
उदाहरण:
`char a;`
`putchar (a);`
In simple words: आउटपुट फंक्शन्स, जैसे `printf()` और `putchar()`, कंप्यूटर प्रोग्राम के नतीजों को स्क्रीन पर दिखाते हैं। `printf()` कई तरह के डेटा दिखा सकता है, जबकि `putchar()` एक बार में सिर्फ एक अक्षर दिखाता है।

🎯 Exam Tip: `printf()` का उपयोग करते समय, नियंत्रण स्ट्रिंग में सही फॉर्मेट स्पेसिफायर (`%d`, `%f`, `%c`, `%s`) का उपयोग करें जो आपके डेटा के प्रकार से मेल खाता हो। `putchar()` केवल सिंगल कैरेक्टर के लिए है।

 

Question 8. समतुल्य व्यंजकों में बदलिये।
Answer:
In simple words: समतुल्य व्यंजकों का मतलब है ऐसे व्यंजक जो अलग दिखने पर भी गणितीय रूप से एक ही मान रखते हैं। यह गणित और प्रोग्रामिंग दोनों में समीकरणों को सरल बनाने में मदद करता है।

🎯 Exam Tip: समतुल्य व्यंजकों को पहचानने के लिए गणितीय नियमों और बीजगणितीय पहचानों का उपयोग करें। यह कोड ऑप्टिमाइजेशन में भी सहायक होता है।

 

Question 9. तीन संख्याओं को पढ़कर उनमें से सबसे बड़ी संख्या ज्ञात करने के लिए कन्डीशनल संकारक का उपयोग करके प्रोग्राम लिखो।
Answer: कन्डीशनल ऑपरेटर (`?:`) का उपयोग करके तीन संख्याओं में से सबसे बड़ी संख्या ज्ञात करने का प्रोग्राम यहाँ दिया गया है:
`#include `
`int main() {`
`int a, b, c, big;`
`printf ("Enter three numbers : ");`
`scanf ("%d %d %d", &a, &b, &c);`
`big = a > b ? (a > c ? a : c) : (b > c ? b : c);`
`printf ("\n The biggest number is : %d", big);`
`return 0;`
`}`
इनपुट: Enter three numbers : `5 12 8`
आउटपुट: The biggest number is : `12`
In simple words: यह प्रोग्राम तीन नंबर लेता है और `? :` सिंबल का उपयोग करके उनमें से सबसे बड़ा नंबर ढूंढता है, फिर उसे स्क्रीन पर दिखाता है। यह एक छोटा तरीका है 'if-else' के बिना शर्त लगाने का।

🎯 Exam Tip: कंडीशनल ऑपरेटर (`?:`) का उपयोग छोटे 'if-else' कथनों को संक्षिप्त रूप में लिखने के लिए करें, खासकर जब आपको एक ही मान असाइन करना हो।

 

Question 10. लूपिंग के लिए कौन-कौन से कथन उपयोग किये जाते हैं? वर्णन कीजिए।
Answer: लूपिंग (Looping) का मतलब है प्रोग्राम में कुछ कथनों को बार-बार दोहराना। निर्णय लेने वाले कथनों के अलावा, प्रोग्राम में कई बार कुछ कोड को बार-बार चलाने की ज़रूरत होती है। जब कोड को एक निश्चित क्रम में बार-बार चलाया जाता है, तो इस प्रक्रिया को लूपिंग कहते हैं। 'C' भाषा में तीन मुख्य लूप कथन (`for`, `while`, और `do-while`) होते हैं। इन सभी लूप कथनों के दो मुख्य भाग होते हैं:
• लूपिंग काया (looping body): यह वह कोड होता है जिसे दोहराया जाना है।
• नियंत्रण कथन (condition): यह वह शर्त होती है जो लूप के चलने को नियंत्रित करती है। जब तक यह शर्त सही (`True`) रहती है, लूप चलता रहता है।

1. `for` लूप (`for loop`):
`for` लूप का सामान्य स्वरूप इस प्रकार है:
`for (exp1; exp2 ; exp3) {`
`लूप काया` (loop body)
`}`
जहाँ:
`exp1`: यह लूप काउंटर वेरिएबल का प्रारंभिक मान बताता है और यह एक्सप्रेशन केवल एक बार चलता है।
`exp2`: यह एक कंडीशन एक्सप्रेशन है। अगर यह `True` होता है तो लूप चलता रहता है।
`exp3`: यह वृद्धि/कमी कथन है, जिसका उपयोग लूप काउंटर वेरिएबल का मान बढ़ाने/घटाने के लिए होता है।

2. `while` लूप (`while loop`):
`while` लूप में यह पहले से पता नहीं होता कि लूप कितनी बार चलेगा, यह एक कंडीशन पर निर्भर करता है। जब तक कंडीशन `True` रहती है, लूप के अंदर के कथन बार-बार चलते रहते हैं। जैसे ही कंडीशन `False` होती है, लूप का चलना रुक जाता है। इसे इस तरह लिखा जाता है:
`while (कन्डीशन) {`
`लूप काया` (loop body)
`}`
उदाहरण:
`(a) while (i < 10)` /* `i` का प्रारंभिक मान 1 है */
`{`
`printf("%d", i);`
`i ++;`
`}`
आउटपुट: `1 2 3 4 5 6 7 8 9`

3. `do-while` लूप (`do-while loop`):
`do-while` लूप भी `while` लूप की तरह ही एक लूपिंग कथन है। `do-while` लूप में पहले लूप का कोड चलता है, उसके बाद कंडीशन को चेक किया जाता है। इसका मतलब है कि `do-while` लूप कम से कम एक बार तो चलता ही है, भले ही कंडीशन पहली बार में `False` क्यों न हो। यह `while` लूप की तरह ही `True` कंडीशन पर चलता रहता है। इसका सामान्य स्वरूप इस प्रकार है:
`do {`
`लूप काया` (loop body)
`}`
`while (कन्डीशन);`
In simple words: लूपिंग का मतलब है कोड को बार-बार चलाना। `for`, `while`, और `do-while` तीन तरह के लूप हैं। `for` लूप हमें पता होता है कितनी बार चलेगा, `while` लूप एक शर्त पर निर्भर करता है, और `do-while` लूप कम से कम एक बार ज़रूर चलता है, फिर शर्त चेक करता है।

🎯 Exam Tip: हर लूप के उपयोग और संरचना को समझें। `for` लूप निश्चित इटरेशन्स के लिए, `while` लूप जब तक शर्त पूरी होती रहे, और `do-while` लूप कम से कम एक बार चलाने के लिए सबसे उपयुक्त होते हैं।

 

Question 11. 1 से 50 तक की सभी विषम संख्याओं को प्रिन्ट करने हेतु 'C' भाषा में प्रोग्राम लिखिये।
Answer: 1 से 50 तक की सभी विषम संख्याओं को प्रिंट करने के लिए 'C' भाषा में प्रोग्राम यहाँ दिया गया है:
`#include `
`int main() {`
`int n;`
`printf ("Odd numbers between 1 to 50\n");`
`n = 1;` /* 'n' को 1 से शुरू किया गया */
`while (n <= 50) {`
`printf ("%d ", n);`
`n = n + 2;` /* अगली विषम संख्या के लिए 'n' में 2 जोड़ा गया */
`}`
`return 0;`
`}`
In simple words: यह प्रोग्राम 1 से शुरू होकर 50 तक की सारी विषम संख्याएँ दिखाता है। यह 'n' को 1 पर सेट करता है और हर बार 2 जोड़ता है, जब तक 'n' 50 से ज़्यादा न हो जाए।

🎯 Exam Tip: विषम संख्याएँ प्रिंट करने के लिए, शुरुआती संख्या को विषम रखें और प्रत्येक चरण में 2 जोड़ते रहें। लूप की कंडीशन को सही ढंग से सेट करना भी ज़रूरी है।

 

प्रश्न 12. while लूप और do-while लूप में अन्तर उदाहरण सहित समझाइये।
Answer:
while लूप:
व्हाइल लूप एक ऐसा लूप है जो तब तक चलता रहता है जब तक एक दी गई शर्त (condition) सही रहती है। इसमें लूप का कोड चलने से पहले शर्त को जाँचा जाता है। अगर शर्त पहली बार में ही गलत हो, तो लूप के अंदर का कोड कभी नहीं चलता।
उदाहरण:
while (शर्त)
{
    // लूप का कोड
}
एक प्रोग्राम का उदाहरण:
int i = 1;
while (i < 10) // यहाँ i का शुरुआती मान 1 है
{
    printf("%d ", i);
    i++;
}
Output: 1 2 3 4 5 6 7 8 9

do-while लूप:
डू-व्हाइल लूप भी एक शर्त पर काम करता है, लेकिन इसमें लूप का कोड कम से कम एक बार ज़रूर चलता है, चाहे शर्त सही हो या गलत। इसमें पहले लूप का कोड चलता है, फिर शर्त जाँची जाती है।
उदाहरण:
do
{
    // लूप का कोड
}
while (शर्त);
एक प्रोग्राम का उदाहरण:
int j = 1;
do // यहाँ j का शुरुआती मान 1 है
{
    printf("%d ", j);
    j += 2;
}
while (j <= 20);
Output: 1 3 5 7 9 11 13 15 17 19
In simple words: वाइल लूप पहले शर्त देखता है, फिर काम करता है; अगर शर्त गलत हो, तो काम नहीं होता। डू-वाइल लूप पहले काम करता है, फिर शर्त देखता है; इसलिए यह कम से कम एक बार ज़रूर चलता है।

🎯 Exam Tip: while और do-while लूप के बीच मुख्य अंतर यह है कि do-while लूप हमेशा अपनी बॉडी को कम से कम एक बार निष्पादित करता है, चाहे कंडीशन कुछ भी हो, जबकि while लूप केवल तभी निष्पादित होता है जब कंडीशन सही हो।

 

प्रश्न 13. निम्नलिखित श्रेणी का योग ज्ञात करने के लिए प्रोग्राम लिखिये। \( 1+x+x^2+x^3+......+x^n \)
Answer: यह प्रोग्राम दी गई श्रेणी \( 1+x+x^2+x^3+...+x^n \) का योग (sum) ज्ञात करेगा, जिसके लिए उपयोगकर्ता 'x' और 'n' का मान डालेगा।
#include <stdio.h>
main ()
{
    int x, n, t;
    long sum = 1; // श्रेणी का पहला पद 1 है
    printf("Enter the value of 'x': ");
    scanf("%d", &x);
    printf("\n Enter the value of 'n' : ");
    scanf ("%d", &n);
    t = x;
    while (n > 0)
    {
        sum = sum + t; // वर्तमान पद को योग में जोड़ो
        t = t * x; // अगला पद ज्ञात करो (जैसे x^2, x^3)
        n--;
    }
    printf ("Sum of the series is = %ld\n", sum);
    getch();
}
Sample Input/Output:
Enter the value of 'x': 2
Enter the value of 'n': 3
Sum of the series is = 15
In simple words: यह कोड आपको किसी भी 'x' और 'n' संख्या के लिए \( 1+x+x^2+...+x^n \) तक का कुल जोड़ निकालने में मदद करेगा।

🎯 Exam Tip: श्रेणी के योग वाले प्रोग्राम में लूप के अंदर के लॉजिक को ध्यान से लिखें ताकि सभी पदों का सही-सही योग हो सके। 'long' डेटा टाइप का उपयोग बड़े योग के लिए करें।