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

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

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

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

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

Database Schema: यह डेटाबेस की संरचना का एक लॉजिकल डिज़ाइन है जो टेबल्स, उनके कॉलम, डेटा टाइप्स, रिलेशनशिप्स और कंस्ट्रेंट्स को परिभाषित करता है। यह डेटाबेस के ब्लूप्रिंट की तरह होता है और इसे तीन स्तरों में बांटा जाता है: फिजिकल, लॉजिकल और व्यू स्कीमा।

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

Recursion Function Conditions:

1. Base Case: एक ऐसी शर्त जो रिकर्शन को समाप्त करती है (जैसे n == 0 या n == 1)।
2. Recursive Case: फंक्शन स्वयं को छोटे इनपुट के साथ कॉल करता है, जो बेस केस की ओर बढ़ता है।
3. Progress: प्रत्येक रिकर्सिव कॉल में इनपुट साइज कम होना चाहिए ताकि अनंत लूप से बचा जा सके।

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

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

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

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

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

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

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

SELECT column1, column2 FROM table_name WHERE condition;

यह डेटा को फ़िल्टर, सॉर्ट और ग्रुप करने की सुविधा भी प्रदान करता है।

MySQL में नया यूजर बनाने की कमांड:

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

उदाहरण:

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

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

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

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

• BEFORE ट्रिगर: ऑपरेशन से पहले निष्पादित होता है।
• AFTER ट्रिगर: ऑपरेशन के बाद निष्पादित होता है।
• INSTEAD OF ट्रिगर: व्यू पर ऑपरेशन के लिए उपयोग होता है।

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

PL/SQL में तीन प्रकार के एक्सेप्शन:

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

प्रोग्राम (Quick Sort in C):

#include <stdio.h>

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

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

Stack (स्टैक) के उपयोग: Stack एक LIFO (Last In First Out) डेटा संरचना है। इसके प्रमुख उपयोग निम्नलिखित हैं:

• Function Calls (फंक्शन कॉल): प्रोग्राम में फंक्शन कॉल को मैनेज करने के लिए stack का उपयोग होता है। जब कोई फंक्शन कॉल किया जाता है, तो उसका return address और local variables stack पर push होते हैं, और फंक्शन समाप्त होने पर pop होते हैं।
• Expression Evaluation (एक्सप्रेशन मूल्यांकन): इनफिक्स, पोस्टफिक्स और प्रीफिक्स एक्सप्रेशन को evaluate करने में stack का उपयोग होता है।
• Undo/Redo Operations: टेक्स्ट एडिटर या सॉफ्टवेयर में undo/redo कार्यों के लिए stack का उपयोग किया जाता है।
• Backtracking (बैकट्रैकिंग): जैसे Maze solving, N-Queens problem आदि में stack का उपयोग होता है।
• Syntax Parsing: कंपाइलर में syntax checking और parsing के लिए stack का उपयोग होता है।
• Browser History: वेब ब्राउज़र में पिछले पेज पर जाने के लिए stack का उपयोग होता है।

लिंक लिस्ट में नोड डिलीट करना: लिंक लिस्ट में नोड को डिलीट करने के तीन मुख्य केस होते हैं:

1. पहले नोड को डिलीट करना: head को head->next पर सेट करें और पुराने head को free करें।
2. बीच के नोड को डिलीट करना: डिलीट होने वाले नोड के पिछले नोड के next pointer को डिलीट होने वाले नोड के next पर सेट करें, फिर नोड को free करें।
3. अंतिम नोड को डिलीट करना: अंतिम नोड के पिछले नोड के next को NULL सेट करें और अंतिम नोड को free करें।

उदाहरण (C code):

void deleteNode(struct Node** head_ref, int key) {
    struct Node *temp = *head_ref, *prev = NULL;
    // यदि पहला नोड ही डिलीट करना है
    if (temp != NULL && temp->data == key) {
        *head_ref = temp->next;
        free(temp);
        return;
    }
    // बीच या अंत का नोड ढूंढें
    while (temp != NULL && temp->data != key) {
        prev = temp;
        temp = temp->next;
    }
    if (temp == NULL) return; // key नहीं मिली
    prev->next = temp->next;
    free(temp);
}

पैरामीटराइज्ड कंस्ट्रक्टर: वह कंस्ट्रक्टर जो पैरामीटर (arguments) लेता है, पैरामीटराइज्ड कंस्ट्रक्टर कहलाता है। इसका उपयोग ऑब्जेक्ट बनाते समय अलग-अलग initial values देने के लिए किया जाता है।

उदाहरण (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

प्रोग्राम (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 m1, m2, m3;
    cout << "Matrix 1:" << endl;
    m1.input();
    cout << "Matrix 2:" << endl;
    m2.input();
    m3 = m1 + m2;
    cout << "Sum of matrices:" << endl;
    m3.display();
    return 0;
}

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

E-R Diagram for School Management System

Entities and Symbols:

• Rectangle (Entity): Represents real-world objects like Student, Teacher, Class, Subject.
• Ellipse (Attribute): Describes properties of entities, e.g., Student_Name, Teacher_ID.
• Diamond (Relationship): Shows association between entities, e.g., Enrolls (Student-Class), Teaches (Teacher-Subject).
• Line (Connector): Links entities to relationships and attributes.
• Double Ellipse (Multivalued Attribute): Holds multiple values, e.g., Phone_Numbers of a student.
• Underlined Attribute (Primary Key): Uniquely identifies each entity instance, e.g., Student_ID.

Example Diagram Structure:

    [Student] ----< Enrolls >---- [Class]
       |                              |
   (Student_ID)                  (Class_ID)
   (Name)                        (Section)
   (Phone_Numbers)
  

Utility of Each Symbol:

• Rectangle: Defines core data objects.
• Ellipse: Provides detailed information about entities.
• Diamond: Clarifies how entities interact.
• Lines: Ensure structural clarity.
• Double Ellipse: Handles attributes with multiple instances.
• Underline: Ensures uniqueness and efficient data retrieval.

OR

Second Normal Form (2NF) with Example

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

Example:

Unnormalized Table (Student_Course):

Problem: Primary key is (Student_ID, Course_ID). Student_Name depends only on Student_ID (partial dependency).

Convert to 2NF:

Table 1: Student

Table 2: Course

Table 3: Enrollment

Result: All non-key attributes now fully depend on the primary key, satisfying 2NF.

Multiple Inheritance with Example

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();
    }
};

int main() {
    ScholarAthlete sa;
    sa.display();  // Output: StudyingPlaying
    return 0;
}
  

Explanation: The class ScholarAthlete inherits from both Student and Athlete, gaining access to both study() and play() methods. This allows combining behaviors from multiple sources.

Note: Multiple inheritance can lead to ambiguity (diamond problem) if not handled carefully, often resolved using virtual inheritance in C++.

OR

Memory Allocation and Management Functions in C

Dynamic Memory Allocation Functions:

• malloc(size_t size): Allocates a block of memory of given size (in bytes) and returns a void pointer to it. Memory is uninitialized.
• calloc(size_t num, size_t size): Allocates memory for an array of num elements, each of size bytes, and initializes all bits to zero.
• realloc(void *ptr, size_t new_size): Resizes a previously allocated memory block pointed by ptr to new_size. May move the block to a new location.
• free(void *ptr): Deallocates the memory previously allocated by malloc, calloc, or realloc, making it available for future allocations.

Example:

#include <stdlib.h>
int *arr = (int*) malloc(5 * sizeof(int));  // allocate array of 5 ints
if (arr != NULL) {
    arr[0] = 10;
    free(arr);  // free memory
}
  

Key Points:

• Always check if allocation returns NULL (failure).
• Use free() to avoid memory leaks.
• Include <stdlib.h> for these functions.