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

इम्प्लीसिट टाईप कास्टिंग (Implicit Type Casting) वह प्रक्रिया है जिसमें कंपाइलर स्वचालित रूप से एक डेटा टाइप को दूसरे डेटा टाइप में बदल देता है, बिना प्रोग्रामर के किसी स्पष्ट निर्देश के। यह तब होता है जब एक छोटे डेटा टाइप को बड़े डेटा टाइप में असाइन किया जाता है, जैसे int को float में बदलना। इसे ऑटोमैटिक टाईप कन्वर्जन भी कहते हैं।

आउटपुट: 5

व्याख्या: प्रारंभ में a = 2।

• a++ (पोस्ट-इन्क्रीमेंट): पहले a का मान 2 प्रयोग होता है, फिर a बढ़कर 3 हो जाता है।
• ++a (प्री-इन्क्रीमेंट): a पहले बढ़कर 4 होता है, फिर प्रयोग होता है।
• a++ (पोस्ट-इन्क्रीमेंट): a का मान 4 प्रयोग होता है, फिर a बढ़कर 5 हो जाता है।

अतः b = 2 + 4 * 4 = 2 + 16 = 18, और अंत में a का मान 5 होता है।

कॉपी कन्सट्रक्टर (Copy Constructor) एक विशेष प्रकार का कन्सट्रक्टर है जो किसी ऑब्जेक्ट को उसी क्लास के किसी दूसरे ऑब्जेक्ट से इनिशियलाइज़ करने के लिए उपयोग किया जाता है। यह एक ऑब्जेक्ट की कॉपी बनाता है। इसका सिंटैक्स ClassName(const ClassName &obj) होता है।

स्टैक का एक उपयोग: फंक्शन कॉल्स को मैनेज करना (Function Call Management) – जब कोई फंक्शन कॉल किया जाता है, तो उसका एड्रेस और लोकल वेरिएबल्स स्टैक पर पुश किए जाते हैं, और फंक्शन रिटर्न होने पर पॉप किए जाते हैं।

• बैंकिंग सिस्टम (Banking System) – खाता लेन-देन, बैलेंस, और ग्राहक जानकारी प्रबंधित करना।
• ऑनलाइन शॉपिंग (E-commerce) – उत्पादों, ऑर्डरों, और ग्राहकों का डेटा संग्रहीत करना।

नॉट गेट (NOT Gate) एक लॉजिक गेट है जो इनपुट का उल्टा (इनवर्ट) आउटपुट देता है। यदि इनपुट 1 है, तो आउटपुट 0 होता है, और यदि इनपुट 0 है, तो आउटपुट 1 होता है। इसे इन्वर्टर (Inverter) भी कहते हैं। इसका सत्य तालिका (Truth Table) इस प्रकार है:

Solution: An OR gate can be implemented using NAND gates as follows:

• Connect the two inputs A and B to a NAND gate. This gives output (A·B)' = A' + B'.
• Connect the output of the first NAND gate to both inputs of a second NAND gate (acting as an inverter). This gives ((A' + B')') = A + B.

Thus, using two NAND gates, we get the OR operation: Y = A + B.

Answer: Baud rate is the number of signal units (symbols) transmitted per second in a communication channel. It is different from bit rate; one baud can represent multiple bits depending on the modulation technique.

Answer: Two web browsers are:

1. Google Chrome
2. Mozilla Firefox

Answer: Two websites for open source software are:

1. SourceForge (sourceforge.net)
2. GitHub (github.com)

Solution: Here is a C++ program to swap two integer values using a temporary variable:

#include <iostream>
using namespace std;

int main() {
    int a = 10, b = 20, temp;
    cout << "Before swapping: a = " << a << ", b = " << b << endl;
    temp = a;
    a = b;
    b = temp;
    cout << "After swapping: a = " << a << ", b = " << b << endl;
    return 0;
}

Output: Before swapping: a = 10, b = 20
After swapping: a = 20, b = 10

Explanation: A friend function in C++ is a non-member function that has access to the private and protected members of a class. It is declared using the friend keyword inside the class. It is not a member function but can access private data.

Example:

#include <iostream>
using namespace std;

class Box {
private:
    int length;
public:
    Box() : length(10) {}
    friend void showLength(Box b); // friend function declaration
};

void showLength(Box b) {
    cout << "Length of box: " << b.length << endl; // accessing private member
}

int main() {
    Box box;
    showLength(box);
    return 0;
}

Output: Length of box: 10

Answer: Two rules of operator overloading in C++ are:

1. Precedence and associativity cannot be changed: The precedence and associativity of an operator remain the same even after overloading.
2. Cannot create new operators: Only existing operators can be overloaded; new operators (like ** or <> ) cannot be created.

स्टोरेज क्लासेज (Storage Classes): C++ में स्टोरेज क्लासेज वेरिएबल की स्कोप (scope), लाइफटाइम (lifetime) और इनिशियलाइजेशन को निर्धारित करती हैं। मुख्य स्टोरेज क्लासेज निम्न हैं:

• auto: डिफ़ॉल्ट स्टोरेज क्लास, लोकल वेरिएबल के लिए उपयोग होता है।
• register: वेरिएबल को CPU रजिस्टर में स्टोर करने का सुझाव देता है।
• static: वेरिएबल को प्रोग्राम के अंत तक जीवित रखता है, केवल एक बार इनिशियलाइज़ होता है।
• extern: वेरिएबल को दूसरी फ़ाइल में डिफ़ाइन करने की अनुमति देता है।
• mutable: कॉन्स्टेंट ऑब्जेक्ट के मेम्बर को मॉडिफाई करने की अनुमति देता है।

फंक्शन ओवरलोडिंग (Function Overloading): एक ही नाम से कई फंक्शन बनाना, जिनके पैरामीटर अलग-अलग हों। कंपाइलर पैरामीटर के आधार पर सही फंक्शन चुनता है।

उदाहरण:

#include <iostream>
using namespace std;

int add(int a, int b) {
    return a + b;
}

double add(double a, double b) {
    return a + b;
}

int main() {
    cout << add(5, 10) << endl;      // int version
    cout << add(5.5, 10.5) << endl;  // double version
    return 0;
}

यहाँ add फंक्शन दो बार डिफ़ाइन है – एक int और एक double पैरामीटर के लिए।

POP ऑपरेशन: स्टैक से सबसे ऊपर वाले तत्व (top) को हटाना। यह LIFO (Last In First Out) सिद्धांत पर काम करता है।

उदाहरण: मान लीजिए स्टैक में तत्व [10, 20, 30] हैं (30 सबसे ऊपर)।

POP() → 30 हटेगा, स्टैक: [10, 20]
POP() → 20 हटेगा, स्टैक: [10]

C++ कोड:

#include <iostream>
#include <stack>
using namespace std;

int main() {
    stack<int> s;
    s.push(10);
    s.push(20);
    s.push(30);
    
    s.pop();  // 30 हटेगा
    cout << "Top element: " << s.top();  // 20
    return 0;
}

व्यूह (Array) के प्रकार:

• एक-आयामी व्यूह (1D Array): तत्वों की एक पंक्ति। उदाहरण: int arr[5] = {1, 2, 3, 4, 5};
• द्वि-आयामी व्यूह (2D Array): पंक्तियों और स्तंभों का मैट्रिक्स। उदाहरण: int mat[2][3] = {{1,2,3}, {4,5,6}};
• बहु-आयामी व्यूह (Multi-dimensional Array): तीन या अधिक आयाम। उदाहरण: int arr[2][2][2];

UPDATE कमांड: SQL में मौजूदा रिकॉर्ड को संशोधित करने के लिए उपयोग होता है।

सिंटैक्स:

UPDATE table_name
SET column1 = value1, column2 = value2
WHERE condition;

उदाहरण: मान लीजिए Students तालिका है:

UPDATE Students
SET Age = 20
WHERE Name = 'Rahul';

यह Rahul की Age को 20 में बदल देगा।

OR गेट: यह लॉजिकल OR ऑपरेशन करता है। आउटपुट 1 होता है यदि कम से कम एक इनपुट 1 हो।

Truth Table:

बूलियन एक्सप्रेशन: Y = A + B

सरलीकरण:

Y = AB' + (AC)' + A'B'C'
  = AB' + (A' + C') + A'B'C'   [डी मॉर्गन नियम: (AC)' = A' + C']
  = AB' + A' + C' + A'B'C'
  = A' + AB' + C' + A'B'C'
  = A' + B' + C' + A'B'C'      [A' + AB' = A' + B' (एब्जॉर्प्शन नियम)]
  = A' + B' + C'               [A'B'C' पहले से ही A' + B' + C' में शामिल है]

सरल रूप: Y = A' + B' + C'

FTP (File Transfer Protocol) एक मानक नेटवर्क प्रोटोकॉल है जिसका उपयोग क्लाइंट और सर्वर के बीच इंटरनेट पर फाइलों को स्थानांतरित करने के लिए किया जाता है। यह TCP/IP पर आधारित है और डेटा ट्रांसफर के लिए पोर्ट 20 और कंट्रोल कनेक्शन के लिए पोर्ट 21 का उपयोग करता है। FTP उपयोगकर्ताओं को फाइलों को अपलोड, डाउनलोड, डिलीट और रीनेम करने की अनुमति देता है।

ट्रांसमिशन मीडिया को दो मुख्य श्रेणियों में बांटा गया है:

1. गाइडेड मीडिया (Wired): इसमें सिग्नल एक भौतिक माध्यम से यात्रा करते हैं। उदाहरण: ट्विस्टेड पेयर केबल, कोएक्सियल केबल, फाइबर ऑप्टिक केबल।
2. अनगाइडेड मीडिया (Wireless): इसमें सिग्नल बिना किसी भौतिक माध्यम के वायु या अंतरिक्ष के माध्यम से यात्रा करते हैं। उदाहरण: रेडियो तरंगें, माइक्रोवेव, इन्फ्रारेड तरंगें।

रिलेशनल डेटा मॉडल डेटा को तालिकाओं (रिलेशन) के रूप में संग्रहीत करता है। प्रत्येक तालिका में पंक्तियाँ (टुपल्स) और स्तंभ (एट्रीब्यूट्स) होते हैं। यह मॉडल डेटा की अखंडता और संबंधों को बनाए रखने के लिए प्राथमिक कुंजी और विदेशी कुंजी का उपयोग करता है। इसका उपयोग RDBMS (जैसे MySQL, Oracle) में किया जाता है।

सेलेक्शन सॉर्ट एक सरल सॉर्टिंग एल्गोरिदम है। इसमें सबसे छोटा (या सबसे बड़ा) तत्व ढूंढकर उसे पहले स्थान पर रखा जाता है, फिर शेष सूची में से अगला सबसे छोटा तत्व ढूंढकर दूसरे स्थान पर रखा जाता है। यह प्रक्रिया तब तक दोहराई जाती है जब तक पूरी सूची सॉर्ट नहीं हो जाती। इसकी समय जटिलता O(n²) है।

ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग (OOP) की मूल अवधारणाएँ निम्नलिखित हैं:

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

C++ में तीन प्रकार के एक्सेस मॉडिफायर होते हैं:

1. public: क्लास के बाहर से भी सदस्यों तक पहुंचा जा सकता है।
2. private: केवल उसी क्लास के सदस्य फंक्शन ही इन तक पहुंच सकते हैं।
3. protected: क्लास के सदस्य फंक्शन और व्युत्पन्न क्लास (derived class) के सदस्य फंक्शन ही इन तक पहुंच सकते हैं।

#include <iostream>
using namespace std;

class Triangle {
private:
    float base, height;
public:
    void setData(float b, float h) {
        base = b;
        height = h;
    }
    float calculateArea() {
        return 0.5 * base * height;
    }
};

int main() {
    Triangle t;
    float b, h;
    cout << "Enter base and height: ";
    cin >> b >> h;
    t.setData(b, h);
    cout << "Area of triangle: " << t.calculateArea() << endl;
    return 0;
}

व्याख्या: इस प्रोग्राम में Triangle नामक क्लास बनाई गई है जिसमें base और height निजी सदस्य हैं। setData() फंक्शन मान सेट करता है और calculateArea() फंक्शन क्षेत्रफल की गणना करता है। मुख्य फंक्शन में उपयोगकर्ता से इनपुट लेकर परिणाम प्रदर्शित किया जाता है।

अर्थमेटिक ऑपरेटर (Arithmetic Operators): ये गणितीय संक्रियाएँ करते हैं।

• + (जोड़), - (घटाव), * (गुणा), / (भाग), % (मॉड्यूलस)

रिलेशनल ऑपरेटर (Relational Operators): ये दो मानों की तुलना करते हैं और बूलियन मान (true/false) लौटाते हैं।

• == (बराबर), != (बराबर नहीं), > (से बड़ा), < (से छोटा), >= (से बड़ा या बराबर), <= (से छोटा या बराबर)

दो एक-विमीय रैखिक व्यूहों का सश्रृंखलन (Merging of two 1-D arrays):

दो एक-विमीय सारणियों (arrays) को मर्ज करने का अर्थ है उन्हें एक नई सारणी में इस प्रकार जोड़ना कि परिणामी सारणी में दोनों सारणियों के सभी अवयव क्रमबद्ध रूप से (यदि सारणियाँ क्रमबद्ध हैं) या बिना क्रम के (यदि सारणियाँ अक्रमबद्ध हैं) आ जाएँ।

मर्जिंग की प्रक्रिया:

1. दो सारणियाँ A और B लें, जिनके आकार क्रमशः m और n हैं।
2. एक नई सारणी C बनाएँ जिसका आकार m + n होगा।
3. यदि सारणियाँ क्रमबद्ध हैं:
   • दो सूचकांक i और j को 0 पर सेट करें।
   • A[i] और B[j] की तुलना करें, छोटे वाले को C में डालें और संबंधित सूचकांक बढ़ाएँ।
   • जब तक दोनों सारणियों के सभी अवयव न आ जाएँ, यह प्रक्रिया दोहराएँ।
4. यदि सारणियाँ अक्रमबद्ध हैं, तो पहले A के सभी अवयव C में डालें, फिर B के सभी अवयव C में डालें।

उदाहरण: A = [2, 5, 8], B = [3, 7, 9] → मर्ज करने पर C = [2, 3, 5, 7, 8, 9]

C++ प्रोग्राम:

#include <iostream>
using namespace std;

int main() {
    int a[4][4], b[4][4], sum[4][4];
    int i, j;

    // पहली सारणी के तत्व इनपुट करें
    cout << "पहली 4x4 सारणी के तत्व दर्ज करें:" << endl;
    for(i = 0; i < 4; i++) {
        for(j = 0; j < 4; j++) {
            cin >> a[i][j];
        }
    }

    // दूसरी सारणी के तत्व इनपुट करें
    cout << "दूसरी 4x4 सारणी के तत्व दर्ज करें:" << endl;
    for(i = 0; i < 4; i++) {
        for(j = 0; j < 4; j++) {
            cin >> b[i][j];
        }
    }

    // दोनों सारणियों का योग
    for(i = 0; i < 4; i++) {
        for(j = 0; j < 4; j++) {
            sum[i][j] = a[i][j] + b[i][j];
        }
    }

    // परिणाम प्रदर्शित करें
    cout << "दोनों सारणियों का योग:" << endl;
    for(i = 0; i < 4; i++) {
        for(j = 0; j < 4; j++) {
            cout << sum[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

व्याख्या: इस प्रोग्राम में पहले दो 4×4 पूर्णांक सारणियाँ a और b घोषित की गई हैं। उपयोगकर्ता से दोनों सारणियों के तत्व इनपुट लिए जाते हैं। फिर एक तीसरी सारणी sum में a और b के संगत तत्वों का योग संग्रहीत किया जाता है। अंत में परिणामी सारणी को प्रदर्शित किया जाता है।