Solved 2024 Sample Question Paper CBSE Class 12 Computer Science (083)

False

Reason — In a Python program, if a break statement is given in a nested loop, it only terminates the execution of the innermost loop where the break statement is encountered. It does not affect the outer loops or any remaining loops in the nested structure.

6, 20

Reason — The datatype VARCHAR(20) is a variable-length character string that can store up to 20 characters. When "Keshav" (6 characters) is assigned to attribute A with VARCHAR(20), it occupies only 6 characters of storage space because VARCHAR adjusts the space based on the actual data length. The datatype CHAR(20) is a fixed-length character string that always occupies the specified amount of space, in this case, 20 characters. When "Meenakshi" (9 characters) is assigned to attribute B with CHAR(20), it still occupies all 20 characters of storage space because CHAR pads the data with spaces to fill up the allocated space, even if the actual data is shorter.

-244.0

Reason — In Python, both ** (exponentiation) and / (division) operators have the same level of precedence, which means they are evaluated from left to right if they appear together without parentheses. However, the exponentiation operator ** is right-associative, which means it is evaluated from right to left. In the given expression print(3 - 2 ** 2 ** 3 + 99 / 11), the innermost exponentiation (2 ** 3) is evaluated first, followed by the outer exponentiation (2 ** 8). Then subtracting the result of the exponentiation from 3, 3 − 256 = −253, then adding the result of the division ((99/11) = 9) to the previously calculated value −253 + 9 = −244.0. The expression is evaluated as follows:

3 - 2 ** 2 ** 3 + 99 / 11

= 3 - 2 ** 8 + 99 / 11

= 3 - 256 + 99 / 11

= 3 - 256 + 9.0

= -253 + 9.0

= -244.0

PYTHON-is-Fun

Reason — The code initializes a string variable s with the value 'Python is fun'. It splits the string into words using split() method, then converts the first word to uppercase ('PYTHON') using indexing and the upper() method, and capitalizes the third word ('Fun') with the capitalize() method. It then joins the modified words with a hyphen ('-') as the separator using the join() method and prints the result.

8, 15

Reason — When performing a Cartesian product (cross join) of two tables, the resulting table retains all columns from both tables. Therefore, the degree of the Cartesian product is the sum of the degrees of the two tables i.e., Degree of Alpha + Degree of Beta = 5 + 3 = 8. Similarly, the cardinality of the Cartesian product is the total number of rows resulting from the cross join, which is the product of the cardinalities of the two tables, i.e., Cardinality of Alpha * Cardinality of Beta = 3 * 5 = 15.

PAN

Reason — A personal area network (PAN) is the interconnection of information technology devices within the range of an individual person, typically within 10 meters. Bluetooth technology is used to create PANs for short-range wireless communication between devices. In Riya's case, she is using Bluetooth to connect her mobile phone to her laptop within a range of about 10 meters, forming a PAN (Personal Area Network).

del D1["Red"]

Reason — The syntax to delete a key-value pair from a dictionary in Python is : del dictionary_name[key]. Therefore, according to this syntax, del D1["Red"] is correct statement."

ceieP0

Reason — The code assigns the string "#G20 Presidency" to the variable pride. The slicing operation pride[-2:2:-2] starts from the second last character ("y"), which is at index -2, moves backward by 2 characters at a time due to the step value of -2, and stops before reaching the third character ("G"), which is at index 2. Hence, the output will be 'ceieP0'.

Statement 4

Reason — The statement that would give an error during execution of the given code is Statement 4 (tup[4] = 80). This is because tuples in Python are immutable, meaning we cannot modify the elements of a tuple after it has been created. Here, it is attempting to assign 80 to the element at the index 4 of a tuple, which results in an error because tuples do not support item assignment.

WHITE*
BLACK*

Reason — random.randint(0, 3) will generate a random integer between 0 and 3. Possible outcomes are 0, 1, 2, or 3. Since 0 and 1 would make the loop invalid, we consider 2 and 3.

When myNumber is 2:

The loop for i in range(1, myNumber) will iterate over range(1, 2), which includes only the number 1. The code will print COLOR[1], which is "WHITE", followed by an asterisk (*). So, one of the possible outputs is:
WHITE*

When myNumber is 3:

The loop for i in range(1, myNumber) will iterate over range(1, 3), which includes the numbers 1 and 2. The code will print COLOR[1], which is "WHITE", followed by an asterisk (*), and then move to the next line. Then, it will print COLOR[2], which is "BLACK", followed by an asterisk (*). So, the other possible output is:
WHITE*
BLACK*

Since the output when myNumber is 3 is among the possible outputs, it's the correct answer.

Modulator

Reason — The modem at the sender's computer end acts as a modulator, which is responsible for converting digital data into analog signals for transmission over the communication channel.

global b

Reason — When we want to modify a global variable within a function in Python, we need to use the global keyword followed by the name of the global variable. In this case, since the variable b is declared as a global variable outside the function, we need to declare it as a global variable again inside the function using global b before attempting to modify its value.

True

Reason — An exception can be raised even if the program is syntactically correct. This can happen due to various runtime errors such as division by zero, accessing an index out of range, trying to perform an operation on incompatible data types, etc. These types of errors are detected during the execution of the program and can lead to exceptions being raised, even if the program's syntax is correct.

A candidate key that is not a primary key is a foreign key.

Reason — A candidate key that is not chosen as the primary key remains a candidate key and is not automatically a foreign key.

circuit

seek()

Reason — The seek() function in Python is utilised to relocate the file pointer within a file to a specific position. It also accepts an optional second argument, which denotes the starting point for determining this new position.

Assertion is false but Reason is true.

Reason — List is a mutable data type. When an attempt is made to update the value of an immutable variable, the old variable is destroyed and a new variable with the updated value is created, and the variable name is reassigned to point to this new object in memory.

Both Assertion and Reason are true but Reason is not the correct explanation for Assertion.

Reason — The Python Standard Library is a collection of modules and packages that provide a wide range of functionalities. A function in a module helps to organize code, simplify it, and avoid repetition which makes programming more efficient.

(i) POP3 – Post Office Protocol 3
URL – Uniform Resource Locator

(ii) One difference between XML and HTML:

(i) Bandwidth is the maximum rate of data transfer over a given transmission medium or the amount of information that can be transmitted over a network.

(ii) HTTPS (Hyper Text Transfer Protocol Secure) is the protocol that uses SSL (Secure Socket Layer) to encrypt data being transmitted over the Internet. Therefore, HTTPS helps in secure browsing while HTTP does not.

def revNumber(num):  #correction 1
    rev = 0
    rem = 0
    while num > 0: #correction 2
        rem = num % 10  #correction 3
        rev = rev * 10 + rem
        num = num // 10
    return rev  #correction 4
print(revNumber(1234))

1. correction 1 — The correct keyword to define a function is "def" not "define".
2. correction 2 — Instead of "While" (capital W) in the while loop, it should be "while" (lowercase w).
3. correction 3 — The comparison operator "==" in the line rem == num % 10 should be replaced with the assignment operator "=".
4. correction 4 — Moved the "return" statement outside the while loop to return the reversed number after the loop completes.

PLACES = {1: "Delhi", 2: "London", 3: "Paris", 4: "New York", 5: "Doha"}
def countNow(PLACES):
    for place in PLACES.values():
        if len(place) > 5:
            print(place.upper())
countNow(PLACES)

LONDON  
NEW YORK

4*L
33*4
21*S
10*6

The code initializes variables S, L, and D, representing a string, list, and dictionary, respectively. The code iterates through the indices of string S. If the index is even, it assigns the popped element from list L as a key in dictionary D with the corresponding character from S as its value. If the index is odd, it assigns the popped element from L as a key in D with the value being the index plus 3. This process continues until the loop ends. After the loop, it prints each key-value pair from D, with keys and values separated by "*".

(i)

L1.insert(2, 200)

(ii)

message.endswith('.')

SQL command to add primary key in the table:

ALTER TABLE Employee ADD EmpId INTEGER
PRIMARY KEY ;

SQL command for inserting data will be:

INSERT INTO Employee (EmpId, Ename, Department, Salary)
VALUES (999, "Shweta", "Production", 26900) ;

SQL command to delete the attribute category from the table Sports:

ALTER TABLE Sports
DROP category ;

SQL command to add the attribute TypeSport to the table Sports:

ALTER TABLE Sports
ADD TypeSport char(10) NOT NULL ;

10.0$20
10.0$2.0###

The code snippet provided defines a function Changer that takes two parameters P and Q, where Q is assigned a default value of 10. Inside the function, P is divided by Q and P is assigned the quotient, and then Q is assigned the remainder of P divided by Q. The modified P value is returned from the function. In the main code, variables A and B are initialized with values 200 and 20, respectively. The Changer function is called first with A and B as arguments, modifying the value of A. The updated values of A and B are then printed with a separator of '$'. Next, the Changer function is called again with only B as an argument, updating B. Finally, the updated values of A and B are printed again with a separator of '$' and an end marker of '###'.

ND-*34

The provided Python code initializes a variable Text1 with the string value "IND-23". Then it initializes an empty string variable Text2 and an index variable I with the value 0. The while loop continues as long as I is less than the length of Text1. Within the loop, each character of Text1 is checked: if it's a digit (0-9), it increments the digit by 1 and appends it to Text2; if it's an uppercase letter (A-Z), it appends the next character in Text1 to Text2; otherwise, it appends an asterisk "*". After processing all characters, the final value of Text2 is printed.

(i)

+------------------------+
| COUNT(DISTINCT SPORTS) |
+------------------------+
|                      4 |
+------------------------+

(ii)

+-------+--------+
| CNAME | SPORTS |
+-------+--------+
| AMINA | CHESS  |
+-------+--------+

(iii)

+-------+-----+------+
| CNAME | AGE | PAY  |
+-------+-----+------+
| AMRIT |  28 | 1000 |
| VIRAT |  35 | 1050 |
+-------+-----+------+

The Alpha.txt file includes following data :

You To be or not to be, that is the question.
You The quick brown fox jumps over the lazy dog.
To infinity and beyond!

def test():
    fobj1 = open("Alpha.txt", "r")
    data = fobj1.readlines()
    for line in data:
        L = line.split()
        if L[0] == "You":
            print(line)
    fobj1.close()
test()

You To be or not to be, that is the question.

You The quick brown fox jumps over the lazy dog.

The Poem.txt file includes following data :

The sun sets in the west.
To be successful, one must work hard.

def vowelCount():
    fobj = open("Poem.txt", "r")
    data = str(fobj.read())
    cnt = 0
    for ch in data:
        if ch in "aeiouAEIOU":
            cnt = cnt + 1
    print(cnt)
    fobj.close()
vowelCount()

16

(i)

UPDATE Personal
SET Salary = Salary + Salary * 0.5
WHERE Allowance IS NOT NULL;

(ii)

SELECT Name, Salary + Allowance AS 
"Total Salary" FROM Personal;

(iii)

DELETE FROM Personal
WHERE Salary > 25000;

(i)

NList=[["New York", "U.S.A.", 11734], ["Naypyidaw", "Myanmar", 3219], ["Dubai", "UAE", 2194], ["London", "England", 6693], ["Gangtok", "India", 1580], ["Columbo", "Sri Lanka", 3405]]  
travel = []
def Push_element(NList):
    for L in NList:
        if L[1] != "India" and L[2] < 3500:
            travel.append([L[0], L[1]])
    return travel
print(Push_element(NList))

(ii)

travel = ['Naypyidaw', 'Myanmar'], ['Dubai', 'UAE'], ['Columbo', 'Sri Lanka']
def Pop_element():
    while len(travel):
        print(travel.pop())
    else:
        print("Stack Empty")
Pop_element()

(i)

SELECT PName, BName FROM PRODUCT P, 
BRAND B WHERE P.BID = B.BID;

(ii)

DESC PRODUCT;

(iii)

SELECT BName, AVG(Rating) FROM PRODUCT 
P, BRAND B
WHERE P.BID = B.BID
GROUP BY BName
HAVING BName = 'Medimix' OR 
BName = 'Dove';

(iv)

SELECT PName, UPrice, Rating
FROM PRODUCT
ORDER BY Rating DESC;

Python code to accept records from users :

def Accept():
    sid = int(input("Enter Student ID"))
    sname = input("Enter Student Name")
    game = input("Enter name of game")
    res = input("Enter Result")
    headings = ["Student ID", "Student Name", "Game Name", "Result"]
    data = [sid, sname, game, res]
    f = open('Result.csv', 'a', newline = '')
    csvwriter = csv.writer(f)
    csvwriter.writerow(headings)
    csvwriter.writerow(data)
    f.close()

Python code to count the number of students who have won any event :

def wonCount():
    f = open('Result.csv', 'r')
    csvreader = csv.reader(f, delimiter = ',')
    head = list(csvreader)
    print(head[0])
    for x in head:
        if x[3] == "WON":
            print(x)
    f.close()   

(a) Below diagrams shows the cable layout for connecting CHENNAI campus blocks:

(b) Switch network device will be used to connect computers in each block to form a local area network.

(c) Admin block in chennai Campus should be made the server, as it has maximum number of computers.

(d) Using microwave wireless transmission medium is preferable for connecting the head office in Delhi with the campus in Chennai.

(e) No, a repeater is not required in the given cable layout as the length of transmission medium between any two blocks does not exceed 70m.

(i)

(ii)

def copyData():
    fobj = open("SPORT.DATA", "rb")
    fobj1 = open("BASKET.DAT", "wb")
    cnt = 0
    try:
        while True:
            data = pickle.load(fobj)
            print(data)
            if data[0] == "Basket Ball":
                pickle.dump(data, fobj1)
                cnt +=1
    except:
        fobj.close()
        fobj1.close()
    return cnt

(i)

(ii)

def Searchtype(mtype):
    fobj = open("CINEMA.DAT", "rb")
    try:
        while True:
            data = pickle.load(fobj)
            if data[2] == mtype:
                print("Movie number:", data[0])
                print("Movie Name:", data[1])
                print("Movie Type:", data[2])

    except EOFError:
        fobj.close()

(i) Domain is a set of values from which an attribute can take value in each row.
For example, roll no field can have only integer values and so its domain is a set of integer values.

(ii)

import mysql.connector as mysql
con1 = mysql.connect(host = "localhost",
                     user = "root",
                     password = "tiger",
                     database = "SCHOOL")
mycursor = con1.cursor()
rno = int(input("Enter Roll Number:: "))
name = input("Enter the name:: ")
DOB = input("Enter date of birth:: ")
fee = float(input("Enter Fee:: "))
query = "INSERT into student values({}, '{}', '{}', {})".format(rno, name, DOB, fee)
mycursor.execute(query)
con1.commit()
print("Data added successfully")
con1.close()

(i) One difference between alternate key and candidate key:

(ii)

import mysql.connector as mysql
con1 = mysql.connect(host = "localhost",
                     user = "root",
                     password = "tiger",
                     database = "SCHOOL")
mycursor = con1.cursor()
query = "SELECT * FROM student WHERE fee > {}".format(5000)
mycursor.execute(query)
data = mycursor.fetchall()
for rec in data:
    print(rec)
con1.close()