RBSE Solutions Class 12 Computer Science Chapter 2 ऐरे

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

RBSE Class 12 Computer Science Chapter 2 वस्तुनिष्ठ प्रश्न

 

Question 1. लीनियर सर्च में वर्स्ट केस कब होता है?
(अ) आइटम ऐरे के बीच में हो
(ब) आइटम ऐरे में बिल्कुल भी नहीं हो
(स) आइटम ऐरे में पीछे हो ।
(द) आइटम ऐरे में पीछे हो या बिल्कुल नहीं हो
Answer: (द) आइटम ऐरे में पीछे हो या बिल्कुल नहीं हो
In simple words: लीनियर सर्च में सबसे खराब स्थिति तब आती है जब हमें जिस आइटम को खोजना है वह ऐरे के बिल्कुल आखिर में हो, या फिर वह आइटम ऐरे में हो ही नहीं। इस स्थिति में, एल्गोरिथम को सभी तत्वों की जाँच करनी पड़ती है।

🎯 Exam Tip: वर्स्ट केस तब होता है जब सर्च किया गया आइटम ऐरे में सबसे आखिर में हो या मौजूद ही न हो, क्योंकि एल्गोरिथम को हर एक एलिमेंट को देखना पड़ता है।

 

Question 2. लीनियर सर्च एल्गोरिथ्म की जटिलता है।
(अ) \( O(n^2) \)
(ब) \( O(\log n) \)
(स) \( O(n \log n) \)
(द) \( O(n) \)
Answer: (द) \( O(n) \)
In simple words: लीनियर सर्च एल्गोरिथम की समय जटिलता \( O(n) \) होती है, जिसका मतलब है कि जैसे-जैसे ऐरे में तत्वों की संख्या (n) बढ़ती है, सर्च करने में लगने वाला समय भी लगभग उसी अनुपात में बढ़ता है। यह तब होता है जब एल्गोरिथम को सबसे खराब स्थिति में सभी तत्वों को देखना पड़ता है।

🎯 Exam Tip: लीनियर सर्च की समय जटिलता हमेशा O(n) होती है क्योंकि यह हर एलिमेंट को एक-एक करके चेक करती है।

 

Question 4. दिये गये मान से किसी तत्व के स्थान को ढूँढ़ना है
(अ) टूर्वस
(ब) सर्च
(स) सोर्ट
(द) इनमें से कोई भी नहीं
Answer: (ब) सर्च
In simple words: किसी भी दिए गए मान को डेटा के अंदर खोजने की प्रक्रिया को 'सर्च' कहते हैं। यह कंप्यूटर विज्ञान में एक बहुत ही महत्वपूर्ण ऑपरेशन है।

🎯 Exam Tip: सर्चिंग का मतलब डेटा में किसी खास वैल्यू को ढूंढना होता है, जबकि सॉर्टिंग का मतलब डेटा को किसी खास क्रम में व्यवस्थित करना होता है।

 

Question 5. निम्न में से कौन-सा मामला जटिलता सिद्धान्त में मौजूद नहीं है
(अ) सबसे अच्छा मामला
(ब) सबसे खराब मामला
(स) औसत के मामले
(द) अशक्त मामले
Answer: (द) अशक्त मामले
In simple words: एल्गोरिथम की जटिलता को समझने के लिए आमतौर पर तीन तरह के मामलों पर विचार किया जाता है: सबसे अच्छा (best), सबसे खराब (worst) और औसत (average) मामला। 'अशक्त मामला' ऐसा कोई मानक वर्गीकरण नहीं है।

🎯 Exam Tip: एल्गोरिथम की क्षमता को मापने के लिए हमेशा 'बेस्ट केस', 'वर्स्ट केस' और 'एवरेज केस' का ही उपयोग किया जाता है।

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

 

Question 1. बाइनरी खोज की समय जटिलता क्या है?
Answer: बाइनरी खोज की समय जटिलता निम्नलिखित है:
• बेस्ट केस - \( O(1) \) इसका मतलब है कि समय स्थिर (constant) रहता है।
• एवरेज केस - \( O(\log n) \)
• वर्स्ट केस - \( O(\log n) \)
जब भी बाइनरी खोज की समय जटिलता पूछी जाती है, तो डिफ़ॉल्ट रूप से वर्स्ट केस मानकर \( O(\log n) \) माना जाता है। बाइनरी सर्च एक बहुत ही एफिशिएंट सर्चिंग एल्गोरिथम है जो सॉर्टेड ऐरे पर काम करती है।
In simple words: बाइनरी सर्च में, सबसे अच्छी स्थिति में बहुत कम समय लगता है (एक बार में ही मिल जाता है), और बाकी सभी स्थितियों में लगभग \( \log n \) समय लगता है। इसका मतलब है कि ऐरे जितना बड़ा होता है, उसे खोजने में थोड़ा ही ज्यादा समय लगता है।

🎯 Exam Tip: बाइनरी सर्च की जटिलता को हमेशा \( O(\log n) \) के रूप में याद रखें, खासकर जब किसी भी विशेष मामले का उल्लेख न किया गया हो।

 

Question 3. स्ट्रिंग क्या है?
Answer: स्ट्रिंग वास्तव में एक आयामी करैक्टर ऐरे (one-dimensional character array) है, जिसके आखिर में Null करैक्टर \( '\0' \) होता है। यह null करैक्टर बताता है कि स्ट्रिंग कहाँ खत्म हो रही है।
उदाहरण:
ऐरे के अंत में Null करैक्टर जोड़ने के लिए करैक्टर स्ट्रिंग की लम्बाई "Hello" शब्द में कुल अक्षरों की संख्या से एक अधिक होनी चाहिए। इसमें 'H', 'e', 'l', 'l', 'o' और \( '\0' \) शामिल होते हैं।
char greeting [6] = {'H', 'e', 'l', 'l', 'o', '\0'};
char greeting [] = "Hello";
In simple words: स्ट्रिंग टेक्स्ट (अक्षरों का समूह) होता है जिसे कंप्यूटर में ऐरे के रूप में रखा जाता है। इसके अंत में एक खास सिंबल \( '\0' \) होता है जो बताता है कि स्ट्रिंग खत्म हो गई है।

🎯 Exam Tip: स्ट्रिंग को हमेशा एक 'कैरेक्टर ऐरे' के रूप में याद रखें जिसके अंत में नल कैरेक्टर '\0' होता है, जो स्ट्रिंग की लंबाई को दर्शाता है।

 

Question 4. सूचक से आपको क्या मतलब है?
Answer: सूचक (Pointer) एक वेरिएबल होता है जिसका मान किसी अन्य वेरिएबल का एड्रेस (मैमोरी लोकेशन का एड्रेस) होता है। यह सीधे मैमोरी के साथ इंटरैक्ट करने का एक तरीका है। किसी भी अन्य वेरिएबल और कॉन्सटेंट की तरह, पोइन्टर को भी उपयोग में लेने से पहले इसे डिक्लेयर करना बहुत जरूरी होता है। पोइन्टर डिक्लेरेशन का साधारण रूप निम्नानुसार है:
type * var-name;
यहाँ 'type' पोइन्टर का प्रकार है। यह C के मान्य डेटा प्रकारों में से कोई एक होना चाहिए, और 'var-name' पोइन्टर वेरिएबल का नाम है। पोइन्टर को डिक्लेयर करने के लिए उपयोग में लिया जाने वाला तारांकन '*' गुणा में उपयोग लिए जाने वाले तारांकन चिह्न के समान ही है। कुछ मान्य पोइन्टर डिक्लेरेशन निम्नानुसार हैं:
int *ip; /*pointer to an integer*/
double *dp; /*pointer to a double*/
float *fp; /*pointer to a float*/
char *ch /*pointer to a character*/
सभी पोइन्टरों के मानों का डेटा प्रकार एक ही होता है, यह एक लॉन्ग (long) हेक्साडेसिमल नम्बर होता है और यह एक मैमोरी पते के रूप में उपयोग किया जाता है। विभिन्न पोइन्टरों के बीच फर्क सिर्फ उनके पोइंट किए गए वेरिएबल और कॉन्सटेंट के डेटा प्रकार पर निर्भर करता है।
In simple words: एक पोइन्टर एक खास तरह का वेरिएबल है जो किसी और वेरिएबल के मैमोरी एड्रेस को स्टोर करता है। यह हमें सीधे कंप्यूटर की मैमोरी के साथ काम करने में मदद करता है।

🎯 Exam Tip: पोइन्टर का मुख्य काम मैमोरी एड्रेस को स्टोर करना है; इसे हमेशा '*' सिंबल के साथ डिक्लेयर किया जाता है, जैसे `int *ptr;`।

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

 

Question 1. उदाहरण के साथ दो आयामी ऐरे समझाओ।
Answer: दो आयामी (2D) ऐरे एक ऐसा डेटा स्ट्रक्चर है जो डेटा को पंक्तियों और कॉलमों में व्यवस्थित करता है, जैसे एक टेबल या मैट्रिक्स। यह एक-आयामी ऐरे का ही विस्तार है और इसे अक्सर 'ऐरे का ऐरे' कहा जाता है। 2D ऐरे को कंपाइल टाइम (प्रोग्राम लिखने के समय) और रन टाइम (प्रोग्राम चलने के समय) दोनों तरीकों से इनिशियलाइज़ किया जा सकता है।
कंपाइल टाइम इनिशियलाइज़ेशन:
जब एक ऐरे को डिक्लेयर करते समय ही उसे मान दिए जाते हैं, तो इसे कंपाइल टाइम इनिशियलाइज़ेशन कहते हैं। 2D ऐरे को इस प्रकार से इनिशियलाइज़ किया जा सकता है:
int table[2][3] = {
{0, 2, 5},
{1, 3, 0}
};
रन टाइम इनिशियलाइज़ेशन:
रन टाइम में 2D ऐरे को स्पष्ट रूप से मान देने के लिए लूप स्ट्रक्चर का उपयोग किया जा सकता है। इसमें दो लूप का उपयोग किया जाता है: एक आउटर लूप पंक्तियों के लिए और एक इनर लूप कॉलमों के लिए।
उदाहरण के लिए, निम्नलिखित C प्रोग्राम का एक खंड दिखाता है कि कैसे रन टाइम में 2D ऐरे को इनिशियलाइज़ किया जाता है:
for (i=0; i<3; i++) {
for (j=0; j<3; j++) {
scanf ("%d", &arl [i] [j]);
}
}
दो आयामी ऐरे, जैसे कि मैट्रिक्स, कंप्यूटर ग्राफिक्स, इमेज प्रोसेसिंग और गेम डेवलपमेंट में बहुत उपयोगी होते हैं।
In simple words: दो आयामी ऐरे एक टेबल जैसा होता है जिसमें जानकारी पंक्तियों और कॉलमों में रखी जाती है। हम इसे प्रोग्राम बनाते समय या प्रोग्राम चलते समय डेटा दे सकते हैं।

🎯 Exam Tip: 2D ऐरे को मैट्रिक्स या टेबल के रूप में सोचें। इसकी घोषणा और इनिशियलाइज़ेशन का सिंटैक्स \( type \,\, variable\_name[rows][columns]; \) याद रखें।

 

Question 2. विस्तार से Malloc फंक्शन को समझाओ।
Answer: `malloc()` फंक्शन डायनामिक मैमोरी एलोकेशन (dynamic memory allocation) के लिए उपयोग किया जाता है। इस फंक्शन का उपयोग करके हम रनटाइम पर मैमोरी का एक ब्लॉक (Block) बना सकते हैं और उसे किसी वेरिएबल को असाइन (allocate) कर सकते हैं। यह उन स्थितियों में उपयोगी होता है जहाँ हमें प्रोग्राम के चलने के दौरान ही मैमोरी की आवश्यकता होती है, जैसे कि जब ऐरे का आकार पहले से पता न हो।
जब हम डायनामिक मैमोरी एलोकेशन के लिए इस फंक्शन का उपयोग करते हैं, तब यह फंक्शन मैमोरी में किसी निश्चित डेटा टाइप के लिए एक मैमोरी ब्लॉक बनाता है और उस मैमोरी लोकेशन या इस `malloc()` फंक्शन द्वारा बनाए गए ब्लॉक स्पेस का एड्रेस (पता) वापस करता है। यह पता फिर एक पॉइंटर वेरिएबल में स्टोर किया जाता है।
इस एड्रेस को उसी डेटा टाइप प्रकार के पोइन्टर वेरिएबल में स्टोर किया जाता है और इस पोइन्टर का उपयोग करके आवश्यकतानुसार डेटा इनपुट किया जाता है। इस फंक्शन का सिंटैक्स निम्नानुसार होता है:
`ptr = (Data Type *) malloc (size of (Data type));`
यहाँ `Data Type *` का मतलब है कि `malloc` द्वारा लौटाए गए `void *` को वांछित डेटा टाइप के पॉइंटर में टाइपकास्ट किया जा रहा है। `size of (Data type)` यह बताता है कि कितने बाइट्स की मैमोरी चाहिए।
उदाहरण:
निम्नलिखित प्रोग्राम डायनेमिक मैमोरी अलोकेशन का फंक्शन के साथ उदाहरण है।
`#include<stdio.h>`
`#include<stdlib.h>`
`#include<string.h>`
`int main() {`
`char name [100];`
`char *description;`
`strcpy (name, "Zara Ali");`
`/* allocate memory dynamically*/`
`description=malloc (200*sizeof (char));`
`if (description==NULL) {`
`fprintf(stderr,''Error - unable to allocate required memory\n'');`
`}`
`else{`
`strcpy(description, ''Zara ali a DPS. student in class 10th'');`
`}`
`printf(''Name = %s\n'', name);`
`printf(''Description : %s\n", description);`
`}`
जब उपरोक्त कोड कंपाइल और रन होगा तो आउटपुट निम्नानुसार होगा:
`Name = Zara Ali`
`Description: Zara ali a DPS student in class 10th`
In simple words: `malloc()` एक फंक्शन है जो प्रोग्राम चलते समय कंप्यूटर की मैमोरी में जगह बनाता है। यह हमें उतनी जगह लेने देता है जितनी हमें जरूरत होती है, और उस जगह का पता हमें वापस देता है ताकि हम उसे इस्तेमाल कर सकें।

🎯 Exam Tip: `malloc()` को हमेशा `sizeof()` ऑपरेटर के साथ उपयोग करें ताकि सही मैमोरी एलोकेट हो, और `free()` का उपयोग करके मैमोरी को रिलीज़ करना न भूलें।

 

Question 3. रिकर्शन के लिए कौन-सा डेटा स्ट्रक्चर का उपयोग किया जाता है।
Answer: रिकर्शन (Recursion) के लिए स्टैक (Stack) डेटा स्ट्रक्चर का उपयोग किया जाता है। स्टैक LIFO (Last In First Out) के सिद्धांत पर काम करता है, जिसका मतलब है कि जो डेटा सबसे आखिर में जोड़ा जाता है, वह सबसे पहले निकाला जाता है। प्रत्येक बार जब कोई फंक्शन खुद को कॉल करता है, तो वर्तमान फंक्शन का स्टेट (स्थानीय वेरिएबल, पैरामीटर, रिटर्न एड्रेस) स्टैक पर पुश कर दिया जाता है।
स्टैक में किसी डेटा को एक ही सिरे से जोड़ा या घटाया जा सकता है। इस सिरे को टॉप ऑफ़ द स्टैक (TOS) कहा जाता है। इसलिए जब किसी स्टैक में डेटा को इनपुट किया जाता है, तो सबसे पहले इनपुट किया गया डेटा सबसे बाद में प्राप्त होता है, और सबसे बाद में इनपुट किया गया डेटा सबसे पहले प्राप्त होता है। स्टैक का उपयोग कॉल स्टैक के रूप में होता है जहाँ रिकर्सिव फंक्शन की हर कॉल का रिकॉर्ड रखा जाता है।
उदाहरण:
मान लीजिए 10 किताबें एक के ऊपर एक रखी हैं। अब यदि हम किसी किताब को पढ़ना चाहें तो सबसे पहले हमें वो किताब उठानी पड़ती है, जिसे सबसे बाद में रखा था और सबसे पहले रखी गई किताब का उपयोग हम बाद में कर सकते हैं। यही स्टैक की अवधारणा है।
In simple words: रिकर्शन (जब कोई फंक्शन खुद को बार-बार बुलाता है) के लिए कंप्यूटर 'स्टैक' नाम के एक डेटा स्ट्रक्चर का इस्तेमाल करता है। यह स्टैक एक के ऊपर एक रखी किताबों जैसा होता है, जिसमें जो किताब सबसे आखिर में रखी जाती है, वही सबसे पहले उठाई जाती है।

🎯 Exam Tip: रिकर्शन को हमेशा 'स्टैक' डेटा स्ट्रक्चर से जोड़कर याद रखें, क्योंकि प्रत्येक फंक्शन कॉल और उसके लोकल वेरिएबल्स स्टैक पर पुश होते हैं।

 

Question 4. बाइनरी सर्च, लीनियर सर्च से क्यों बेहतर है?
Answer: लीनियर सर्च और बाइनरी सर्च दोनों ही डेटा खोजने के एल्गोरिदम हैं, लेकिन उनकी कार्यप्रणाली और दक्षता अलग-अलग होती है।
लीनियर सर्च:
लीनियर सर्च एक बुनियादी और सरल सर्च एल्गोरिथम है। लीनियर सर्च में यह हर एक तत्व की तुलना सर्च किए गए मान से तब तक करता है जब तक वह मान मिल नहीं जाता। यह ऐरे में उपलब्ध सभी तत्वों से तुलना करता है और मिलान होने पर ऐरे इंडेक्स का मान प्राप्त करता है। यदि तत्व नहीं मिलता है, तो -1 रिटर्न करता है। लीनियर सर्च सॉर्टेड और अनसॉर्टेड दोनों तरह के मानों पर लागू होती है, लेकिन यह तब बेहतर काम करती है जब तत्वों की संख्या कम हो।
बाइनरी सर्च:
बाइनरी सर्च सॉर्टेड ऐरे या लिस्ट पर लागू होता है। इसमें सबसे पहले हम दिए गए तत्व की ऐरे के बीच के तत्व से तुलना करते हैं। यदि तत्व का मान मिलान हो जाता है तो ऐरे का इंडेक्स मान रिटर्न करता है। यदि तत्व का मान बीच के मान से कम है तो निचले आधे हिस्से में खोज जारी रहती है, अन्यथा ऊपरी आधे हिस्से में खोज होती है। बाइनरी सर्च का उपयोग तब किया जाता है जब तत्वों की संख्या अधिक हो, क्योंकि यह बहुत तेज होता है।
बाइनरी सर्च, लीनियर सर्च से बेहतर है क्योंकि यह \( O(\log n) \) की समय जटिलता के साथ बहुत बड़े डेटासेट में भी तेजी से तत्व ढूंढ सकता है, जबकि लीनियर सर्च की जटिलता \( O(n) \) है, जो बड़े डेटा के लिए धीमी हो जाती है। यह डेटा को आधी-आधी करके सर्च करता है, जिससे समय की बचत होती है।
In simple words: बाइनरी सर्च लीनियर सर्च से बेहतर है क्योंकि यह केवल सॉर्टेड डेटा पर काम करता है और डेटा को हर बार आधा करके खोजता है, जिससे यह बड़े डेटा में बहुत तेजी से काम करता है। लीनियर सर्च हर एक आइटम को चेक करता है, इसलिए यह बड़े डेटा के लिए धीमा होता है।

🎯 Exam Tip: बाइनरी सर्च की मुख्य विशेषता उसकी \( O(\log n) \) जटिलता और सॉर्टेड डेटा पर काम करने की आवश्यकता है, जो इसे लीनियर सर्च से कहीं अधिक कुशल बनाती है।

 

Question 2. एकल या एक आयामी ऐरे क्या होता है?
Answer: एकल या एक आयामी ऐरे (single or one-dimensional array) एक डेटा स्ट्रक्चर है जो एक ही प्रकार के कई आइटमों को एक ही नाम के तहत स्टोर करता है। इन आइटमों को एक ही सूची में रखा जाता है, और प्रत्येक आइटम को उसके इंडेक्स (यानी, उसकी स्थिति) का उपयोग करके एक्सेस किया जा सकता है। इसे 'सिंगल सब्सक्रिप्टेड वेरिएबल' भी कहा जाता है क्योंकि इसमें आइटमों को संदर्भित करने के लिए केवल एक सब्सक्रिप्ट (इंडेक्स) का उपयोग होता है।
उदाहरण के लिए, यदि हम छात्रों के रोल नंबर का एक ऐरे बनाना चाहते हैं, तो हम उसे `int roll_numbers[50];` के रूप में घोषित कर सकते हैं, जहाँ `roll_numbers[0]` पहले छात्र का रोल नंबर होगा, और इसी तरह। यह ऐरे एक प्रकार के डेटा को एक साथ स्टोर करने का एक सरल और कुशल तरीका है।
In simple words: एक आयामी ऐरे एक लिस्ट जैसा होता है जहाँ एक ही तरह की कई चीजें एक ही नाम से रखी जाती हैं। हर चीज को उसकी जगह के नंबर (इंडेक्स) से ढूंढा जा सकता है।

🎯 Exam Tip: एक-आयामी ऐरे को डेटा की एक 'लिस्ट' या 'पंक्ति' के रूप में समझें, जिसमें प्रत्येक तत्व को उसके 'इंडेक्स' (0 से शुरू होकर) द्वारा एक्सेस किया जाता है।

 

Question 3. एक आयामी ऐरे को किस प्रकार डिक्लेयर किया जाता है? उदाहरण सहित बताइए।
Answer: एक आयामी ऐरे को कंप्यूटर प्रोग्रामिंग में उपयोग करने से पहले उसे डिक्लेयर करना पड़ता है, ताकि कंपाइलर को पता चल सके कि उसे कितनी मैमोरी की आवश्यकता होगी और वह किस प्रकार का डेटा स्टोर करेगा। एक आयामी ऐरे को निम्न प्रकार डिक्लेयर किया जाता है:
`type variable-name[size];`
यहाँ:
• `type`: ऐरे में स्टोर किए जाने वाले तत्वों का डेटा प्रकार (जैसे `int`, `float`, `char`)।
• `variable-name`: ऐरे का नाम, जिसका उपयोग इसे संदर्भित करने के लिए किया जाएगा।
• `size`: ऐरे में स्टोर किए जा सकने वाले तत्वों की कुल संख्या। यह हमेशा एक पॉजिटिव पूर्णांक होना चाहिए।
उदाहरण:
`char name[10];` // 10 अक्षरों को स्टोर करने के लिए एक कैरेक्टर ऐरे
`int marks[5];` // 5 पूर्णांकों को स्टोर करने के लिए एक पूर्णांक ऐरे
`float height[20];` // 20 फ्लोटिंग-पॉइंट संख्याओं को स्टोर करने के लिए एक फ्लोट ऐरे
ऐरे को डिक्लेयर करने से मैमोरी में उसके लिए आवश्यक जगह आरक्षित हो जाती है, जिससे प्रोग्राम डेटा को स्टोर और एक्सेस कर सके।
In simple words: एक आयामी ऐरे को बनाने के लिए, हमें बताना पड़ता है कि हम किस तरह की जानकारी (जैसे नंबर या अक्षर) स्टोर करेंगे और कितनी चीजें स्टोर करेंगे। जैसे `int ages[10];` का मतलब है कि हम 10 लोगों की उम्र नंबरों में स्टोर करेंगे।

🎯 Exam Tip: ऐरे की घोषणा में डेटा टाइप, नाम और आकार तीनों स्पष्ट रूप से बताएं, जैसे `int arr[10];` जिसका अर्थ है 10 पूर्णांक तत्वों का ऐरे।

 

Question 4. ऐरे को उपयोग करने से पहले डिक्लेयर करना क्यों आवश्यक है?
Answer: ऐरे को उपयोग करने से पहले डिक्लेयर करना बहुत जरूरी है ताकि कंपाइलर (जो प्रोग्राम को कंप्यूटर की भाषा में बदलता है) को यह पता चल सके कि उसे मैमोरी में कितनी जगह आरक्षित करनी है। जब आप एक ऐरे डिक्लेयर करते हैं, तो आप उसका डेटा प्रकार (जैसे पूर्णांक, फ्लोट, कैरेक्टर) और उसका आकार (कितने तत्व वह स्टोर कर सकता है) बताते हैं।
यह जानकारी कंपाइलर को मैमोरी एलोकेशन और डेटा एक्सेस के लिए आवश्यक होती है। यदि आप ऐरे को डिक्लेयर नहीं करते हैं, तो कंपाइलर को यह नहीं पता चलेगा कि डेटा को कहाँ स्टोर करना है और उसे कितनी मैमोरी चाहिए, जिससे प्रोग्राम में एरर आ सकती है। यह सुनिश्चित करता है कि प्रोग्राम सुचारु रूप से चले और मैमोरी को ठीक से प्रबंधित किया जा सके।
In simple words: ऐरे को पहले डिक्लेयर करना जरूरी है ताकि कंप्यूटर को पता चले कि उसे कितनी मैमोरी चाहिए और किस तरह की जानकारी रखनी है। बिना बताए, कंप्यूटर को पता ही नहीं चलेगा कि क्या करना है।

🎯 Exam Tip: ऐरे को डिक्लेयर करना अनिवार्य है क्योंकि यह कंपाइलर को मैमोरी में आवश्यक स्थान आरक्षित करने की अनुमति देता है, जिससे प्रोग्राम कुशलतापूर्वक डेटा को स्टोर और एक्सेस कर सके।

 

Question 5. बहुआयामी ऐरे से आप क्या समझते है?
Answer: बहुआयामी ऐरे (multidimensional array) एक ऐसा ऐरे है जिसमें एक से अधिक इंडेक्स (या सब्सक्रिप्ट) होते हैं। इसे 'ऐरे का ऐरे' भी कहा जाता है। सबसे आम बहुआयामी ऐरे दो-आयामी (2D) ऐरे होते हैं, जिन्हें मैट्रिक्स या टेबल के रूप में सोचा जा सकता है, जिसमें डेटा पंक्तियों और कॉलमों में व्यवस्थित होता है।
हालांकि, ऐरे तीन या उससे अधिक आयामों के भी हो सकते हैं। बहुआयामी ऐरे का उपयोग अक्सर ऐसे डेटा को स्टोर करने के लिए किया जाता है जिसकी संरचना में एक से अधिक गुण होते हैं, जैसे कि इमेज के पिक्सल, ग्राफिक्स में 3D पॉइंट, या डेटाबेस में टेबल। यह डेटा को एक संगठित और संरचित तरीके से प्रस्तुत करने में मदद करता है।
In simple words: बहुआयामी ऐरे एक खास तरह का ऐरे है जिसमें डेटा को एक से ज्यादा लाइनों और कॉलमों में रखा जाता है, जैसे एक बड़ी टेबल या कई टेबलों का समूह।

🎯 Exam Tip: बहुआयामी ऐरे को एक 'मैट्रिक्स' या 'टेबल' के रूप में सोचें, जिसमें डेटा को पंक्तियों और कॉलमों का उपयोग करके व्यवस्थित किया जाता है।

 

Question 6. बहु आयामी ऐरे की घोषणा किस प्रकार की जाती है? उदाहरण भी दीजिए।
Answer: बहु आयामी ऐरे की घोषणा करने के लिए, हमें डेटा प्रकार, ऐरे का नाम, और प्रत्येक आयाम के लिए उसका आकार बताना पड़ता है। यह कंपाइलर को यह समझने में मदद करता है कि कितनी मैमोरी आरक्षित करनी है और डेटा को कैसे व्यवस्थित करना है। सामान्य रूप से बहु आयामी ऐरे की घोषणा निम्न प्रकार से होती है:
`type variable-name [size1] [size2]..... [sizeN];`
यहाँ:
• `type`: ऐरे में स्टोर किए जाने वाले तत्वों का डेटा प्रकार।
• `variable-name`: ऐरे का नाम।
• `size1, size2,..., sizeN`: प्रत्येक आयाम के लिए तत्वों की संख्या।
उदाहरण:
`int x [3][4];`
यह एक दो-आयामी (2D) पूर्णांक ऐरे 'x' की घोषणा करता है जिसमें 3 पंक्तियाँ और 4 कॉलम होते हैं, यानी कुल \( 3 \times 4 = 12 \) पूर्णांक तत्वों को स्टोर किया जा सकता है। बहु आयामी ऐरे का उपयोग अक्सर जटिल डेटा संरचनाओं जैसे ग्राफिक्स या मैट्रिक्स को हैंडल करने के लिए किया जाता है।
In simple words: बहुआयामी ऐरे को बनाने के लिए, हमें यह बताना होता है कि उसमें किस तरह के नंबर या अक्षर होंगे, उसका क्या नाम होगा, और उसमें कितनी पंक्तियाँ और कॉलम होंगे। जैसे `int grid[3][4];` का मतलब 3 पंक्तियों और 4 कॉलमों वाला नंबरों का एक ग्रिड।

🎯 Exam Tip: बहु-आयामी ऐरे की घोषणा में प्रत्येक आयाम के लिए उसका आकार बताना महत्वपूर्ण है, जैसे `int matrix[R][C];`।

 

Question 8. सर्च से आप क्या समझते हैं? एक लीनियर ऐरे में सर्च कितने प्रकार की होती है?
Answer: सर्च (Search) का मतलब है एक डेटा स्ट्रक्चर में किसी खास डेटा तत्व (element) को खोजना। यह कंप्यूटर विज्ञान में एक बहुत ही सामान्य ऑपरेशन है, जिसका उपयोग डेटाबेस, फ़ाइलों या किसी भी डेटा कलेक्शन से जानकारी निकालने के लिए किया जाता है।
एक लीनियर ऐरे (linear array) में सर्च मुख्य रूप से दो प्रकार की होती है:
• लीनियर सर्च (Linear Search): इसमें ऐरे के हर तत्व को एक-एक करके तब तक चेक किया जाता है जब तक कि वांछित तत्व मिल न जाए या ऐरे खत्म न हो जाए। यह सबसे सरल सर्चिंग विधि है और सॉर्टेड या अनसॉर्टेड दोनों तरह के ऐरे पर काम करती है।
• बाइनरी सर्च (Binary Search): यह विधि केवल सॉर्टेड (क्रमबद्ध) ऐरे पर काम करती है। इसमें ऐरे को बार-बार दो हिस्सों में बांटा जाता है और सर्च को उस हिस्से में केंद्रित किया जाता है जहाँ वांछित तत्व होने की संभावना होती है। यह लीनियर सर्च से बहुत तेज होती है, खासकर बड़े ऐरे के लिए।
ये दोनों विधियाँ डेटा खोजने के अलग-अलग तरीके प्रदान करती हैं, जिनकी दक्षता और उपयोग की शर्तें अलग-अलग होती हैं।
In simple words: सर्च का मतलब है डेटा में कोई खास चीज ढूंढना। एक सीधी लाइन वाले ऐरे में, इसे ढूंढने के दो मुख्य तरीके हैं: लीनियर सर्च (एक-एक करके सब देखना) और बाइनरी सर्च (आधे-आधे करके देखना, लेकिन इसमें लिस्ट क्रम में होनी चाहिए)।

🎯 Exam Tip: सर्चिंग का मुख्य उद्देश्य डेटा सेट से एक विशिष्ट तत्व को पुनः प्राप्त करना है। लीनियर ऐरे के लिए, 'लीनियर सर्च' और 'बाइनरी सर्च' दो मुख्य विधियाँ हैं, जिनमें से बाइनरी सर्च सॉर्टेड डेटा के लिए अधिक कुशल है।

 

Question 9. पोइन्टर क्या होता है?
Answer: पोइन्टर (Pointer) एक ऐसा वेरिएबल है जिसका मान किसी अन्य वेरिएबल का मैमोरी एड्रेस (memory address) होता है। सरल शब्दों में, यह एक ऐसा वेरिएबल है जो किसी और वेरिएबल की जगह का पता बताता है, न कि उसकी वैल्यू। पोइन्टर का उपयोग करके, प्रोग्रामर सीधे मैमोरी लोकेशन को एक्सेस और मॉडिफाई कर सकते हैं। यह डायनामिक मैमोरी एलोकेशन, डेटा स्ट्रक्चर (जैसे लिंकड लिस्ट और ट्री), और फंक्शन में आर्गुमेंट पास करने में बहुत उपयोगी होता है।
In simple words: पोइन्टर एक खास वेरिएबल होता है जो किसी और वेरिएबल की मैमोरी में जगह का पता बताता है, उसकी असली वैल्यू नहीं। यह हमें कंप्यूटर की मैमोरी के साथ सीधा काम करने में मदद करता है।

🎯 Exam Tip: पोइन्टर का सबसे महत्वपूर्ण उपयोग मैमोरी एड्रेस को स्टोर करना है, न कि डेटा वैल्यू को। इसे `*` ऑपरेटर के साथ घोषित किया जाता है।

 

Question 10. क्या पोइन्टर को उपयोग करने से पहले डिक्लेयर करना आवश्यक है?
Answer: हाँ, किसी भी अन्य वेरिएबल और कॉन्स्टेन्ट (constant) की तरह, पोइन्टर को भी उपयोग करने से पहले डिक्लेयर करना बहुत आवश्यक है। पोइन्टर को डिक्लेयर करने से कंपाइलर को यह पता चलता है कि यह वेरिएबल मैमोरी एड्रेस स्टोर करने वाला है और यह किस डेटा टाइप के वेरिएबल के एड्रेस को स्टोर करेगा।
यदि पोइन्टर को डिक्लेयर नहीं किया जाता है, तो कंपाइलर को पता नहीं चलेगा कि यह एक पोइन्टर है, और इससे प्रोग्राम में एरर आ सकती है या अप्रत्याशित व्यवहार हो सकता है। पोइन्टर डिक्लेरेशन का साधारण रूप निम्नानुसार है:
`type * var-name;`
जहाँ `type` वह डेटा प्रकार है जिसके वेरिएबल का एड्रेस पोइन्टर स्टोर करेगा, और `*` इंगित करता है कि `var-name` एक पोइन्टर वेरिएबल है। यह सही मैमोरी प्रबंधन और सुरक्षित प्रोग्रामिंग के लिए एक महत्वपूर्ण कदम है।
In simple words: हाँ, पोइन्टर को इस्तेमाल करने से पहले उसे बनाना (डिक्लेयर करना) बहुत जरूरी है। ऐसा करने से कंप्यूटर को पता चलता है कि यह एक खास तरह का वेरिएबल है जो मैमोरी का पता रखेगा।

🎯 Exam Tip: किसी भी वेरिएबल की तरह, पोइन्टर को भी उपयोग से पहले डिक्लेयर करना अनिवार्य है ताकि कंपाइलर उसके टाइप और उद्देश्य को समझ सके।

 

Question 11. NULL पोइन्टर किसे कहते है?
Answer: NULL पोइन्टर एक ऐसा पोइन्टर वेरिएबल होता है जिसे NULL वैल्यू असाइन की गई है। NULL एक विशेष मान है जिसका मतलब है कि पोइन्टर किसी भी वैध मैमोरी लोकेशन को पॉइंट नहीं कर रहा है। दूसरे शब्दों में, NULL पोइन्टर किसी भी वैध ऑब्जेक्ट या फंक्शन से जुड़ा नहीं होता है।
NULL पोइन्टर का उपयोग अक्सर प्रोग्रामिंग में यह इंगित करने के लिए किया जाता है कि एक पोइन्टर अभी तक किसी मैमोरी को असाइन नहीं किया गया है, या किसी ऑपरेशन के दौरान कोई एरर हुई है जिसके कारण पोइन्टर को कोई वैध पता नहीं मिल पाया। यह प्रोग्राम को क्रैश होने से बचाने में मदद करता है जब कोई पोइन्टर गलती से किसी अमान्य मैमोरी लोकेशन को एक्सेस करने की कोशिश करता है।
In simple words: NULL पोइन्टर एक खास तरह का पोइन्टर होता है जिसे कोई मैमोरी एड्रेस नहीं दिया गया होता। यह बस बताता है कि पोइन्टर अभी खाली है, किसी जगह को पॉइंट नहीं कर रहा है।

🎯 Exam Tip: NULL पोइन्टर को 'किसी वैध मैमोरी एड्रेस को पॉइंट न करने वाले पोइन्टर' के रूप में याद रखें, यह एरर हैंडलिंग में महत्वपूर्ण है।

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

 

Question 1. एकल या एक आयामी ऐरे पर संक्षिप्त टिप्पणी लिखिए।
Answer: एकल या एक आयामी ऐरे (Single or One-Dimensional Array) एक ऐसा डेटा स्ट्रक्चर है जो एक ही प्रकार के कई डेटा आइटमों को एक ही नाम के तहत एक क्रम में स्टोर करता है। इन आइटमों को एक सूची के रूप में देखा जा सकता है। प्रत्येक आइटम को उसके इंडेक्स (या सब्सक्रिप्ट) का उपयोग करके एक्सेस किया जाता है, जो 0 से शुरू होता है।
इसे 'एकल सब्सक्रिप्टेड वेरिएबल' भी कहा जाता है क्योंकि इसमें केवल एक इंडेक्स का उपयोग करके तत्वों तक पहुँचा जा सकता है। उदाहरण के लिए, `int numbers[10];` एक ऐरे है जो 10 पूर्णांकों को स्टोर कर सकता है, जहाँ `numbers[0]` पहला तत्व और `numbers[9]` आखिरी तत्व होगा। ऐरे को उपयोग करने से पहले डिक्लेयर करना आवश्यक है ताकि कंपाइलर उसके लिए मैमोरी में जगह आरक्षित कर सके। यह डेटा को व्यवस्थित और कुशलता से प्रबंधित करने का एक सरल तरीका है।
In simple words: एक आयामी ऐरे एक सीधी लिस्ट जैसा होता है जहाँ एक ही तरह की कई चीजें एक ही नाम के नीचे रखी होती हैं। हम हर चीज को उसके क्रम संख्या (इंडेक्स) से ढूंढ सकते हैं।

🎯 Exam Tip: एक-आयामी ऐरे डेटा की एक सीधी सूची है, जिसे इंडेक्स का उपयोग करके एक्सेस किया जाता है। इसकी घोषणा में डेटा प्रकार, नाम और आकार शामिल होते हैं।

 

Question 2. सी प्रोग्रामिंग में एक ऐरे के प्रारम्भ होने के विभिन्न चरण लिखिए। अथवा एकल या एक आयामी ऐरे के प्रारम्भ के विषय में बताइए।
Answer: सी प्रोग्रामिंग में एक ऐरे के प्रारम्भ होने (Initialization) का मतलब है कि जब आप एक ऐरे बनाते हैं, तो उसे कुछ शुरुआती मान (values) देना। एक ऐरे को डिक्लेयर करने के बाद, उसके तत्वों को मान दिए जा सकते हैं। एकल या एक आयामी ऐरे को दो मुख्य चरणों में प्रारम्भ किया जा सकता है:
1. कंपाइल टाइम प्रारम्भ (Compile-Time Initialization):
जब एक ऐरे को डिक्लेयर करते समय ही उसे मान दिए जाते हैं, तो इसे कंपाइल टाइम प्रारम्भ कहते हैं। यह प्रोग्राम के कंपाइल होने के समय होता है।
`type array-name [size] = {list of values};`
लिस्ट में मानों को कोमा से अलग किया जाता है।
उदाहरण:
`int number [3] = {0, 5, 4};`
ऊपर दिए गए स्टेटमेंट में 3 आकार का एक `number` नाम का ऐरे है और हर तत्व को वैल्यू आवंटित होगी (`number[0]=0, number[1]=5, number[2]=4`)। यदि लिस्ट में वैल्यू की संख्या ऐरे के साइज़ की तुलना में कम है, तो यह केवल कुछ ऐरे तत्वों को वैल्यू आवंटित करेगा, और बाकी तत्वों को स्वचालित रूप से शून्य आवंटित हो जाएगा। ध्यान रखने वाली बात है कि यदि घोषित आकार की तुलना में अधिक वैल्यू दी जाती हैं, तो एक त्रुटि (error) उत्पन्न होगी।
2. रन टाइम प्रारम्भ (Run-Time Initialization):
एक ऐरे को स्पष्ट रूप से चलाने के लिए रन टाइम आरम्भ किया जा सकता है। यह प्रोग्राम के चलने के दौरान होता है, अक्सर उपयोगकर्ता से इनपुट लेकर या गणनाओं के आधार पर। उदाहरण के लिए, निम्नलिखित C प्रोग्राम का खंड रन टाइम पर एक ऐरे को प्रारम्भ करने का तरीका दिखाता है:
`for (i = 0; i < 10; i++) {`
`scanf("%d", &x [i]);`
`}`
इस प्रकार, हम प्रोग्राम की आवश्यकता के अनुसार ऐरे को लचीले ढंग से मान दे सकते हैं।
In simple words: ऐरे को शुरू करने का मतलब है कि उसे बनाते समय या बाद में उसे कुछ मान देना। हम उसे प्रोग्राम लिखते समय (कंपाइल टाइम) या प्रोग्राम चलते समय (रन टाइम) मान दे सकते हैं, जैसे उपयोगकर्ता से इनपुट लेकर।

🎯 Exam Tip: ऐरे इनिशियलाइज़ेशन के दो मुख्य तरीके कंपाइल-टाइम (घोषणा के साथ) और रन-टाइम (लूप या इनपुट से) हैं; दोनों ही तरीके ऐरे को उपयोग के लिए तैयार करते हैं।

 

Question 4. सी प्रोग्राम में एक बहुआयामी ऐरे के प्रारम्भ होने के विभिन्न चरण लिखिए।
Answer: सी प्रोग्रामिंग में एक बहुआयामी ऐरे (Multidimensional Array) को प्रारम्भ करने का मतलब है कि उसे बनाते समय या प्रोग्राम चलते समय उसे शुरुआती मान (values) देना। बहुआयामी ऐरे को प्रारम्भ करने के भी दो मुख्य चरण होते हैं:
1. कंपाइल टाइम प्रारम्भ (Compile-Time Initialization):
जब एक बहुआयामी ऐरे को डिक्लेयर करते समय ही उसे मान दिए जाते हैं, तो इसे कंपाइल टाइम प्रारम्भ कहते हैं। इसमें मानों को कर्ली ब्रेसेज़ (`{}`) के अंदर पंक्ति-दर-पंक्ति दिया जाता है।
`int table[2][3] = {`
`{0, 2, 5},`
`{1, 3, 0}`
`};`
यहाँ, `table` नाम का 2x3 का एक ऐरे डिक्लेयर और इनिशियलाइज़ किया गया है। हर कर्ली ब्रेसेज़ के अंदर एक पंक्ति के मान होते हैं।
2. रन टाइम प्रारम्भ (Run-Time Initialization):
रन टाइम में बहुआयामी ऐरे को स्पष्ट रूप से मान देने के लिए लूप स्ट्रक्चर का उपयोग किया जा सकता है। इसमें आमतौर पर नेस्टेड लूप (nested loops) का उपयोग किया जाता है: एक आउटर लूप पंक्तियों (rows) के लिए और एक इनर लूप कॉलमों (columns) के लिए। यह उपयोगकर्ता से इनपुट लेने या प्रोग्राम में गणनाओं के आधार पर मान असाइन करने के लिए उपयोगी है।
उदाहरण के लिए, निम्नलिखित C प्रोग्राम का खंड दिखाता है कि कैसे रन टाइम में एक 2D ऐरे को इनिशियलाइज़ किया जाता है:
`for (i=0; i<3; i++) {`
`for (j=0; j<3; j++) {`
`scanf("%d",&arl [i][j]);`
`}`
`}`
यह तरीका प्रोग्राम को लचीलापन प्रदान करता है, जिससे वह विभिन्न इनपुट या शर्तों के आधार पर ऐरे को डायनामिक रूप से भर सके।
In simple words: बहुआयामी ऐरे को शुरू करने के दो तरीके हैं: पहला, प्रोग्राम लिखते समय (कंपाइल टाइम) ही उसे मान देना, जैसे एक टेबल बनाते समय। दूसरा, प्रोग्राम चलते समय (रन टाइम) लूप का उपयोग करके मान भरना, जैसे उपयोगकर्ता से डेटा लेना।

🎯 Exam Tip: बहु-आयामी ऐरे के इनिशियलाइज़ेशन के लिए कंपाइल-टाइम में नेस्टेड ब्रेसेस का उपयोग करें और रन-टाइम में नेस्टेड लूप्स का उपयोग करें।

 

Question 5. एक 2 डी ऐरे का प्रोग्राम लिखिए।
Answer: यहाँ एक C प्रोग्राम है जो एक 2D ऐरे को इनिशियलाइज़ करता है और उसके तत्वों को प्रिंट करता है:
`/* 2-डी ऐरे का सी प्रोग्राम */`
`#include <stdio.h>`
`#include <conio.h>`
`void main() {`
`int array[3][3], i, j, count = 0;`
`/* Run time Initialization */`
`for (i=1; i<=3; i++) {`
`for (j=1; j<=3; j++) {`
`count++;`
`array[i][j] = count;`
`printf("%d ", array[i][j]);`
`}`
`printf("\n");`
`}`
`getch();`
`}`
इस प्रोग्राम में, एक 3x3 का ऐरे `array` डिक्लेयर किया गया है। नेस्टेड लूप्स का उपयोग करके, यह ऐरे को 1 से 9 तक के मानों से भरता है और हर मान को भरते ही प्रिंट भी करता जाता है। `getch()` फंक्शन आउटपुट स्क्रीन को रोके रखता है ताकि यूजर आउटपुट देख सके। यह प्रोग्राम 2D ऐरे को इनिशियलाइज़ करने और उसके कंटेंट को प्रदर्शित करने का एक सीधा तरीका है।
जब उपरोक्त कोड कंपाइल और रन होगा तो आउटपुट निम्नानुसार होगा:
`1 2 3`
`4 5 6`
`7 8 9`
In simple words: यह C प्रोग्राम एक 3x3 टेबल बनाता है। यह उसमें 1 से 9 तक नंबर भरता है और फिर उन नंबरों को टेबल के रूप में दिखाता है।

🎯 Exam Tip: 2D ऐरे को इनिशियलाइज़ और प्रिंट करने के लिए हमेशा नेस्टेड लूप्स का उपयोग करें, जिसमें आउटर लूप पंक्तियों और इनर लूप कॉलमों को हैंडल करे।

 

Question 6. एकल आयामी ऐरे में पता की गणना का सूत्र बताइए।
Answer: एकल (एक) आयामी ऐरे में पता गणना के लिए, हमें आधार पता (Base Address) और प्रत्येक तत्व द्वारा ली गई मेमोरी की चौड़ाई (Width) की आवश्यकता होती है। यह समझने के लिए कि एरे तत्व मेमोरी में कैसे व्यवस्थित होते हैं, एक उदाहरण तालिका नीचे दी गई है। यह एक महत्वपूर्ण अवधारणा है जो बताती है कि डेटा मेमोरी में कैसे संग्रहीत होता है।

Answer: (Continued)
यहाँ, ऐरे के पहले तत्व का वास्तविक पता (आधार पता) 1100 है, और प्रत्येक तत्व 4 बाइट्स मेमोरी लेता है। एक ऐरे A[I] के एक तत्व का पता ज्ञात करने के लिए निम्न सूत्र का उपयोग किया जाता है:
Address of A[I] = B + W * (I - LB)
जहाँ,
B = आधार पता (Base Address) - यह एरे के पहले तत्व का पता है।
W = ऐरे में उपस्थित एक तत्व की स्टोरेज साइज (बाइट में) - यह बताता है कि प्रत्येक तत्व कितनी मेमोरी लेता है।
I = जिस तत्व का पता ज्ञात करना है उसका सबस्क्रिप्ट
LB = निचली सीमा/उपलब्ध नहीं होने पर शून्य माने 0 (शून्य) - यह एरे का शुरुआती इंडेक्स है।
In simple words: एक एरे में किसी भी आइटम का पता जानने के लिए, हमें यह जानना होगा कि एरे कहाँ से शुरू होता है (बेस एड्रेस), हर आइटम कितनी जगह लेता है (चौड़ाई), और हम किस आइटम को ढूंढ रहे हैं (सबस्क्रिप्ट)। यदि निचली सीमा 0 है, तो यह गणना सीधी हो जाती है।

🎯 Exam Tip: इस सूत्र में 'LB' का मान अक्सर 0 होता है, खासकर C/C++ जैसी भाषाओं में जहाँ एरे इंडेक्स 0 से शुरू होते हैं। जब तक अन्यथा न बताया जाए, इसे 0 मानें।

 

Question 7. ऐरे पर कौन-कौन से ऑपरेशन किये जा सकते हैं? अथवा ऐरे पर होने वाले कुछ बुनियादी ऑपरेशन के विषय में बताइए।
Answer: ऐरे पर कई महत्वपूर्ण ऑपरेशन (कार्य) किए जा सकते हैं जो डेटा को व्यवस्थित और प्रबंधित करने में मदद करते हैं। इन बुनियादी ऑपरेशनों में ट्रैवर्सिंग (सभी तत्वों पर जाना), इन्सर्शन (एक नया तत्व जोड़ना), और डिलिशन (एक मौजूदा तत्व हटाना) शामिल हैं। ये ऑपरेशन प्रोग्रामिंग में एरे के साथ काम करने के लिए नींव बनाते हैं।

Answer: (Continued)
(i) ट्रैवर्सिंग (Traversing): ट्रैवर्सिंग का अर्थ है एक डेटा स्ट्रक्चर में मौजूद सभी डेटा तत्वों को एक-एक करके एक्सेस करना (प्रोसेसिंग)। निम्नलिखित एल्गोरिथ्म का उपयोग करके लीनियर ऐरे को ट्रैवर्स किया जा सकता है:
1. Repeat For I = LB to UB (एरे की निचली सीमा से ऊपरी सीमा तक दोहराएं)
2. Apply PROCESS to A[I] (एरे के प्रत्येक तत्व A[I] पर कोई प्रक्रिया लागू करें)
[End of For Loop] (लूप समाप्त करें)
3. Exit (बाहर निकलें)

Answer: (Continued)
(ii) इन्सर्शन (Insertion): इन्सर्शन का अर्थ है एक डेटा स्ट्रक्चर में एक नया डेटा तत्व जोड़ना। निम्नलिखित एल्गोरिथ्म का उपयोग करके लीनियर ऐरे में एक तत्व इन्सर्ट किया जा सकता है:
Algorithm: Let LA be a Linear Array (unordered) with N elements and K is a positive integer such that \( N/LK \le N \). Following is the algorithm where ITEM is inserted into the Kth position of LA
1. Start (शुरू करें)
2. Set J = N (J को एरे के वर्तमान आकार N के बराबर सेट करें)
3. Set N = N + 1 (एरे का आकार एक से बढ़ाएँ)
4. Repeat steps 5 and 6 while \( J \ge K \) (जब तक J, K से बड़ा या बराबर है, तब तक स्टेप 5 और 6 दोहराएं)
5. Set LA[J+1] = LA[J] (वर्तमान तत्व को एक स्थान आगे खिसकाएँ)
6. Set J = J - 1 (J को एक से घटाएँ)
7. Set LA[K] = ITEM (नए आइटम को वांछित Kवीं स्थिति पर रखें)
8. Stop (रोकें)

Answer: (Continued)
(iii) डिलिशन (Deletion): डिलिशन का अर्थ है एक डेटा स्ट्रक्चर में एक डेटा तत्व को हटाना यदि वह मौजूद है। निम्नलिखित एल्गोरिथ्म का उपयोग करके लीनियर ऐरे के तत्वों को डिलीट कर सकते हैं:
Algorithm: Consider LA is a linear array with N elements and K is a positive integer such that \( K \le N \). Following is the algorithm to delete an element available at the Kth position of LA.
1. Start (शुरू करें)
2. Repeat for \( J = K \) to \( N-1 \) (J को K से \( N-1 \) तक दोहराएं)
3. Set LA[J] = LA[J+1] (अगले तत्व को वर्तमान स्थिति में ले आएं, जिससे पुराना तत्व हट जाए)
[End of For Loop] (लूप समाप्त करें)
4. Set N = N - 1 (एरे का आकार एक से घटाएँ)
5. Stop (रोकें)

Answer: (Continued)
डिलीशन ऑपरेशन का एक C प्रोग्राम उदाहरण यहाँ दिया गया है:
#include <stdio.h>
main() {
int LA[] = {1, 3, 5, 7, 8};
int K = 3, n = 5;
int i, j;
printf("The original array elements are : \\n");
for (i = 0; i < n; i++) {
printf("LA[%d] = %d \\n", i, LA[i]);
}
j = K;
while (j < n) {
LA[j - 1] = LA[j];
j = j + 1;
}
n = n - 1;
printf("The array elements after deletion: \\n");
for (i = 0; i < n; i++) {
printf("LA [%d] = %d \\n", i, LA[i]);
}
}
इस कोड को चलाने पर निम्न आउटपुट मिलेगा:
The original array elements are:
LA[0]=1
LA[1]=3
LA[2]=5
LA[3]=7
LA[4]=8
The array elements after deletion:
LA[0]=1
LA[1]=3
LA[2]=7
LA[3]=8
In simple words: एरे पर मुख्य काम डेटा को देखना (ट्रैवर्सिंग), नया डेटा डालना (इन्सर्शन), और पुराना डेटा हटाना (डिलिशन) है। हर काम के लिए एक खास तरीका (एल्गोरिथम) होता है, जो बताता है कि डेटा को सही ढंग से कैसे मैनेज करें। डिलिशन में, हम उस आइटम को हटाते हैं जिसे हम नहीं चाहते, और बाकी आइटम को आगे खिसका देते हैं।

🎯 Exam Tip: एरे ऑपरेशन एल्गोरिथम्स को याद रखना महत्वपूर्ण है। इन्सर्शन और डिलिशन में तत्वों को शिफ्ट करने का तर्क अक्सर भ्रमित करने वाला होता है, इसलिए लूप की सीमाओं पर ध्यान दें।

 

Question 9. रिकर्शन से आप क्या समझते हैं? यह किस प्रकार कार्य करता है?
Answer: 'C' प्रोग्रामिंग में रिकर्शन (Recursion) एक ऐसी प्रक्रिया है जहाँ एक फंक्शन खुद को बार-बार कॉल करता है। इसे 'स्व-समान' (self-similar) तरीके से आइटमों को दोहराने जैसा समझा जा सकता है। जब कोई प्रोग्रामिंग भाषा एक फंक्शन को खुद के अंदर ही कॉल करने की अनुमति देती है, तो उस फंक्शन को रिकर्सिव फंक्शन कहा जाता है। यह अक्सर जटिल समस्याओं को छोटे, समान हिस्सों में तोड़ने में मदद करता है।
रिकर्शन इस तरह से काम करता है:
एक रिकर्सिव फंक्शन के अंदर, एक कंडीशन (बेस केस) होती है जो यह तय करती है कि फंक्शन को कब खुद को कॉल करना बंद करना है। यदि यह कंडीशन पूरी नहीं होती है, तो फंक्शन खुद को फिर से कॉल करता है, आमतौर पर एक छोटे इनपुट के साथ। यह प्रक्रिया तब तक चलती है जब तक बेस केस तक नहीं पहुंच जाता। उदाहरण के लिए, एक फंक्शन जो फैक्टरियल की गणना करता है, खुद को तब तक कॉल करेगा जब तक कि इनपुट 1 न हो जाए।
void recurse() { /* ... कुछ काम ... */ recurse(); /* फंक्शन खुद को फिर से कॉल करता है */ }
int main() { /* ... */ recurse(); /* मेन फंक्शन से पहली कॉल */ /* ... */ }
In simple words: रिकर्शन तब होता है जब एक कंप्यूटर प्रोग्राम का एक हिस्सा (एक फंक्शन) खुद को ही बार-बार बुलाता है। यह तब तक चलता रहता है जब तक कोई खास शर्त पूरी नहीं हो जाती, जो उसे रुकने के लिए कहती है।

🎯 Exam Tip: रिकर्शन में बेस केस (समाप्ति की शर्त) को सही ढंग से परिभाषित करना महत्वपूर्ण है, अन्यथा फंक्शन अनंत लूप में चला जाएगा और प्रोग्राम क्रैश हो सकता है।

 

Question 10. रिकर्शन फंक्शन के लिए शर्ते बताइए व रिकर्शन के द्वारा फिबोनैकी सीरीज का प्रोग्राम भी लिखिए।
Answer: रिकर्शन फंक्शन के सही ढंग से काम करने के लिए कुछ शर्तें पूरी होनी चाहिएं:

• फंक्शन को खुद को कॉल करते समय, यह एक 'बेस केस' (Base Case) के करीब आना चाहिए। बेस केस वह शर्त होती है जिस पर फंक्शन खुद को कॉल करना बंद कर देता है।
• हर बार जब फंक्शन खुद को कॉल करता है, तो समस्या का आकार छोटा होना चाहिए।

निम्नलिखित C प्रोग्राम रिकर्शन का उपयोग करके फिबोनैकी सीरीज की Nवीं टर्म (पद) को प्रिंट करता है। फिबोनैकी संख्याएँ ऐसी होती हैं जहाँ प्रत्येक संख्या पिछली दो संख्याओं का योग होती है (जैसे 0, 1, 1, 2, 3, 5...).
#include <stdio.h>
#include <stdlib.h>
int fibonacci(int term);
int main() {
int terms, counter;
printf("Enter number of terms in Fibonacci series: ");
scanf("%d", &terms);
printf("Fibonacci series till %d terms \\n", terms);
for (counter = 0; counter < terms; counter++) {
printf("%d ", fibonacci(counter));
}
getch();
return 0;
}

/* Function to calculate Nth Fibonacci number */
int fibonacci(int term) {
if (term <= 1) {
return term;
}
return fibonacci(term - 1) + fibonacci(term - 2);
}
इस प्रोग्राम को संकलित और चलाने पर निम्नलिखित आउटपुट मिलेगा:
Enter number of terms in Fibonacci series: 9
Fibonacci series till 9 terms
0 1 1 2 3 5 8 13 21
In simple words: रिकर्शन को काम करने के लिए एक आखिरी शर्त की ज़रूरत होती है ताकि फंक्शन हमेशा खुद को बुलाता न रहे। फिबोनैकी सीरीज का प्रोग्राम दिखाता है कि कैसे एक फंक्शन खुद को बुलाकर संख्याओं की एक लिस्ट बनाता है, जहाँ हर नई संख्या पिछली दो का जोड़ होती है।

🎯 Exam Tip: फिबोनैकी सीरीज रिकर्शन का एक क्लासिक उदाहरण है। बेस केस (term <= 1) को सही ढंग से सेट करना याद रखें, क्योंकि यह रिकर्शन को रोकने और सही परिणाम देने में मदद करता है।

 

Question 11. रिकर्शन द्वारा दो नम्बरों का GCD (HCF) निकालने के लिए 'C'भाषा में प्रोग्राम लिखिए।
Answer: रिकर्शन का उपयोग करके दो संख्याओं का सबसे बड़ा सामान्य भाजक (GCD या HCF) ज्ञात करने के लिए एक C प्रोग्राम यहाँ दिया गया है। GCD वह सबसे बड़ी संख्या होती है जो दो या दो से अधिक पूर्णांकों को पूरी तरह विभाजित करती है।
#include <stdio.h>

/* Function declaration */
int gcd(int a, int b);

int main() {
int num1, num2, hcf;

/* Reads two numbers from user */
printf("Enter any two numbers to find GCD: ");
scanf("%d%d", &num1, &num2);

hcf = gcd(num1, num2);

printf("GCD of %d and %d\\n", num1, num2, hcf);
return 0;
}

/* Recursive approach of euclidean algorithm to find GCD of two numbers: */
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
इस प्रोग्राम को संकलित और चलाने पर निम्नलिखित आउटपुट मिलेगा:
Enter any two numbers to find GCD: 12 30
GCD of 12 and 30 = 6
In simple words: यह प्रोग्राम यूक्लिड के एल्गोरिथम का उपयोग करके दो संख्याओं का सबसे बड़ा साझा भाजक (GCD) ढूंढता है। फंक्शन तब तक खुद को बुलाता है जब तक दूसरी संख्या शून्य न हो जाए, फिर पहली संख्या GCD होती है।

🎯 Exam Tip: यूक्लिडियन एल्गोरिथम GCD ज्ञात करने के लिए सबसे कुशल तरीकों में से एक है। रिकर्सिव फंक्शन (gcd) का बेस केस (b == 0) समझना महत्वपूर्ण है।

 

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

 

Question 1. दो आयामी ऐरे क्या हैं और उनकी मेमोरी में व्यवस्था कैसे होती है? उदाहरण सहित समझाइए।
Answer: दो आयामी ऐरे (Two-dimensional arrays) ऐसे ऐरे होते हैं जिनमें डेटा को पंक्तियों (rows) और स्तंभों (columns) के रूप में व्यवस्थित किया जाता है, जैसे एक तालिका या मैट्रिक्स। इन्हें ऐरे का ऐरे भी कहा जाता है। मेमोरी में, कंप्यूटर वास्तव में सभी डेटा को एक ही सीधी रेखा (लगातार मेमोरी स्थानों) में संग्रहीत करता है। डेटा को इस लीनियर मेमोरी में दो मुख्य तरीकों से व्यवस्थित किया जा सकता है: पंक्ति-प्रमुख व्यवस्था (Row-Major Arrangement) और कॉलम-प्रमुख व्यवस्था (Column-Major Arrangement)।

Answer: (Continued)
उदाहरण के लिए, एक 3x4 ऐरे पर विचार करें:

Answer: (Continued)
(क) पंक्ति प्रमुख प्रणाली (Row Major System):
इस प्रणाली में ऐरे के तत्वों को पंक्ति-दर-पंक्ति मेमोरी में संग्रहीत किया जाता है। यानी, पहले पूरी पहली पंक्ति, फिर पूरी दूसरी पंक्ति, और इसी तरह।

Answer: (Continued)
पंक्ति प्रमुख प्रणाली में A[I][J] तत्व का पता निम्न सूत्र का उपयोग करके ज्ञात किया जाता है:
Address of A[I][J] = B + W * [N * (I-Lr) + (J-Lc)]
जहाँ,
B = आधार पता
W = ऐरे में उपस्थित एक तत्व की स्टोरेज साइज (बाइट में)
N = कॉलम की कुल संख्या
I = जिस तत्व का पता ज्ञात करना है उसका पंक्ति सबस्क्रिप्ट
J = जिस तत्व का पता ज्ञात करना है उसका कॉलम सबस्क्रिप्ट
Lr = पंक्ति की निचली सीमा (सामान्यतः 0)
Lc = कॉलम की निचली सीमा (सामान्यतः 0)

Answer: (Continued)
(ख) कॉलम प्रमुख प्रणाली (Column Major System):
इस प्रणाली में ऐरे के तत्वों को कॉलम-दर-कॉलम मेमोरी में संग्रहीत किया जाता है। यानी, पहले पूरा पहला कॉलम, फिर पूरा दूसरा कॉलम, और इसी तरह।

Answer: (Continued)
कॉलम प्रमुख प्रणाली में A[I][J] तत्व का पता निम्न सूत्र का उपयोग करके ज्ञात किया जाता है:
A[I][J] तत्व का पता = B + W * [(I-Lr) + M * (J-Lc)]
जहाँ,
B = आधार पता
W = ऐरे में उपस्थित एक तत्व की स्टोरेज साइज (बाइट में)
M = पंक्ति की कुल संख्या
I = जिस तत्व का पता ज्ञात करना है उसका पंक्ति सबस्क्रिप्ट
J = जिस तत्व का पता ज्ञात करना है उसका कॉलम सबस्क्रिप्ट
Lr = पंक्ति की निचली सीमा (सामान्यतः 0)
Lc = कॉलम की निचली सीमा (सामान्यतः 0)
In simple words: दो आयामी ऐरे डेटा को ग्रिड की तरह रखते हैं। कंप्यूटर उन्हें दो तरीकों से स्टोर करता है: या तो पूरी एक पंक्ति को एक साथ, फिर अगली पंक्ति (रो-मेजर); या पूरे एक कॉलम को एक साथ, फिर अगला कॉलम (कॉलम-मेजर)। हर तरीके के लिए एक खास फार्मूला होता है जो बताता है कि मेमोरी में कोई भी आइटम कहाँ मिलेगा।

🎯 Exam Tip: पंक्ति-प्रमुख (Row-Major) और कॉलम-प्रमुख (Column-Major) व्यवस्था डेटा संरचना में मूलभूत अवधारणाएं हैं। याद रखें कि C और Java जैसी अधिकांश भाषाएं पंक्ति-प्रमुख व्यवस्था का उपयोग करती हैं।

 

Question 2. किसी ऐरे में एलीमेन्ट को इन्सर्ट करने के लिए एक प्रोग्राम लिखिए।
Answer: किसी ऐरे में एक नया तत्व (element) इन्सर्ट करने के लिए हमें बाकी तत्वों को एक स्थान आगे खिसकाना पड़ता है ताकि नए तत्व के लिए जगह बन सके। यह एक C प्रोग्राम है जो दिखाता है कि किसी लीनियर ऐरे में एक एलीमेन्ट को कैसे इन्सर्ट किया जाए।
#include <stdio.h>
main() {
int LA[] = {1, 3, 5, 7, 8};
int item = 10, k = 3, n = 5;
int i = 0, j = n;

printf("The original array elements are : \\n");
for (i = 0; i < n; i++) {
printf("LA[%d] = %d \\n", i, LA[i]);
}

n = n + 1;
while (j >= k) {
LA[j + 1] = LA[j];
j = j - 1;
}
LA[k] = item;

printf("The array elements after insertion : \\n");
for (i = 0; i < n; i++) {
printf("LA [%d] = %d \\n", i, LA[i]);
}
}
इस प्रोग्राम को संकलित और चलाने पर निम्नलिखित आउटपुट मिलेगा:
The original array elements are:
LA[0]=1
LA[1]=3
LA[2]=5
LA[3]=7
LA[4]=8
The array elements after insertion:
LA[0]=1
LA[1]=3
LA[2]=5
LA[3]=10
LA[4]=7
LA[5]=8
In simple words: यह प्रोग्राम दिखाता है कि किसी एरे में एक नया नंबर कैसे डालते हैं। सबसे पहले, यह मौजूदा नंबरों को नई जगह बनाने के लिए एक कदम आगे खिसकाता है। फिर, यह नया नंबर खाली जगह में रख देता है।

🎯 Exam Tip: इन्सर्शन करते समय, यह सुनिश्चित करना महत्वपूर्ण है कि आप ऐरे की क्षमता से अधिक तत्वों को इन्सर्ट न करें। तत्वों को खिसकाते समय लूप की सीमाएं (J >= K) ध्यान से जांचें।

 

Question 3. लीनियर सर्च के लिए एक प्रोग्राम लिखिए। अथवा ऐरे में किसी एलीमेन्ट (element) को सर्च करके उसकी पोजिशन ज्ञात करने के लिए प्रोग्राम लिखिए।
Answer: लीनियर सर्च एक सरल विधि है जिसका उपयोग किसी ऐरे में एक विशेष तत्व (element) को खोजने के लिए किया जाता है। यह ऐरे के पहले तत्व से शुरू होकर प्रत्येक तत्व की तुलना तब तक करता है जब तक वांछित तत्व मिल न जाए। यदि तत्व मिल जाता है, तो उसकी स्थिति वापस कर दी जाती है; अन्यथा, यह इंगित किया जाता है कि तत्व नहीं मिला।
#include <stdio.h>
main() {
int LA[] = {1, 3, 5, 7, 8};
int item = 5, n = 5;
int i = 0, j = 0;

printf("The original array elements are : \\n");
for (i = 0; i < n; i++) {
printf("LA[%d] = %d \\n", i, LA[i]);
}

while (j < n) {
if (LA[j] == item) {
break;
}
j = j + 1;
}

printf("Found element %d at position %d \\n", item, j + 1);
}
इस प्रोग्राम को संकलित और चलाने पर निम्नलिखित आउटपुट मिलेगा:
The original array elements are:
LA[0]=1
LA[1]=3
LA[2]=5
LA[3]=7
LA[4]=8
Found element 5 at position 3.
In simple words: यह प्रोग्राम एक लिस्ट में किसी खास नंबर को ढूंढता है। यह लिस्ट के हर नंबर को एक-एक करके चेक करता है जब तक उसे वह नंबर मिल न जाए। अगर मिल जाता है, तो यह उसकी जगह बता देता है।

🎯 Exam Tip: लीनियर सर्च छोटे एरे के लिए आसान है, लेकिन बड़े एरे के लिए यह धीमा हो सकता है क्योंकि इसे सभी तत्वों को देखना पड़ सकता है। इसकी जटिलता O(n) है।

 

Question 4. बाइनरी सर्च के लिए एक प्रोग्राम लिखिए।
Answer: बाइनरी सर्च एक कुशल एल्गोरिथम है जिसका उपयोग किसी सॉर्ट किए गए (क्रमबद्ध) ऐरे में एक तत्व को खोजने के लिए किया जाता है। यह लीनियर सर्च की तुलना में बहुत तेज़ है क्योंकि यह ऐरे को बार-बार आधे हिस्से में विभाजित करता है, जिससे खोज का स्थान कम हो जाता है।
#include <stdio.h>
#define MAX 20

int Array[MAX] = {1, 2, 3, 4, 6, 7, 9, 11, 12, 14, 15, 16, 17, 19, 33, 34, 43, 45, 55, 66};

void printline(int count) {
int i;
for (i = 0; i < count - 1; i++) {
printf("=");
}
printf("=\\n");
}

int find(int data) {
int lowerBound = 0;
int upperBound = MAX - 1;
int midPoint = -1;
int comparisons = 0;
int index = -1;

while (lowerBound <= upperBound) {
printf("Comparison %d\\n", (comparisons + 1));
printf("lower Bound : %d, int Array [%d] = %d\\n", lowerBound, lowerBound, Array[lowerBound]);
printf("upper Bound : %d, int Array [%d] = %d\\n", upperBound, upperBound, Array[upperBound]);
comparisons++;

// compute the mid point
// mid point = (lowerBound + upperBound) / 2;
midPoint = lowerBound + (upperBound - lowerBound) / 2;

// data found
if (Array[midPoint] == data) {
index = midPoint;
break;
} else if (Array[midPoint] < data) {
// data is in upper half
lowerBound = midPoint + 1;
} else {
// data is in lower half
upperBound = midPoint - 1;
}
}

printf("Total comparisons made: %d\\n", comparisons);
return index;
}

void display() {
int i;
printf("[");
// navigate through all items
for (i = 0; i < MAX; i++) {
printf("%d ", Array[i]);
}
printf("]\\n");
}

int main() {
printf("Input Array:");
display();
printline(50);

// find location of 1
int location = find(1);

if (location != -1) {
printf("Element found at location: %d \\n", (location + 1));
} else {
printf("Element not found. \\n");
}
}
इस प्रोग्राम को संकलित और चलाने पर निम्नलिखित आउटपुट मिलेगा:
Input Array: [1 2 3 4 6 7 9 11 12 14 15 16 17 19 33 34 43 45 55 66]
Comparison 1
lower Bound: 0, int Array [0] = 1
upper Bound: 19, int Array [19] = 66
Comparison 2
lower Bound : 0, int Array [0] = 1
upper Bound: 8, int Array [8] = 12
Comparison 3
lower Bound : 0, int Array [0] = 1
upper Bound: 3, int Array [3] = 4
Comparison 4
lower Bound : 0, int Array [0] = 1
upper Bound: 0, int Array [0] = 1
Total comparisons made: 4
Element found at location: 1
In simple words: यह प्रोग्राम बाइनरी सर्च का उपयोग करके एक सॉर्ट किए गए लिस्ट (ऐरे) में किसी नंबर को ढूंढता है। यह लिस्ट को बार-बार आधा करता है जब तक कि नंबर मिल न जाए, जिससे यह बड़े लिस्ट के लिए बहुत तेज़ होता है।

🎯 Exam Tip: बाइनरी सर्च का उपयोग केवल तभी किया जा सकता है जब ऐरे सॉर्टेड (क्रमबद्ध) हो। यदि ऐरे सॉर्टेड नहीं है, तो बाइनरी सर्च गलत परिणाम दे सकता है। इसकी जटिलता O(log n) है।

🎯 Exam Tip: When a page appears blank in the source, it's crucial to confirm there's no hidden content or missed elements by carefully reviewing the original document to ensure no educational material is accidentally omitted.