RBSE Class 12th 2020 (Supp.)-SS-02-2020 Previous Year Papers

Static Member Function: यह एक ऐसा सदस्य फंक्शन है जो किसी क्लास के सभी ऑब्जेक्ट्स के लिए साझा होता है। इसे static कीवर्ड से घोषित किया जाता है और यह केवल स्टैटिक डेटा मेम्बर्स तक ही पहुँच सकता है। इसे क्लास के नाम से सीधे कॉल किया जा सकता है, बिना ऑब्जेक्ट बनाए।

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

उत्तर: :: (स्कोप रिज़ॉल्यूशन ऑपरेटर), . (डॉट ऑपरेटर), .* (पॉइंटर टू मेंबर ऑपरेटर), ?: (टर्नरी ऑपरेटर), sizeof, और # (प्रीप्रोसेसर ऑपरेटर) को ओवरलोड नहीं किया जा सकता। उदाहरण के लिए, डॉट ऑपरेटर (.) को ओवरलोड नहीं किया जा सकता।

Multi-valued Attribute: यह एक ऐसा एट्रीब्यूट है जिसमें एक ही एंटिटी के लिए एक से अधिक मान हो सकते हैं। उदाहरण के लिए, किसी व्यक्ति के फोन नंबर (एक व्यक्ति के कई फोन नंबर हो सकते हैं) या किसी कर्मचारी के कौशल (एक कर्मचारी के कई कौशल हो सकते हैं)। इसे डेटाबेस में अलग टेबल या कंपोजिट एट्रीब्यूट के रूप में दर्शाया जाता है।

Database Schema: यह डेटाबेस की संरचना का एक खाका (blueprint) होता है जो यह परिभाषित करता है कि डेटा कैसे संगठित किया जाएगा, जैसे टेबल्स, कॉलम्स, डेटा टाइप्स, रिलेशनशिप्स, और कंस्ट्रेंट्स। यह डेटाबेस के लॉजिकल डिज़ाइन को दर्शाता है और डेटा को स्टोर करने का तरीका बताता है।

Time Complexity: यह किसी एल्गोरिदम के चलने में लगने वाले समय का माप है, जो इनपुट साइज (n) के फंक्शन के रूप में व्यक्त किया जाता है। यह बताता है कि इनपुट बढ़ने पर एल्गोरिदम का समय कितनी तेजी से बढ़ता है। इसे आमतौर पर बिग-ओ नोटेशन (जैसे O(n), O(n²), O(log n)) में दर्शाया जाता है।

Recursion Function Conditions:

1. Base Case: एक ऐसी शर्त होनी चाहिए जो रिकर्शन को रोक दे, अन्यथा फंक्शन अनंत बार कॉल होता रहेगा।
2. Recursive Case: फंक्शन को स्वयं को कॉल करना चाहिए, लेकिन हर कॉल में समस्या का आकार छोटा होना चाहिए ताकि अंततः बेस केस तक पहुँचा जा सके।
3. Progress Towards Base Case: हर रिकर्सिव कॉल में इनपुट या समस्या का आकार कम होना चाहिए, जिससे बेस केस तक पहुँचना सुनिश्चित हो।

In-place Sorting: यह एक सॉर्टिंग तकनीक है जिसमें डेटा को सॉर्ट करने के लिए अतिरिक्त मेमोरी की आवश्यकता नहीं होती (या बहुत कम, जैसे O(1) या O(log n) अतिरिक्त स्पेस)। इसमें एलिमेंट्स को उसी ऐरे या डेटा स्ट्रक्चर में पुनर्व्यवस्थित किया जाता है। उदाहरण: बबल सॉर्ट, इंसर्शन सॉर्ट, क्विक सॉर्ट (कुछ वेरिएंट)।

Structure (संरचना): इसमें सभी सदस्यों के लिए अलग-अलग मेमोरी स्थान आवंटित होते हैं। सभी सदस्यों को एक साथ एक्सेस किया जा सकता है। कुल मेमोरी सभी सदस्यों के आकार के योग के बराबर होती है।

Union (यूनियन): इसमें सभी सदस्य एक ही मेमोरी स्थान साझा करते हैं। एक समय में केवल एक सदस्य को एक्सेस किया जा सकता है। कुल मेमोरी सबसे बड़े सदस्य के आकार के बराबर होती है।

स्कोप रिजोलुशन ऑपरेटर (::) का उपयोग निम्नलिखित कार्यों के लिए किया जाता है:

• किसी क्लास के बाहर उसके सदस्य फंक्शन को परिभाषित करने के लिए।
• ग्लोबल वेरिएबल को एक्सेस करने के लिए जब लोकल वेरिएबल का नाम समान हो।
• स्टैटिक वेरिएबल या फंक्शन को एक्सेस करने के लिए।
• नेमस्पेस में परिभाषित सदस्यों को एक्सेस करने के लिए।

फ्रेंड फंक्शन का उपयोग किसी क्लास के प्राइवेट और प्रोटेक्टेड डेटा सदस्यों को क्लास के बाहर से एक्सेस करने के लिए किया जाता है। यह क्लास का सदस्य नहीं होता, लेकिन इसे क्लास के अंदर friend कीवर्ड से घोषित किया जाता है। इसका उपयोग दो या अधिक क्लासों के बीच डेटा साझा करने और ऑपरेटर ओवरलोडिंग में किया जाता है।

SELECT स्टेटमेंट SQL में डेटा को डेटाबेस से पुनर्प्राप्त (retrieve) करने के लिए उपयोग किया जाता है। यह एक या अधिक तालिकाओं से डेटा को चुनने और प्रदर्शित करने की अनुमति देता है। इसका सामान्य सिंटैक्स है:

SELECT column1, column2, ... FROM table_name WHERE condition;

यह WHERE क्लॉज, ORDER BY, GROUP BY, और JOIN जैसे विभिन्न क्लॉज के साथ उपयोग किया जा सकता है।

MySQL में नया यूजर बनाने के लिए निम्नलिखित कमांड का उपयोग किया जाता है:

CREATE USER 'username'@'host' IDENTIFIED BY 'password';

उदाहरण:

CREATE USER 'raj'@'localhost' IDENTIFIED BY 'mypassword';

यह 'raj' नाम का एक नया यूजर बनाएगा जो केवल localhost से कनेक्ट हो सकता है और जिसका पासवर्ड 'mypassword' होगा।

कॉल-बाय वेल्यू (Call by Value): इसमें फंक्शन को आर्गुमेंट की एक कॉपी भेजी जाती है। फंक्शन के अंदर किए गए बदलाव मूल वेरिएबल को प्रभावित नहीं करते। यह डिफ़ॉल्ट तरीका है।

कॉल-बाय रेफरेंस (Call by Reference): इसमें फंक्शन को आर्गुमेंट का एड्रेस (reference) भेजा जाता है। फंक्शन के अंदर किए गए बदलाव मूल वेरिएबल को प्रभावित करते हैं। C++ में इसे & ऑपरेटर का उपयोग करके किया जाता है।

PL/SQL में ट्रिगर एक स्टोर्ड प्रोग्राम है जो किसी तालिका पर INSERT, UPDATE, या DELETE जैसी घटना (event) होने पर स्वचालित रूप से निष्पादित होता है। ट्रिगर निम्नलिखित प्रकार के होते हैं:

• BEFORE ट्रिगर: घटना से पहले निष्पादित होता है।
• AFTER ट्रिगर: घटना के बाद निष्पादित होता है।
• INSTEAD OF ट्रिगर: घटना के स्थान पर निष्पादित होता है (मुख्यतः व्यू पर)।

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

PL/SQL में तीन प्रकार के exceptions (अपवाद) निम्नलिखित हैं:

1. प्रीडिफाइंड एक्सेप्शन (Predefined Exceptions): ये PL/SQL द्वारा पूर्वनिर्धारित होते हैं, जैसे NO_DATA_FOUND, TOO_MANY_ROWS, ZERO_DIVIDE आदि।
2. यूजर-डिफाइंड एक्सेप्शन (User-defined Exceptions): ये प्रोग्रामर द्वारा अपनी आवश्यकता के अनुसार परिभाषित किए जाते हैं।
3. अनहैंडल्ड एक्सेप्शन (Unhandled Exceptions): ये वे अपवाद हैं जिन्हें प्रोग्राम में हैंडल नहीं किया गया है और ये OTHERS हैंडलर द्वारा पकड़े जाते हैं।

प्रोग्राम (C भाषा में):

#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = (low - 1);
    for (int j = low; j <= high - 1; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++)
        printf("%d ", arr[i]);
    printf("\n");
}

int main() {
    int arr[] = {4, 6, 3, 2, 1, 9, 7};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("Original array: ");
    printArray(arr, n);
    quickSort(arr, 0, n - 1);
    printf("Sorted array: ");
    printArray(arr, n);
    return 0;
}

आउटपुट: 1 2 3 4 6 7 9

व्याख्या: त्वरित सॉर्ट (Quick Sort) एक डिवाइड और कॉन्कर एल्गोरिथम है। इसमें एक पिवट चुनकर ऐरे को दो भागों में बांटा जाता है, फिर प्रत्येक भाग को पुनरावृत्ति (recursion) से सॉर्ट किया जाता है।

स्टैक (Stack) के उपयोग:

• फंक्शन कॉल और रिटर्न एड्रेस: प्रोग्राम में फंक्शन कॉल करने पर रिटर्न एड्रेस और लोकल वेरिएबल स्टैक में स्टोर होते हैं।
• एक्सप्रेशन इवैल्यूएशन: इनफिक्स, पोस्टफिक्स और प्रीफिक्स एक्सप्रेशन को हल करने में स्टैक का उपयोग होता है।
• रिकर्सन: रिकर्सिव फंक्शन कॉल को मैनेज करने के लिए स्टैक का उपयोग होता है।
• अंडू/रीडू (Undo/Redo): एडिटर या सॉफ्टवेयर में पिछली क्रिया को पूर्ववत करने के लिए स्टैक का उपयोग होता है।
• पार्सिंग: HTML, XML या कोड पार्स करने में स्टैक का उपयोग होता है।
• बैकट्रैकिंग: मेज़ या पज़ल सॉल्व करने में स्टैक का उपयोग होता है।

स्टैक LIFO (Last In First Out) सिद्धांत पर काम करता है।

लिंक लिस्ट में नोड डिलीट करने के चरण:

1. डिलीट करने वाले नोड को ढूंढें: लिस्ट को ट्रैवर्स करके उस नोड को खोजें जिसे डिलीट करना है।
2. पिछले नोड का पता लगाएं: डिलीट होने वाले नोड के पिछले नोड (previous node) को पहचानें।
3. लिंक को अपडेट करें: पिछले नोड के next पॉइंटर को डिलीट होने वाले नोड के next नोड पर सेट करें।
4. नोड को फ्री करें: डिलीट किए गए नोड की मेमोरी को free() फंक्शन से मुक्त करें।

उदाहरण (C भाषा में):

void deleteNode(struct Node** head, int key) {
    struct Node *temp = *head, *prev = NULL;
    if (temp != NULL && temp->data == key) {
        *head = temp->next;
        free(temp);
        return;
    }
    while (temp != NULL && temp->data != key) {
        prev = temp;
        temp = temp->next;
    }
    if (temp == NULL) return;
    prev->next = temp->next;
    free(temp);
}

ध्यान दें: यदि हेड नोड डिलीट हो रहा है तो हेड को अपडेट करना आवश्यक है।

पैरामीटराइज्ड कंस्ट्रक्टर: वह कंस्ट्रक्टर जो आर्गुमेंट लेता है, उसे पैरामीटराइज्ड कंस्ट्रक्टर कहते हैं। इसका उपयोग ऑब्जेक्ट को इनिशियलाइज़ करने के लिए अलग-अलग मान देने में होता है।

उदाहरण (C++ में):

#include <iostream>
using namespace std;

class Student {
    int rollNo;
    string name;
public:
    // पैरामीटराइज्ड कंस्ट्रक्टर
    Student(int r, string n) {
        rollNo = r;
        name = n;
    }
    void display() {
        cout << "Roll No: " << rollNo << ", Name: " << name << endl;
    }
};

int main() {
    Student s1(101, "Rahul");
    Student s2(102, "Priya");
    s1.display();
    s2.display();
    return 0;
}

आउटपुट:
Roll No: 101, Name: Rahul
Roll No: 102, Name: Priya

व्याख्या: यहाँ Student क्लास का कंस्ट्रक्टर दो पैरामीटर (rollNo और name) लेता है, जिससे अलग-अलग ऑब्जेक्ट को अलग-अलग मान दे सकते हैं।

प्रोग्राम (C++ में ऑपरेटर ओवरलोडिंग के साथ):

#include <iostream>
using namespace std;

class Matrix {
    int arr[2][3];
public:
    void input() {
        cout << "Enter 6 elements (2x3 matrix): ";
        for (int i = 0; i < 2; i++)
            for (int j = 0; j < 3; j++)
                cin >> arr[i][j];
    }
    void display() {
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++)
                cout << arr[i][j] << " ";
            cout << endl;
        }
    }
    // बाइनरी + ऑपरेटर ओवरलोडिंग
    Matrix operator+(Matrix m) {
        Matrix temp;
        for (int i = 0; i < 2; i++)
            for (int j = 0; j < 3; j++)
                temp.arr[i][j] = arr[i][j] + m.arr[i][j];
        return temp;
    }
};

int main() {
    Matrix A, B, C;
    cout << "Matrix A:" << endl;
    A.input();
    cout << "Matrix B:" << endl;
    B.input();
    C = A + B;  // ऑपरेटर ओवरलोडिंग का उपयोग
    cout << "Sum of matrices:" << endl;
    C.display();
    return 0;
}

आउटपुट (दिए गए मैट्रिक्स के लिए):
Sum of matrices:
8 10 12
5 7 9

व्याख्या: operator+ फंक्शन को ओवरलोड करके दो मैट्रिक्स ऑब्जेक्ट को जोड़ा गया है। यह प्रत्येक संबंधित एलिमेंट को जोड़कर नई मैट्रिक्स लौटाता है।

Solution (E-R Diagram for School Management System):

E-R Diagram Symbols and Their Utility:

• Rectangle (Entity): Represents a real-world object or concept, e.g., Student, Teacher, Class, Subject.
• Ellipse (Attribute): Describes properties of an entity, e.g., Student_Name, Roll_No, Teacher_ID.
• Diamond (Relationship): Shows association between entities, e.g., "Enrolls" between Student and Class.
• Line (Connector): Links entities to attributes or relationships.
• Double Ellipse (Multivalued Attribute): An attribute with multiple values, e.g., Phone_Numbers for a student.
• Underlined Attribute (Primary Key): Uniquely identifies each entity instance, e.g., Student_ID.

Example E-R Diagram for School Management System:

    [Student] ---- (Enrolls) ---- [Class]
       |                              |
   (Roll_No)                     (Class_ID)
   (Name)                        (Section)
   (Address)                     (Teacher_ID)
  

Utility: The E-R diagram helps in designing the database structure by clearly defining entities, their attributes, and relationships, ensuring data integrity and efficient querying.

Alternative Solution (Second Normal Form - 2NF):

Definition: A table is in Second Normal Form (2NF) if it is in 1NF and every non-key attribute is fully functionally dependent on the primary key (i.e., no partial dependency).

Example:

Consider a table Student_Course with attributes: Student_ID, Course_ID, Student_Name, Course_Name, Grade.

Primary Key: (Student_ID, Course_ID)

Here, Student_Name depends only on Student_ID (partial dependency), and Course_Name depends only on Course_ID (partial dependency). This violates 2NF.

To convert to 2NF:

• Student table: Student_ID (PK), Student_Name
• Course table: Course_ID (PK), Course_Name
• Enrollment table: Student_ID (FK), Course_ID (FK), Grade (PK: composite)

Now, all non-key attributes are fully dependent on the primary key, satisfying 2NF.

Solution (Multiple Inheritance):

Definition: Multiple inheritance is a feature in object-oriented programming where a class can inherit properties and methods from more than one parent class.

Example (C++):

class Student {
public:
    void study() { cout << "Studying"; }
};

class Athlete {
public:
    void play() { cout << "Playing"; }
};

class ScholarAthlete : public Student, public Athlete {
public:
    void display() {
        study();
        play();
    }
};
  

Here, ScholarAthlete inherits from both Student and Athlete, allowing it to use methods from both base classes.

Note: Multiple inheritance can lead to ambiguity (diamond problem) if not handled carefully.

Alternative Solution (Memory Allocation Functions in C):

Functions for Memory Allocation and Management in C:

• malloc(): Allocates a block of memory of specified size (in bytes) and returns a void pointer. Example: int *p = (int*)malloc(5 * sizeof(int));
• calloc(): Allocates memory for an array of elements, initializes all bytes to zero. Example: int *p = (int*)calloc(5, sizeof(int));
• realloc(): Resizes previously allocated memory block. Example: p = (int*)realloc(p, 10 * sizeof(int));
• free(): Deallocates previously allocated memory to prevent memory leaks. Example: free(p);

Explanation: These functions are defined in <stdlib.h> and are used for dynamic memory management, allowing programs to allocate and free memory at runtime as needed.

Speech on Child Labour in India

Good morning, respected Principal, teachers, and dear friends. Today, I stand before you to speak about a grave issue – child labour in India. Child labour robs children of their childhood, education, and dreams. Millions of children are forced to work in hazardous conditions instead of going to school. This is a violation of their basic rights. As responsible citizens, we must raise awareness, support education, and report such cases. Let us pledge to build a nation where every child is free to learn, play, and grow. Thank you.

Article on Importance of Games and Sports

Games and sports are an essential part of life. They keep us physically fit, mentally alert, and teach us teamwork, discipline, and leadership. Regular participation in sports improves concentration, reduces stress, and builds character. In schools, sports should be given equal importance as academics. They help in overall personality development. A healthy mind resides in a healthy body. Therefore, every student must take part in games and sports to lead a balanced and successful life.

All the birds belong to the poet because he does not trap them or set any snare to catch them. He lets them fly freely in the sky. His love and respect for their freedom make them feel at home, and thus they belong to him.

The poet wants to convey that true ownership comes from love, care, and freedom, not from capturing or confining. We should respect nature and all living beings, allowing them to live freely. Only then can we truly enjoy their beauty and presence.

Hope helps a bud by giving it the strength to stay on the branch and bloom. It is the optimistic expectation of becoming a beautiful flower that motivates the bud to grow and flourish.

Trees lose their leaves with the hope that one day they will be ladened with green hues again. This shedding is a natural process driven by the hope of renewal and fresh growth in the coming season.