ISC Class 12 Computer Science Board Exam Question Paper 2016 with Solutions

ISC Class 12 Computer Science Board Exam Question Paper 2016 with Solutions

Part - I (20 Marks)

Question 1.

(a) State Involution law and prove it with the help of a truth table. [1]

Answer:
The Involution law states that double negation of a variable is equal to the variable itself, i.e., \(\bar{\bar{x}} = x\).
Truth Table:
x | \(\bar{x}\) | \(\bar{\bar{x}}\)
0 | 1 | 0
1 | 0 | 1

Teacher's Note:
a) The involution law shows that applying a NOT operation twice returns the original logical value.
b) Ensure the truth table clearly shows intermediate negation columns and the final output column matching the input.

(b) Show that X ∨ ~ (Y ∧ X) is a tautology. [1]

Answer:
Truth table verification:
X | Y | Y ∧ X | ~ (Y ∧ X) | X ∨ ~ (Y ∧ X)
0 | 0 | 0 | 1 | 1
0 | 1 | 0 | 1 | 1
1 | 0 | 0 | 1 | 1
1 | 1 | 1 | 0 | 1
Since the final column contains only 1s, the expression is a tautology.

Teacher's Note:
a) A tautology is a Boolean expression that evaluates to true (1) for all possible combinations of truth values of its variables.
b) Check each step carefully while evaluating conjunctions and negations to avoid arithmetic row errors.

(c) Find the dual of [1]
YX + X' + 1 = 1

Answer:
To find the dual, replace AND (∧) with OR (∨), OR (∨) with AND (∧), 1 with 0, and 0 with 1.
Dual expression: (Y + X) . X' . 0 = 0

Teacher's Note:
a) Dual of a Boolean expression is obtained by interchanging operators (+ and .) and identity elements (0 and 1).
b) Do not complement the literals while finding the dual; only operators and constants change.

(d) Write the maxterm and minterm, when the inputs are A = 0, B = 1, C = 1 and D = 0. [1]

Answer:
Minterm = \(\bar{A}BC\bar{D}\)
Maxterm = \(A + \bar{B} + \bar{C} + D\)

Answer:
A NAND gate can be constructed from a combination of 4 NOR gates.

[Figure: Logic diagram showing inputs connected to two NOR gates functioning as NOT gates, whose outputs feed into another pair of NOR gates configured to realize a NAND operation]

Teacher's Note:
a) Universal gates like NOR and NAND can implement any Boolean function or basic gate.
b) Clearly label inputs and gate connections in logic diagrams.

Question 2.

(a) Define the term fall through the condition with reference to switch () case. [2]

Answer:
Fall through occurs when execution flows from one case label into the next case in a switch statement because the break statement is omitted. While useful in intentional shared logic, unintentional fall through causes logical bugs.

Teacher's Note:
a) Always include a break statement at the end of each case block unless deliberate fall through is required.
b) Mentioning debugging consequences fetches full credit.

(b) Convert the following infix expression into postfix form: [2]
A + B / C * (D/E * F)

Answer:
AB/C+DEF*/*

Teacher's Note:
a) Apply operator precedence rules strictly (parentheses first, then multiplication and division from left to right, then addition).
b) Double-check intermediate conversions to ensure proper operand pairing.

(c) A matrix A[m] [n] is stored with each element requiring 4 bytes of storage. If the base address at A[1] [1] is 1500 and the address at A [4] [5] is 1608, determine the number of rows of the matrix when the matrix is stored in Column Major Wise. [2]

Answer:
Given base address \(B = 1500\), \(w = 4\), \(i = 4\), \(j = 5\), base index \(R_0 = 1, C_0 = 1\), Address = \(1608\).
Column major formula: Address = \(B + w \times ((i - R_0) + (j - C_0) \times m)\)
\(1608 = 1500 + 4 \times ((4 - 1) + (5 - 1) \times m)\)
\(108 = 4 \times (3 + 4m)\)
\(27 = 3 + 4m \implies 4m = 24 \implies m = 6\).
Number of rows = 6.

Teacher's Note:
a) Remember the column major address calculation formula depends on the number of rows \(m\).
b) Substitute lower bounds correctly as specified by the starting indices \(A[1][1]\).

(d) From the class declaration given below, state the nature of the identifiers A, B, C and D: [2]
class A extends B implements C, D

Answer:
Class A is a subclass derived from superclass B, and C and D are interfaces implemented by class A.

[Figure: Tree hierarchy diagram showing A extending B, and C, D as implemented interfaces]

Teacher's Note:
a) The keyword extends denotes inheritance from a class, while implements denotes interface implementation.
b) Clearly distinguish between class inheritance and interface implementation.

(e) State one advantage and one disadvantage of using recursion over iteration. [2]

Answer:
Advantage: Recursion makes code shorter, cleaner, and easier to write for problems defined recursively (like tree traversals or tower of Hanoi).
Disantage: Recursion consumes extra memory on the call stack for every recursive call, making it slower and susceptible to stack overflow errors compared to iteration.

Teacher's Note:
a) Highlight memory overhead and readability differences.
b) Concise and precise comparison points ensure full marks.

Question 3.

The following function Check() is a part of some class. What will the function Check() return when the values of both ‘m’ and ‘n’ is equal to 5? Show the dry run/working. [5]
int Check (int m, int n)
{
if(n = = 1)
return - m --;
else
return + + m + Check (m, -- n);
}

Answer:
Dry run for Check(5, 5):
1. n != 1, goes to else: returns ++m + Check(m, --n) -> m becomes 6, n becomes 4, evaluates ++6 + Check(6, 4).
2. Check(6, 4): n != 1, returns ++m + Check(m, --n) -> m becomes 7, n becomes 3, evaluates ++7 + Check(7, 3).
3. Check(7, 3): n != 1, returns ++m + Check(m, --n) -> m becomes 8, n becomes 2, evaluates ++8 + Check(8, 2).
4. Check(8, 2): n != 1, returns ++m + Check(m, --n) -> m becomes 9, n becomes 1, evaluates ++9 + Check(9, 1).
5. Check(9, 1): n == 1, returns -m-- -> returns -9, and m becomes 8.
Summing up: 7 + 8 + 9 + 10 + (-9) = 25.

Teacher's Note:
a) Trace pre-increment and pre-decrement operators carefully at each recursive step.
b) Pay close attention to how variable values mutate across recursive activation records.

Part - II (50 Marks)

Section - A

Question 4.

(a) Given the Boolean function F (A, B, C, D) = Σ (1, 3, 5, 7, 8, 9, 10, 11, 14, 15).
(i) Reduce the above expression by using 4-variable Karnaugh map, showing the various groups (i.e. octal, quads and pairs). [4]
(ii) Draw the logic gate diagram for the reduced expression. Assume that the variables and their complements are available as inputs. [1]

Answer:
(i) K-Map reduction yields four quads:
\(\bar{A}D + CD + \bar{A}B + AC\)

[Figure: 4-variable K-Map showing minterms 1, 3, 5, 7, 8, 9, 10, 11, 14, 15 grouped into four quads]

(ii) Logic gate diagram for \(\bar{A}D + CD + \bar{A}B + AC\).

[Figure: Logic diagram with 4 AND gates and 1 OR gate taking inputs A, \(\bar{A}\), B, C, D]

Teacher's Note:
a) Form the largest possible groupings (quads) to achieve minimal expression.
b) Verify all minterms are covered by at least one group.

(b) Given the Boolean function:
F (A, B, C, D) = π (4, 6, 7, 10, 11, 12, 14, 15)
(i) Reduce the above expression by using the 4-variable Karnaugh map, showing the various groups (i.e., octal, quads and pairs). [4]
(ii) Draw the logic gate diagram for the reduced expression. Assume that the variables and their complements are available as inputs. [1]

Answer:
(i) K-map reduction for Product of Sums (POS):
\(BC + AC + B\bar{C}\bar{D}\)

[Figure: K-Map showing maxterm groupings for POS expression]

(ii) Logic diagram for the reduced POS expression.

[Figure: Logic circuit diagram for \(BC + AC + B\bar{C}\bar{D}\)]

Teacher's Note:
a) For Product of Sums (π), map 0s on the Karnaugh map.
b) Combine adjacent 0s into quads and pairs to write the simplified POS expression.

Question 5.

(a) What is a decoder? Draw the logic diagram for a binary to octal (3 to 8) decoder. [3]

Answer:
A decoder is a combinatorial circuit that converts binary information from \(n\) input lines to \(2^n\) unique output lines. For a 3-to-8 decoder, 3 input lines produce 8 distinct outputs.

[Figure: Logic diagram of a 3-to-8 binary decoder showing 3 inputs (\(S_2, S_1, S_0\)) with NOT gates and 8 AND gates producing outputs \(Q_0\) to \(Q_7\)]

Teacher's Note:
a) Clearly define the input-to-output conversion principle of decoders.
b) Ensure all 8 output minterm lines are correctly drawn using AND gates.

(b) How is a half adder different from a full adder? Draw the truth table and derive the SUM and CARRY expression for a full adder. Also, draw the logic diagram for a full adder. [4]

Answer:
Difference: A half adder adds two bits and produces SUM and CARRY, whereas a full adder adds three bits (two inputs and a previous carry) and produces SUM and CARRY.
Full Adder Truth Table & Derivations:
SUM = \(X \oplus Y \oplus Z\)
CARRY = \(XZ + YZ + ZX\)

[Figure: Truth table for Full Adder and logic diagram containing XOR and AND/OR gates for SUM and CARRY]

Teacher's Note:
a) Emphasize that the full adder includes the carry-in bit from a previous addition stage.
b) Standard algebraic expressions for SUM and CARRY must be written clearly.

(c) State whether the following expression is a Tautology, Contradiction or a Contingency, with the help of a truth table:
(X=>Z)∨~[(X=>Y)∧(Y=>Z)] [3]

Answer:
Truth table evaluation yields true (1) for all input combinations.
Therefore, it is a tautology.

[Figure: Complete truth table verifying the tautology expression across all variables X, Y, Z]

Teacher's Note:
a) Replace implication \(A \implies B\) with \(\bar{A} + B\) to simplify truth table evaluation.
b) Conclude clearly whether the final column represents a tautology, contradiction, or contingency.

Question 6.

(a) A passenger is allotted a window seat in an aircraft if he/she satisfies the criteria given below: [5]
The passenger is below 15 years and is accompanied by an adult.
or
The passenger is a lady and is not accompanied by an adult.
or
The passenger is not below 15 years but is travelling for the first time
The inputs are:
A: The passenger is below 15 years age.
C: The passenger is accompanied by an adult.
L: The passenger is a lady.
F: The passenger is travelling for the first time.
(In all the above cases 1 indicates yes and 0 indicates no).
Output: W - Denotes the passenger is allotted a window seat (1 indicates yes and 0 indicates no)
Draw the truth table for the inputs and outputs given above and write the SOP expression for W(A, C, L, F).

Answer:
Truth table and SOP expression derived from the given conditions:
W(A, C, L, F) = \(\bar{A}\bar{C}L\bar{F} + \bar{A}\bar{C}LF + \bar{A}C\bar{L}F + \bar{A}CLF + A\bar{C}\bar{L}F + A\bar{C}LF + AC\bar{L}\bar{F} + AC\bar{L}F + ACL\bar{F} + ACLF\)

[Figure: Complete truth table for 4 inputs A, C, L, F and output W]

Teacher's Note:
a) Break down each condition into standard minterms based on logical AND/OR translations.
b) Verify truth table entries carefully against every problem statement criterion.

(b) State the complement properties. Find the complement of the following Boolean expression using De Morgan's law: [3]
AB' + A' + BC

Answer:
Complement property states that \(X \cdot \bar{X} = 0\) and \(X + \bar{X} = 1\).
Complement of \(AB' + A' + BC\):
\(= \overline{AB' + A' + BC}\)
\(= \overline{AB'} \cdot \overline{A'} \cdot \overline{BC}\)
\(= (\bar{A} + B) \cdot A \cdot (\bar{B} + \bar{C})\)

Teacher's Note:
a) De Morgan's laws state that \(\overline{X + Y} = \bar{X} \cdot \bar{Y}\) and \(\overline{X \cdot Y} = \bar{X} + \bar{Y}\).
b) Apply double complement elimination wherever applicable during simplification.

(c) Differentiate between Canonical form and Cardinal form of expression. [2]

Answer:
Canonical form: A Boolean expression expressed explicitly as a sum of minterms or product of maxterms where every variable appears in each term.
Cardinal form: A compact representation of a Boolean function represented using summation of minterm indices or product of maxterm indices (e.g., \(\Sigma(1, 3)\)).

Teacher's Note:
a) Canonical forms list all variables explicitly in each product/sum term.
b) Cardinal forms use shorthand numerical notations like \(\Sigma\) or \(\pi\).

Section - B

Question 7.

A disarium number is a number in which the sum of the digits to the power of their respective position is equal to the number itself. [10]
Example: 135 = 1¹ + 3² + 5³
Hence, 135 is a disarium number.
Design a class Disarium to check if a given number is a disarium number or not. Some of the members of the class are given below:
Class name: Disarium
Data members/instance variables:
int num: stores the number
int size: stores the size of the number
Methods/Member functions:
Disarium (int nn): parameterized constructor to initialize the data members n = nn and size = 0
void countDigit(): counts the total number of digits and assigns it to size
int sumofDigits (int n, int p): returns the sum of the digits of the number(n) to the power of their respective positions (p) using recursive technique
void check(): checks whether the number is a disarium number and displays the result with an appropriate message
Specify the class Disarium giving the details of the constructor, void countDigit(), int sumofDigits(int, int) and void check(). Define the main() function to create an object and call the functions accordingly to enable the task.

Answer:

import java.io.*;
class Disarium
{
    int num;
    int size;
    Disarium(int nn)
    {
        num = nn;
        size = 0;
    }
    void countDigit()
    {
        int temp = num;
        while(temp > 0)
        {
            size++;
            temp = temp / 10;
        }
    }
    int sumofDigits(int n, int p)
    {
        if(n == 0)
            return 0;
        int d = n % 10;
        return (int)Math.pow(d, p) + sumofDigits(n / 10, p - 1);
    }
    void check()
    {
        countDigit();
        int sum = sumofDigits(num, size);
        if(sum == num)
            System.out.println(num + " is a Disarium number.");
        else
            System.out.println(num + " is not a Disarium number.");
    }
    public static void main(String args[]) throws IOException
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.print("Enter a number: ");
        int n = Integer.parseInt(br.readLine());
        Disarium ob = new Disarium(n);
        ob.check();
    }
}

Teacher's Note:
a) Ensure the recursive function decreases the position index correctly as digits are extracted from right to left or left to right.
b) Verify constructor initialization and object instantiation in main().

Question 8.

A class Shift contains a two-dimensional integer array of order (m×n) where the maximum values of both m and n are 5. Design the class Shift to shuffle the matrix (i.e. the first row becomes the last, the second row becomes the first and so on). The details of the members of the class are given below: [10]
Class name: Shift
Data member/instance variable:
mat[][]: stores the array element
m: integer to store the number of rows
n: integer to store the number of columns
Member functions/methods:
Shift(int mm, int nn): parameterized constructor to initialize the data members m=mm and n=nn
void input(): enters the elements of the array
void cyclic(Shift p): enables the matrix of the object (P) to shift each row upwards in a cyclic manner and store the resultant matrix in the current object
void display(): displays the matrix elements
Specify the class Shift giving details of the constructor, void input(), void cyclic(Shift) and void display(). Define the main() function to create an object and call the methods accordingly to enable the task of shifting the array elements.

Answer:

import java.io.*;
class Shift
{
    int mat[][];
    int m, n;
    Shift(int mm, int nn)
    {
        m = mm;
        n = nn;
        mat = new int[m][n];
    }
    void input() throws IOException
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Enter elements of the matrix:");
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                mat[i][j] = Integer.parseInt(br.readLine());
            }
        }
    }
    void cyclic(Shift p)
    {
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(i == 0)
                    this.mat[m - 1][j] = p.mat[i][j];
                else
                    this.mat[i - 1][j] = p.mat[i][j];
            }
        }
    }
    void display()
    {
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                System.out.print(mat[i][j] + "\t");
            }
            System.out.println();
        }
    }
    public static void main(String args[]) throws IOException
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.print("Enter rows and columns: ");
        int r = Integer.parseInt(br.readLine());
        int c = Integer.parseInt(br.readLine());
        Shift obj1 = new Shift(r, c);
        Shift obj2 = new Shift(r, c);
        obj1.input();
        obj2.cyclic(obj1);
        System.out.println("Shifted Matrix:");
        obj2.display();
    }
}

Teacher's Note:
a) Object passing in the cyclic method requires accessing the source matrix elements via the parameter object `p` and storing them into `this` object.
b) Check boundary index conditions for row shifting accurately.

Question 9.

A class ConsChange has been defined with the following details: [10]
Class name: ConsChange
Data members/instance variables:
word: stores the word
len: stores the length of the word
Member functions/methods:
ConsChange(): default constructor
void readword(): accepts the word in lowercase
void shiftcons(): shifts all the consonants of the word at the beginning followed by the vowels (e.g. spoon becomes spnoo)
void changeword(): changes the case of all occurring consonants of the shifted word to uppercase, for e.g. (spnoo becomes SPNoo)
void show(): displays the original word, shifted word and the changed word
Specify the class ConsChange giving the details of the constructor, void readword(), void shiftcons(), void changeword() and void show(). Define the main() function to create an object and call the functions accordingly to enable the task.

Answer:

import java.io.*;
class ConsChange
{
    String word, shifted, changed;
    int len;
    ConsChange()
    {
        word = "";
        shifted = "";
        changed = "";
        len = 0;
    }
    void readword() throws IOException
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.print("Enter a word in lowercase: ");
        word = br.readLine().trim().toLowerCase();
        len = word.length();
    }
    void shiftcons()
    {
        String cons = "";
        String vowel = "";
        for(int i = 0; i < len; i++)
        {
            char ch = word.charAt(i);
            if(ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
                vowel += ch;
            else
                cons += ch;
        }
        shifted = cons + vowel;
    }
    void changeword()
    {
        changed = "";
        for(int i = 0; i < len; i++)
        {
            char ch = shifted.charAt(i);
            if(ch != 'a' && ch != 'e' && ch != 'i' && ch != 'o' && ch != 'u')
                changed += Character.toUpperCase(ch);
            else
                changed += ch;
        }
    }
    void show()
    {
        System.out.println("Original word: " + word);
        System.out.println("Shifted word: " + shifted);
        System.out.println("Changed word: " + changed);
    }
    public static void main(String args[]) throws IOException
    {
        ConsChange ob = new ConsChange();
        ob.readword();
        ob.shiftcons();
        ob.changeword();
        ob.show();
    }
}

Teacher's Note:
a) Separate string accumulations for vowels and consonants make shifting straightforward.
b) Use `Character.toUpperCase()` carefully when modifying consonant cases.

Section - C

Question 10.

A superclass Bank has been defined to store the details of a customer. Define a sub-class Account that enables transactions for the customer with the bank. The details of both the classes are given below: [5]
Class name: Bank
Data members/instance variables:
name: stores the name of the customer
accno: stores the account number
P: stores the principal amount in decimals
Member functions/methods:
Bank(...): parameterized constructor to assign values to the instance variables
void display(): displays the details of the customer
Class name: Account
Data member/instance variable:
amt: stores the transaction amount in decimals
Member functions/methods:
Account(...): parameterized constructor to assign values to the instance variables of both the classes
void deposit(): accepts the amount and updates the principal as p=p+amt
void withdraw(): accepts the amount and updates the principal as p=p-amt
If the withdrawal amount is more than the principal amount, then display the message "INSUFFICIENT BALANCE".
If the principal amount after withdrawal is less than 500, then a penalty is imposed by using the formula.
p=p-(500-p)/10
void display(): displays the details of the customer
Assume that the superclass Bank has been defined.
Using the concept of Inheritance; specify the class Account giving details of the constructor(...), void deposit(), void withdraw() and void display() The superclass and the main function need not be written.

Answer:

class Account extends Bank
{
    double amt;
    Account(String n, long ac, double principal, double amount)
    {
        super(n, ac, principal);
        amt = amount;
    }
    void deposit()
    {
        P = P + amt;
    }
    void withdraw()
    {
        if(amt > P)
        {
            System.out.println("INSUFFICIENT BALANCE");
        }
        else
        {
            P = P - amt;
            if(P < 500)
            {
                P = P - (500 - P) / 10.0;
            }
        }
    }
    void display()
    {
        super.display();
        System.out.println("Transaction Amount: " + amt);
        System.out.println("Updated Principal: " + P);
    }
}

Teacher's Note:
a) Use the `super` keyword to invoke the parameterized constructor of the superclass and to call superclass methods.
b) Implement withdrawal validations and penalty calculations exactly as specified in the formula.

Question 11.

A bookshelf is designed to store the books in a stack with LIFO (Last In First Out) operation. Define a class Book with the following specifications: [5]
Class name: Book
Data members/instance variables:
name[]: stores the names of the books
point: stores the index of the topmost book
max: stores the maximum capacity of the bookshelf
Methods/Member functions:
Book(int cap): constructor to initialise the data members max = cap and point = -1
void tell(): displays the name of the book which was last entered in the shelf. If there is no book left in the shelf, displays the message "SHELF EMPTY"
void add(String v): adds the name of the book to the shelf if possible, otherwise displays the message 'SHELF FULL"
void display(): displays all the names of the books available on the shelf
Specify the class Book giving the details of ONLY the functions void tell() and void add(String). Assume that the other functions have been defined.
The main function need not be written.

Answer:

class Book
{
    String name[];
    int point, max;
    Book(int cap)
    {
        max = cap;
        point = -1;
        name = new String[max];
    }
    void tell()
    {
        if(point == -1)
            System.out.println("SHELF EMPTY");
        else
            System.out.println("Last entered book: " + name[point]);
    }
    void add(String v)
    {
        if(point == max - 1)
            System.out.println("SHELF FULL");
        else
            name[++point] = v;
    }
}

Teacher's Note:
a) Stack overflow condition occurs when `point == max - 1`, and underflow occurs when `point == -1`.
b) Use pre-increment `++point` when pushing elements onto the stack.

Question 12.

(a) A linked list is formed from the objects of the class Node. The class structure of the Node is given below: [2]
class Node
{
String name;
Node next;
}
Write an Algorithm OR a Method to search for a given name in the linked list. The method of the declaration is given below:
boolean search name(Node start, String v)

Answer:

boolean searchname(Node start, String v)
{
    if(start == null)
        return false;
    if(start.name.equalsIgnoreCase(v))
        return true;
    return searchname(start.next, v);
}

Teacher's Note:
a) Recursive traversal checks base condition (null pointer) and match condition before proceeding to the next node.
b) `equalsIgnoreCase()` ensures robust string matching.

(b) Answer the following questions from the diagram of a Binary Tree given below:

[Figure: Binary tree structure with root node A, left child B with descendants D, F, J; and right child C with descendants E, G, H, I]

(i) Write the inorder traversal of the above tree structure. [1]
(ii) Name the parent of nodes B and G [1]
(iii) Name the leaves of the right sub-tree. [1]

Answer:
(i) Inorder traversal (Left, Root, Right): F, D, J, B, A, E, H, G, C, I
(ii) Parent of node B is A; parent of node G is E.
(iii) Leaves of the right sub-tree are H and I.

Teacher's Note:
a) Inorder traversal visits left subtree, root, then right subtree recursively.
b) Leaf nodes are terminal nodes with no children.