RBSE Class 12th 2017 -SS-03-2017 Previous Year Papers

उत्तर: फ़ाइल स्ट्रीम (File Stream) – C++ में fstream क्लास इनपुट और आउटपुट दोनों के लिए कार्य करती है।

Explanation: In C++, the fstream class (derived from iostream) allows both reading from and writing to files, making it a bidirectional stream.

उत्तर: मल्टी लेवल इन्हेरीटेंस एक प्रकार का इन्हेरीटेंस है जिसमें एक क्लास दूसरी क्लास से प्राप्त होती है, और फिर उससे तीसरी क्लास प्राप्त होती है। यह एक श्रृंखला (chain) बनाता है।

Explanation: In multilevel inheritance, a derived class inherits from a base class, and another class inherits from that derived class, forming a hierarchy (e.g., Class A → Class B → Class C).

उत्तर: पंक्ति (Queue) एक रैखिक डाटा संरचना है जो FIFO (First In First Out) सिद्धांत पर कार्य करती है। इसमें नया तत्व पीछे (rear) से जोड़ा जाता है और सामने (front) से हटाया जाता है।

Explanation: A queue follows the FIFO principle: elements are added at the rear and removed from the front, like a line of people waiting.

उत्तर: व्यूह (Array) दो प्रकार के होते हैं:

1. एक-आयामी व्यूह (One-dimensional array) – जिसमें तत्व एक पंक्ति में व्यवस्थित होते हैं।
2. बहु-आयामी व्यूह (Multi-dimensional array) – जैसे द्वि-आयामी (2D) या त्रि-आयामी (3D) व्यूह, जिसमें तत्व पंक्तियों और स्तंभों में व्यवस्थित होते हैं।

Explanation: Arrays are classified as one-dimensional (linear) and multi-dimensional (e.g., 2D arrays with rows and columns).

उत्तर: नीचे एक एक-आयामी व्यूह (array) का चित्र दिया गया है जो इन्डेक्स और लम्बाई (length) को दर्शाता है:

इन्डेक्स:  0    1    2    3    4
        +----+----+----+----+----+
        | 10 | 20 | 30 | 40 | 50 |
        +----+----+----+----+----+
लम्बाई (Length) = 5
  

Explanation: The array has indices starting from 0 to 4, and its length (number of elements) is 5.

उत्तर: DROP TABLE कमाण्ड का प्रयोग किया जाता है।

Explanation: In SQL, the DROP TABLE command permanently removes a table and its data from the database.

उत्तर: SQL (Structured Query Language) एक डेटाबेस भाषा है जिसका उपयोग रिलेशनल डेटाबेस में डेटा को संग्रहीत, प्रबंधित और क्वेरी करने के लिए किया जाता है।

Explanation: SQL is a standard programming language for managing and manipulating relational databases, including operations like SELECT, INSERT, UPDATE, and DELETE.

उत्तर: आधारभूत बूलियन ऑपरेटर AND, OR और NOT हैं।

Answer: The basic boolean operators are AND, OR, and NOT.

उत्तर: NOR गेट एक डिजिटल लॉजिक गेट है जो OR गेट और NOT गेट का संयोजन है। इसका आउटपुट तभी 1 (हाई) होता है जब सभी इनपुट 0 (लो) हों, अन्यथा आउटपुट 0 होता है।

Answer: A NOR gate is a digital logic gate that is a combination of an OR gate and a NOT gate. Its output is 1 (high) only when all inputs are 0 (low), otherwise the output is 0.

उत्तर: हाफ डुप्लेक्स डाटा ट्रांस्फर मोड में डेटा दोनों दिशाओं में ट्रांसफर हो सकता है, लेकिन एक समय में केवल एक दिशा में। यह एक समय में केवल एक डिवाइस को डेटा भेजने या प्राप्त करने की अनुमति देता है।

Answer: In half duplex data transfer mode, data can be transferred in both directions, but only in one direction at a time. It allows only one device to send or receive data at a time.

उत्तर: HTML का पूरा नाम हाइपरटेक्स्ट मार्कअप लैंग्वेज (HyperText Markup Language) है।

Answer: The full name of HTML is HyperText Markup Language.

उत्तर: FOR लूप एक नियंत्रण संरचना है जो एक निश्चित संख्या में कोड के ब्लॉक को दोहराता है। इसका सामान्य सिंटैक्स (C++/Java में) इस प्रकार है:

for (initialization; condition; increment/decrement) {
    // statements to be executed
}

उदाहरण: for (int i = 0; i < 5; i++) { cout << i; } यह लूप 0 से 4 तक प्रिंट करेगा।

Answer: A FOR loop is a control structure that repeats a block of code a fixed number of times. Its general syntax (in C++/Java) is:

for (initialization; condition; increment/decrement) {
    // statements to be executed
}

Example: for (int i = 0; i < 5; i++) { cout << i; } This loop will print 0 to 4.

उत्तर: डायनामिक कन्सट्रक्टर वह कन्सट्रक्टर है जो रन टाइम पर मेमोरी आवंटित करता है। इसमें new ऑपरेटर का उपयोग करके ऑब्जेक्ट के लिए डायनामिक रूप से मेमोरी आवंटित की जाती है।

Answer: A dynamic constructor is a constructor that allocates memory at runtime. It uses the new operator to dynamically allocate memory for an object.

उत्तर: दो ऑपरेटर जिन्हें ओवरलोड नहीं किया जा सकता:

• स्कोप रिज़ॉल्यूशन ऑपरेटर (::)
• टर्नरी ऑपरेटर (?:)

Answer: Two operators that cannot be overloaded:

• Scope resolution operator (::)
• Ternary operator (?:)

सिंटेक्स: data_type array_name[rows][columns];

उदाहरण: int marks[3][4]; — यह 3 पंक्तियों और 4 स्तंभों वाला एक पूर्णांक ऐरे है।

• डेटा रिडंडेंसी (अनावश्यकता) को कम करता है।
• डेटा सुरक्षा और एकीकरण प्रदान करता है।
• डेटा तक आसान पहुँच और प्रबंधन।
• डेटा की संगति और अखंडता बनाए रखता है।

1. बैंकिंग प्रणाली (खाता प्रबंधन)
2. शिक्षा संस्थान (छात्र रिकॉर्ड)
3. ई-कॉमर्स (उत्पाद और ऑर्डर डेटा)
4. स्वास्थ्य सेवा (रोगी रिकॉर्ड)

AND गेट: यह एक लॉजिक गेट है जो तभी आउटपुट 1 देता है जब सभी इनपुट 1 हों।

वितरण नियम (Distribution Law):

• A · (B + C) = (A · B) + (A · C)
• A + (B · C) = (A + B) · (A + C)

यह नियम बताता है कि AND और OR ऑपरेशन एक-दूसरे पर वितरित हो सकते हैं।

को-एक्सियल केबल की संरचना:

1. आंतरिक चालक (Inner Conductor): तांबे का तार जो सिग्नल ले जाता है।
2. डाइइलेक्ट्रिक इन्सुलेशन (Dielectric Insulation): प्लास्टिक या फोम की परत जो चालक को अलग करती है।
3. बाहरी चालक (Outer Conductor): धातु की जाली या फॉइल जो शील्डिंग प्रदान करती है।
4. बाहरी जैकेट (Outer Jacket): रबर या प्लास्टिक की सुरक्षात्मक परत।

क्रम वाली सूची (Ordered List): <ol> टैग से बनाई जाती है। इसमें आइटम क्रमांकित होते हैं (1, 2, 3...)।

उदाहरण:

<ol>
  <li>पहला आइटम</li>
  <li>दूसरा आइटम</li>
</ol>

बिना क्रम वाली सूची (Unordered List): <ul> टैग से बनाई जाती है। इसमें आइटम बुलेट पॉइंट (•) से दिखाए जाते हैं।

उदाहरण:

<ul>
  <li>पहला आइटम</li>
  <li>दूसरा आइटम</li>
</ul>

प्रोप्राइटरी सॉफ्टवेयर वह सॉफ्टवेयर है जिसका स्वामित्व किसी व्यक्ति या कंपनी के पास होता है और इसके स्रोत कोड को सार्वजनिक रूप से उपलब्ध नहीं कराया जाता। उपयोगकर्ता को इसका उपयोग करने के लिए लाइसेंस खरीदना पड़ता है और इसे संशोधित या पुनर्वितरित नहीं किया जा सकता।

उदाहरण: Microsoft Windows, Adobe Photoshop, Microsoft Office.

#include <iostream>
using namespace std;

// Function to swap two integers
void swapInt(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

// Function to swap two floats
void swapFloat(float &x, float &y) {
    float temp = x;
    x = y;
    y = temp;
}

int main() {
    int i1 = 10, i2 = 20;
    float f1 = 3.5, f2 = 7.2;
    
    cout << "Before swapping: i1=" << i1 << ", i2=" << i2 << endl;
    swapInt(i1, i2);
    cout << "After swapping: i1=" << i1 << ", i2=" << i2 << endl;
    
    cout << "Before swapping: f1=" << f1 << ", f2=" << f2 << endl;
    swapFloat(f1, f2);
    cout << "After swapping: f1=" << f1 << ", f2=" << f2 << endl;
    
    return 0;
}

व्याख्या: यहाँ दो अलग-अलग फंक्शन बनाए गए हैं - एक int और एक float प्रकार के मानों को स्वैप करने के लिए। दोनों फंक्शन रेफरेंस पैरामीटर का उपयोग करते हैं ताकि मूल मान बदल जाएं।

1. स्वचालित आह्वान: कन्सट्रक्टर ऑब्जेक्ट बनाते समय स्वचालित रूप से कॉल होता है।
2. क्लास का नाम: कन्सट्रक्टर का नाम क्लास के नाम के समान होता है।
3. कोई रिटर्न टाइप नहीं: कन्सट्रक्टर का कोई रिटर्न टाइप नहीं होता (void भी नहीं)।
4. ओवरलोडिंग: कन्सट्रक्टर को ओवरलोड किया जा सकता है (एक से अधिक कन्सट्रक्टर हो सकते हैं)।
5. डिफॉल्ट कन्सट्रक्टर: यदि कोई कन्सट्रक्टर परिभाषित नहीं किया जाता, तो कंपाइलर एक डिफॉल्ट कन्सट्रक्टर प्रदान करता है।
6. इनिशियलाइजेशन: कन्सट्रक्टर का उपयोग ऑब्जेक्ट के डेटा मेंबर्स को इनिशियलाइज करने के लिए किया जाता है।
7. पैरामीटराइज्ड कन्सट्रक्टर: कन्सट्रक्टर पैरामीटर ले सकता है।
8. कॉपी कन्सट्रक्टर: एक विशेष कन्सट्रक्टर जो एक ऑब्जेक्ट को दूसरे ऑब्जेक्ट से कॉपी करता है।

स्टैक एक रैखिक डेटा संरचना है जो LIFO (Last In First Out) सिद्धांत पर काम करती है। इसका अर्थ है कि जो तत्व सबसे अंत में जोड़ा जाता है, वह सबसे पहले हटाया जाता है।

मुख्य संक्रियाएं:

• push(x): स्टैक के शीर्ष पर एक तत्व जोड़ना।
• pop(): स्टैक के शीर्ष से तत्व हटाना।
• top()/peek(): शीर्ष तत्व को देखना (हटाए बिना)।
• isEmpty(): जांचना कि स्टैक खाली है या नहीं।

उपयोग: फंक्शन कॉल्स को ट्रैक करना, एक्सप्रेशन मूल्यांकन, बैकट्रैकिंग एल्गोरिदम, ब्राउज़र का बैक बटन आदि।

1. क्लास (Class): एक ब्लूप्रिंट या टेम्पलेट जो ऑब्जेक्ट के गुणों और व्यवहार को परिभाषित करता है।
2. ऑब्जेक्ट (Object): क्लास का एक इंस्टेंस जो वास्तविक दुनिया की इकाई का प्रतिनिधित्व करता है।
3. एनकैप्सुलेशन (Encapsulation): डेटा और मेथड्स को एक इकाई में बांधना और बाहरी पहुंच से बचाना।
4. इनहेरिटेंस (Inheritance): एक क्लास दूसरी क्लास के गुणों और मेथड्स को प्राप्त कर सकती है।
5. पॉलीमॉर्फिज्म (Polymorphism): एक ही नाम के फंक्शन या ऑपरेटर अलग-अलग संदर्भों में अलग-अलग व्यवहार कर सकते हैं।
6. एब्स्ट्रैक्शन (Abstraction): जटिल विवरणों को छिपाकर केवल आवश्यक सुविधाएं प्रदान करना।

#include <iostream>
using namespace std;

int main() {
    float base, height, area;
    
    cout << "त्रिभुज का आधार (base) दर्ज करें: ";
    cin >> base;
    cout << "त्रिभुज की ऊंचाई (height) दर्ज करें: ";
    cin >> height;
    
    // क्षेत्रफल = (1/2) * आधार * ऊंचाई
    area = 0.5 * base * height;
    
    cout << "त्रिभुज का क्षेत्रफल = " << area << " वर्ग इकाई" << endl;
    
    return 0;
}

व्याख्या: यह प्रोग्राम उपयोगकर्ता से त्रिभुज का आधार और ऊंचाई इनपुट लेता है, फिर सूत्र क्षेत्रफल = 0.5 × आधार × ऊंचाई का उपयोग करके क्षेत्रफल की गणना करता है और परिणाम प्रदर्शित करता है।

असाइनमैन्ट ऑपरेटर ओवरलोडिंग C++ में एक विशेषता है जो हमें '=' ऑपरेटर को यूज़र-डिफाइंड डेटा टाइप्स (जैसे क्लास) के लिए पुनर्परिभाषित करने की अनुमति देती है।

मुख्य बिंदु:

• इसे एक मेंबर फंक्शन के रूप में ओवरलोड किया जाता है।
• डिफॉल्ट असाइनमैन्ट ऑपरेटर शैलो कॉपी (shallow copy) करता है, जबकि ओवरलोडेड वर्जन डीप कॉपी (deep copy) कर सकता है।
• इसका उपयोग तब आवश्यक होता है जब क्लास में डायनामिक मेमोरी एलोकेशन हो।
• सिंटैक्स: ClassName& operator=(const ClassName& other);
• यह आमतौर पर *this को रिटर्न करता है ताकि चेनिंग (a=b=c) संभव हो।

1. सिंगल इनहेरिटेंस (Single Inheritance): एक डिराइव्ड क्लास केवल एक बेस क्लास से इनहेरिट करती है।
2. मल्टीपल इनहेरिटेंस (Multiple Inheritance): एक डिराइव्ड क्लास एक से अधिक बेस क्लास से इनहेरिट करती है।
3. मल्टीलेवल इनहेरिटेंस (Multilevel Inheritance): एक क्लास दूसरी क्लास से इनहेरिट करती है, जो स्वयं किसी अन्य क्लास से इनहेरिट करती है (श्रृंखला)।
4. हाइरार्किकल इनहेरिटेंस (Hierarchical Inheritance): एक बेस क्लास से कई डिराइव्ड क्लास इनहेरिट करती हैं।
5. हाइब्रिड इनहेरिटेंस (Hybrid Inheritance): दो या अधिक प्रकार के इनहेरिटेंस का संयोजन।

उदाहरण: सिंगल: A→B; मल्टीपल: A,B→C; मल्टीलेवल: A→B→C; हाइरार्किकल: A→B, A→C; हाइब्रिड: A→B, A→C, B,C→D

Searching Methods in an Array

1. Linear Search (Sequential Search): In this method, each element of the array is compared with the target element one by one from the beginning until a match is found or the end of the array is reached. It works on both sorted and unsorted arrays. Time complexity: O(n) in worst case.

2. Binary Search: This method works only on sorted arrays. It repeatedly divides the search interval in half. If the target value is less than the middle element, search in the left half; otherwise, search in the right half. Time complexity: O(log n).

3. Interpolation Search: An improved variant of binary search for uniformly distributed sorted arrays. It estimates the position of the target using a formula based on the values at the ends of the array. Time complexity: O(log log n) on average.

4. Hashing: Uses a hash function to map keys to indices in a hash table, allowing near O(1) average time search. Requires extra memory for the hash table.

Sorting Methods in an Array

1. Bubble Sort: Repeatedly steps through the array, compares adjacent elements, and swaps them if they are in the wrong order. The largest element "bubbles" to its correct position in each pass. Time complexity: O(n²).

2. Selection Sort: Divides the array into sorted and unsorted parts. In each pass, it finds the minimum element from the unsorted part and swaps it with the first element of the unsorted part. Time complexity: O(n²).

3. Insertion Sort: Builds the final sorted array one element at a time by repeatedly inserting the next element into its correct position among the previously sorted elements. Efficient for small or nearly sorted arrays. Time complexity: O(n²) worst case, O(n) best case.

4. Quick Sort: A divide-and-conquer algorithm that selects a pivot element, partitions the array around the pivot (elements smaller on left, larger on right), and recursively sorts the subarrays. Average time complexity: O(n log n).

5. Merge Sort: A divide-and-conquer algorithm that divides the array into two halves, recursively sorts them, and then merges the sorted halves. Time complexity: O(n log n) in all cases. Requires extra space for merging.

6. Heap Sort: Builds a max-heap from the array, then repeatedly extracts the maximum element (root) and places it at the end of the array, reducing the heap size. Time complexity: O(n log n).