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

उत्तर: बाइनरी सर्च की समय जटिलता O(log n) होती है, जहाँ n तत्वों की संख्या है।

Answer: The time complexity of Binary Search is O(log n), where n is the number of elements.

उत्तर: इन प्लेस सॉर्टिंग का एक उदाहरण बबल सॉर्ट (Bubble Sort) है।

Answer: An example of In place Sorting is Bubble Sort.

उत्तर: Stack एक रैखिक डेटा संरचना है जो LIFO (Last In First Out) सिद्धांत पर कार्य करती है, जिसमें तत्वों का सम्मिलन और निष्कासन केवल एक सिरे (Top) से होता है।

Answer: Stack is a linear data structure that works on the LIFO (Last In First Out) principle, where insertion and deletion of elements occur only at one end (Top).

उत्तर: Breadth first traversal में Queue डेटा स्ट्रक्चर का उपयोग किया जाता है।

Answer: Queue data structure is used in Breadth first traversal.

उत्तर: की वर्डस (Keywords) वे आरक्षित शब्द हैं जिनका C++ में पूर्वनिर्धारित अर्थ होता है और इन्हें वेरिएबल या फंक्शन के नाम के रूप में उपयोग नहीं किया जा सकता। उदाहरण: int, if, else, while, class, etc.

Answer: Keywords are reserved words that have predefined meanings in C++ and cannot be used as variable or function names. Examples: int, if, else, while, class, etc.

उत्तर: new ऑपरेटर का उपयोग डायनामिक मेमोरी आवंटन (Dynamic Memory Allocation) के लिए किया जाता है, जो रन टाइम पर मेमोरी आवंटित करता है और आवंटित मेमोरी का पता (address) लौटाता है।

Answer: The new operator is used for dynamic memory allocation, which allocates memory at runtime and returns the address of the allocated memory.

उत्तर: फंक्शन प्रोटोटाईप एक घोषणा है जो फंक्शन के नाम, वापसी प्रकार (return type) और पैरामीटर की संख्या व प्रकार को निर्दिष्ट करती है, बिना फंक्शन के शरीर (body) को परिभाषित किए। यह कंपाइलर को फंक्शन कॉल को सही ढंग से जांचने में मदद करता है।

Answer: A function prototype is a declaration that specifies the function's name, return type, and the number and types of parameters, without defining the function body. It helps the compiler to check function calls correctly.

उपयोग: इनलाइन फंक्शन का उपयोग प्रोग्राम की कार्यक्षमता (performance) को बढ़ाने के लिए किया जाता है। जब किसी फंक्शन को इनलाइन घोषित किया जाता है, तो कंपाइलर फंक्शन कॉल के स्थान पर फंक्शन के कोड को सीधे रख देता है, जिससे फंक्शन कॉल का ओवरहेड (overhead) समाप्त हो जाता है और प्रोग्राम तेजी से चलता है।

Use: The inline function is used to improve the performance of a program. When a function is declared inline, the compiler places the function's code directly at the point of the function call, eliminating the overhead of the function call and making the program run faster.

डिस्ट्रक्टर: डिस्ट्रक्टर एक विशेष सदस्य फंक्शन है जो क्लास के ऑब्जेक्ट के नष्ट होने पर स्वचालित रूप से कॉल होता है। इसका नाम क्लास के नाम के समान होता है और इसके आगे टिल्ड (~) चिह्न लगा होता है। डिस्ट्रक्टर का उपयोग ऑब्जेक्ट द्वारा उपयोग किए गए संसाधनों (जैसे मेमोरी, फाइल हैंडल) को मुक्त करने के लिए किया जाता है।

Destructor: A destructor is a special member function that is automatically called when an object of a class is destroyed. Its name is the same as the class name, preceded by a tilde (~). The destructor is used to release resources (such as memory, file handles) used by the object.

बहुमान एट्रीब्यूट (Multivalued Attribute): वह एट्रीब्यूट जिसमें एक एंटिटी के लिए एक से अधिक मान हो सकते हैं, बहुमान एट्रीब्यूट कहलाता है।

उदाहरण:

1. किसी व्यक्ति के फोन नंबर (Phone Number) - एक व्यक्ति के कई फोन नंबर हो सकते हैं।
2. किसी कर्मचारी के कौशल (Skills) - एक कर्मचारी के पास कई कौशल हो सकते हैं (जैसे प्रोग्रामिंग, डिजाइनिंग, टेस्टिंग)।

Normalization के उद्देश्य (Objectives of Normalization):

1. डेटा रिडंडेंसी (Data Redundancy) को कम करना - अनावश्यक डेटा की पुनरावृत्ति को समाप्त करना।
2. डेटा इंटीग्रिटी (Data Integrity) को बनाए रखना - डेटा की सटीकता और स्थिरता सुनिश्चित करना।
3. एनोमली (Anomalies) को समाप्त करना - इंसर्शन, अपडेशन और डिलीशन एनोमली को दूर करना।
4. डेटाबेस को अधिक कुशल और लचीला बनाना।

GRANT कमाण्ड का उपयोग: SQL में GRANT कमाण्ड का उपयोग डेटाबेस उपयोगकर्ताओं को विशेष अनुमतियाँ (permissions) प्रदान करने के लिए किया जाता है। इसके माध्यम से हम उपयोगकर्ताओं को टेबल, व्यू, या अन्य डेटाबेस ऑब्जेक्ट्स पर SELECT, INSERT, UPDATE, DELETE, ALTER आदि ऑपरेशन करने की अनुमति दे सकते हैं। यह डेटाबेस सुरक्षा (database security) के लिए महत्वपूर्ण है।

Use of GRANT Command: The GRANT command in SQL is used to provide specific permissions to database users. Through this, we can grant users permission to perform operations like SELECT, INSERT, UPDATE, DELETE, ALTER on tables, views, or other database objects. It is important for database security.

ट्रिगर (Trigger) एक विशेष प्रकार की संग्रहीत प्रक्रिया (stored procedure) है जो डेटाबेस में किसी घटना (जैसे INSERT, UPDATE, DELETE) होने पर स्वचालित रूप से निष्पादित होती है। इसका उपयोग डेटा की अखंडता बनाए रखने, व्यावसायिक नियमों को लागू करने और ऑडिट ट्रेल बनाने के लिए किया जाता है।

प्रोग्राम:

#include <stdio.h>
int main() {
    int n = 8, t1 = 0, t2 = 1, nextTerm;
    printf("Fibonacci Series: ");
    for (int i = 1; i <= n; ++i) {
        printf("%d, ", t1);
        nextTerm = t1 + t2;
        t1 = t2;
        t2 = nextTerm;
    }
    return 0;
}

आउटपुट: Fibonacci Series: 0, 1, 1, 2, 3, 5, 8, 13

नोट: दी गई श्रृंखला (0 1 2 3 5 8 13 21) में तीसरा पद 2 है, जो वास्तविक फिबोनैकी श्रृंखला (0,1,1,2,3,5,8,13) से भिन्न है। उपरोक्त प्रोग्राम मानक फिबोनैकी श्रृंखला उत्पन्न करता है।

कॉपी कंस्ट्रक्टर एक विशेष प्रकार का कंस्ट्रक्टर है जो किसी ऑब्जेक्ट को उसी क्लास के किसी अन्य ऑब्जेक्ट से प्रारंभ (initialize) करने के लिए उपयोग किया जाता है। यह ऑब्जेक्ट की एक प्रतिलिपि (copy) बनाता है।

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

#include <iostream>
using namespace std;

class Student {
    int roll;
public:
    Student(int r) { roll = r; }  // Parameterized constructor
    Student(const Student &s) {   // Copy constructor
        roll = s.roll;
        cout << "Copy constructor called" << endl;
    }
    void display() { cout << "Roll: " << roll << endl; }
};

int main() {
    Student s1(101);
    Student s2 = s1;  // Copy constructor called
    s1.display();
    s2.display();
    return 0;
}

व्याख्या: जब s2 = s1 लिखा जाता है, तो कॉपी कंस्ट्रक्टर स्वचालित रूप से कॉल होता है और s2 में s1 की प्रतिलिपि बन जाती है।

एब्सट्रैक्ट क्लास वह क्लास होती है जिसमें कम से कम एक शुद्ध वर्चुअल फंक्शन (pure virtual function) होता है। इसका कोई ऑब्जेक्ट नहीं बनाया जा सकता; इसका उपयोग केवल बेस क्लास के रूप में किया जाता है, जिससे अन्य क्लासेज़ इनहेरिट कर सकें।

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

#include <iostream>
using namespace std;

class Shape {  // Abstract class
public:
    virtual void draw() = 0;  // Pure virtual function
};

class Circle : public Shape {
public:
    void draw() { cout << "Drawing Circle" << endl; }
};

class Rectangle : public Shape {
public:
    void draw() { cout << "Drawing Rectangle" << endl; }
};

int main() {
    Shape *s;
    Circle c;
    Rectangle r;
    s = &c;  s->draw();
    s = &r;  s->draw();
    return 0;
}

व्याख्या: Shape एक एब्सट्रैक्ट क्लास है क्योंकि इसमें शुद्ध वर्चुअल फंक्शन draw() है। Circle और Rectangle क्लासेज़ draw() को ओवरराइड करती हैं।

त्वरित सॉर्ट (Quick Sort) एक विभाजन-आधारित (divide-and-conquer) सॉर्टिंग एल्गोरिथम है। इसमें एक पिवट (pivot) तत्व चुनकर सूची को दो भागों में विभाजित किया जाता है: पिवट से छोटे तत्व बाईं ओर और बड़े तत्व दाईं ओर। फिर इन दोनों उप-सूचियों पर पुनरावृत्ति (recursion) द्वारा यही प्रक्रिया दोहराई जाती है।

उदाहरण: सूची [10, 7, 8, 9, 1, 5] को सॉर्ट करें।

1. चरण 1: पिवट = 5 (अंतिम तत्व)
2. चरण 2: विभाजन: [1, 5, 7, 8, 9, 10] (1 < 5, बाकी > 5)
3. चरण 3: बाईं उप-सूची [1] – पहले से सॉर्टेड
4. चरण 4: दाईं उप-सूची [7, 8, 9, 10] – पिवट = 10, विभाजन: [7, 8, 9, 10]
5. चरण 5: पुनरावृत्ति जारी रखें – अंततः सॉर्टेड सूची: [1, 5, 7, 8, 9, 10]

समय जटिलता: औसत स्थिति O(n log n), सबसे खराब स्थिति O(n²)।

मर्ज सॉर्ट (Merge Sort) एक विभाजन-आधारित सॉर्टिंग एल्गोरिथम है जो सूची को बार-बार आधा-आधा विभाजित करता है जब तक कि प्रत्येक उप-सूची में केवल एक तत्व न रह जाए, फिर उन्हें क्रमबद्ध रूप में मर्ज करता है।

उदाहरण: सूची [38, 27, 43, 3, 9, 82, 10] को सॉर्ट करें।

1. चरण 1: विभाजन: [38, 27, 43, 3] और [9, 82, 10]
2. चरण 2: आगे विभाजन: [38, 27], [43, 3], [9, 82], [10]
3. चरण 3: और विभाजन: [38], [27], [43], [3], [9], [82], [10]
4. चरण 4: मर्ज: [27, 38], [3, 43], [9, 82], [10]
5. चरण 5: मर्ज: [3, 27, 38, 43], [9, 10, 82]
6. चरण 6: अंतिम मर्ज: [3, 9, 10, 27, 38, 43, 82]

समय जटिलता: सभी स्थितियों में O(n log n)।

SQL Query Syntax:

1. GREATEST: SELECT GREATEST(value1, value2, ...); — Returns the largest value from a list of expressions.
2. ADDDATE: SELECT ADDDATE(date, INTERVAL value unit); — Adds a time interval to a date.
3. NOW: SELECT NOW(); — Returns the current date and time.
4. COUNT: SELECT COUNT(column_name) FROM table_name; — Returns the number of rows that match a specified condition.

Foreign Key Integrity Constraints are rules that maintain the consistency and accuracy of data between two related tables in a database. A foreign key in one table points to a primary key in another table. The constraints ensure that:

• No orphan records exist (i.e., a foreign key value must match a primary key value in the referenced table or be NULL).
• Referential integrity is maintained, meaning you cannot delete or update a record in the parent table if it is referenced by a foreign key in the child table (unless cascading actions are defined).
• Data remains consistent across related tables.

Example: In a Orders table, CustomerID is a foreign key referencing CustomerID in the Customers table. The constraint ensures that every order belongs to an existing customer.

3NF (Third Normal Form) is a level of database normalization that reduces data redundancy and avoids anomalies. A relation is in 3NF if:

• It is in 2NF (Second Normal Form).
• There is no transitive dependency of non-prime attributes on the primary key. In other words, every non-prime attribute is non-transitively dependent on every candidate key.

Necessary condition for a relation schema to be in BCNF (Boyce-Codd Normal Form):

• For every functional dependency X → Y, X must be a superkey. This means that the left-hand side of every functional dependency must be a candidate key.

Note: The question mentions "BNF" which is likely a typo for "BCNF" (Boyce-Codd Normal Form).

Components of E-R (Entity-Relationship) Model:

1. Entity: A real-world object or thing (e.g., Student, Employee). Represented by a rectangle.
2. Attribute: Properties of an entity (e.g., Name, Age). Represented by an ellipse.
3. Relationship: Association between entities (e.g., Enrolls, Works). Represented by a diamond.
4. Key Attribute: Uniquely identifies an entity (e.g., Student_ID). Underlined in the diagram.
5. Multivalued Attribute: Can have multiple values (e.g., Phone_Numbers). Represented by a double ellipse.
6. Derived Attribute: Derived from other attributes (e.g., Age from Date_of_Birth). Represented by a dashed ellipse.

Diagram (Text Representation):

        [Student] ---- (Enrolls) ---- [Course]
           |                              |
      (Student_ID)                   (Course_ID)
      (Name)                         (Title)
      (Age)                          (Credits)

Note: In a proper diagram, rectangles represent entities, diamonds represent relationships, and ellipses represent attributes.