SCI 2026 Paper Solution

Option A

The CSS Box Model describes how every HTML element is represented as a rectangular box. It consists of four main components:

• Content : The actual text, image, or other content inside the element.
• Padding : The space between the content and the border.
• Border : The line surrounding the padding and content.
• Margin : The space outside the border that separates the element from other elements.

Therefore, from innermost to outermost, the correct order is: Content → Padding → Border → Margin.

CSS Box Model Structure:

Option D

Machine Language is the lowest-level programming language that consists of binary instructions (0s and 1s). These instructions are written in a form that the computer's processor can understand and execute directly.
The CPU (Central Processing Unit) is the actual hardware that fetches, decodes, and executes machine-language instructions.

Option B

A Multiplexer (MUX) is a combinational digital circuit that selects one input from several input lines and sends the selected input to a single output line.
The number of select lines determines how many different input lines can be selected.
If a multiplexer has n select lines, each select line can have two possible values, either 0 or 1. Therefore, n select lines can produce 2ⁿ different combinations.
Each combination selects one input line. Hence, a multiplexer with n select lines can select a maximum of 2ⁿ input lines.

Option B

In Boolean Algebra, every element x has a corresponding complement, represented by x′. The complement has the opposite Boolean value of x.
For a Boolean variable:

• If x = 0, then x′ = 1.
• If x = 1, then x′ = 0.

The two fundamental complement laws of Boolean Algebra are:

• x + x′ = 1
• x · x′ = 0

Option A

PHP is a "loosely typed" language. This means you don't have to declare what type of data a variable hold. PHP figures it out automatically and even converts types on its own when needed. This automatic conversion is called "Type Juggling".
In PHP, the + operator is an arithmetic addition operator. It adds the numeric values of its operands.
$x = "10";
$y = 5;
echo $x + $y;
Here, $x contains the value "10" as a string, while $y contains 5 as an integer.
When PHP sees the + operator, it expects both sides to be numbers. So, if one side is a numeric string (a string that looks like a number like "10"), PHP automatically converts it into a real number before doing the math. 
Therefore, 10+5 = 15. So, the output is 15.

Note:

• In PHP, string joining is done with a dot (.), not +. So $x . $y would give "105", not $x + $y.

Option D

A binary tree can be "visited" in different orders.

• Inorder (Left → Root → Right).
• Preorder (Root → Left → Right).
• Postorder (Left → Right → Root).
• Level-Order (Visit level by level, top to bottom, left to right like BFS).

To uniquely construct a general binary tree, the traversal information must be sufficient to determine both:

• Which node is the root, and
• Which nodes belong to the left and right subtrees.

The Golden Rule:
To uniquely reconstruct a binary tree, you generally need Inorder (provides the left/right subtree boundary) paired with one of Preorder, Postorder, or Level-order.

Why is Postorder + Level-order insufficient?
Consider two different binary trees:

Thus, two different binary trees have exactly the same Postorder and Level-order traversals. Therefore, these two traversals cannot uniquely determine a general binary tree.

Option B

This question tests the difference between a static variable and a local automatic variable in C.
static int s = 1;
int d = 1;

• The s is a static variable, so it is initialized only once and retains its value between function calls.
• The d is a normal local variable, so it is created and initialized to 1 every time the function is called.

Therefore, the complete output is 2 2 3 2 4 2.

Option B

In a Binary Search Tree (BST), the word successor means the node that comes immediately after a given node in a particular order.
The in-order successor of a node is the node that comes immediately after that node in the In-order Traversal of the BST.

The in-order traversal sequence of above tree is 20 → 30 → 40 → 50 → 60 → 70 → 80.
Therefore:
Successor of 20 = 30
Successor of 30 = 40
Successor of 40 = 50
Successor of 50 = 60
Successor of 60 = 70
Successor of 70 = 80
80 has no successor, because it is the largest node.
So, in other word, “in a BST, the in-order successor of a node is the smallest value that is greater than that node” (किसी node से बड़ी values में सबसे छोटी value = उसका In-order Successor).

Finding the In-order Successor?
Case 1: The node has a Right Subtree
If the given node has a right child or right subtree, go to the right subtree and then keep moving left until the leftmost node is reached.
Case 2: The Node Has No Right Subtree
If a node does not have a right subtree, its successor cannot be found below that node. So, we move upward through its parent and ancestor nodes.
While moving upward, find the first ancestor for which the given node is in its left subtree. That ancestor is the in-order successor.
Time Complexity:
The time required to find the successor depends on the height h of the BST. In the worst case, we may have to move down or up along a path whose length is proportional to the tree height.
Therefore, O(h).

Option B

In Karnaugh Map (K-Map) minimization using SOP (Sum of Products), we form groups of 1s. Each group gives a product term, and then all the product terms are combined using the OR (+) operation.
The question gives two groups:

• A group of 4 cells produces A’C
• An overlapping group of 2 cells produces A’B’C

Therefore, the initial SOP expression is: F=A′C+A′B′C
Now we need to check whether the second term is already covered by the first term.
F=A’C+A’B’C
F=A’C(1+B’)
F=A’C.1
F=A’C
Thus, the smaller 2-cell group does not add any new minterms because it is completely covered by the 4-cell group.
The 4-cell group represented by A'C already includes the cells represented by A'B'C. Therefore, adding the smaller group does not change the function. A'C+A'B'C = A'C

Option A

In C programming, an enumeration (enum) is a user-defined data type used to assign meaningful names to a set of integer constants.
enum WeekDay {
    MON,
    TUE,
    WED,
    THU
};
By default, the enumeration constants are assigned integer values starting from 0, not 1.
MON = 0
TUE = 1
WED = 2
THU = 3
The values can also be explicitly specified:
enum WeekDay {
    MON = 1,
    TUE = 5,
    WED = 10
};
No matter what values you assign, they are always integers, you cannot assign floating-point (decimal) values like 1.5 to an enum constant in C.

Option D

In Object-Oriented Programming (OOP), a class contains data (variables) and functions (methods).
Access specifiers control who is allowed to access these members from outside the class. This is part of a core OOP principle called encapsulation. The encapsulation controlling visibility and protecting data from unwanted or unsafe access.
C++ provides three main access specifiers, public, private, and protected.
Members declared as public can be accessed from anywhere, inside the class, in derived (child) classes, and even from outside the class entirely. It is the most unrestricted access level.
Members declared as private can be accessed only within the same class where they are defined. This is the most restrictive access level.
Members declared as protected behave almost like private, except for one important difference that they can be accessed by derived (child) classes through inheritance.

Option C

In a linked list, each element is stored in a separate node, and nodes are connected using pointers. Unlike an array, the elements of a linked list do not need to be stored in contiguous memory locations.
When a new node is inserted at a suitable position, we generally only need to change the links (pointers) between the existing nodes. The existing elements do not have to be physically moved or shifted.
Note:

• Saying “insertion is faster in a linked list” does not mean every insertion is automatically O(1).
• If we first need to traverse the list to find the insertion position, that traversal can take O(n). 
• The actual insertion after reaching the required position can be O(1) because no shifting is needed.

Option A

When comparing functions, we care about how fast a function grows as n becomes very large (n → ∞), not how it behaves for small values of n.
There's a well-known ordering of common growth rates, from slowest to fastest:

Option B

An ADT (Abstract Data Type) defines what operations can be performed on a data type and what those operations do, without requiring the user to know how those operations are implemented internally.
This separation between the interface (what the user can use) and the implementation (how it actually works) is called encapsulation.
For example, consider a Stack ADT. A user may use operations such as:

• push() : Adds an element.
• pop() : Removes the top element.
• peek() : Returns the top element.

The user does not need to know whether the stack is implemented using an Array or a Linked List.

Option A

In C++ inheritance, when an object of a derived class is created, the base class constructor executes first, followed by the derived class constructor.
This order is important because the derived class may depend on the base class being properly initialized first.

Option A

Branch-and-Bound is a problem-solving technique used to explore a State-Space Tree while eliminating branches that cannot lead to a better solution.
The way we explore this tree of possibilities is called the search strategy, and there are a few common strategies used in Branch and Bound.

• FIFO Search (First In, First Out)
• LIFO Search (Last In, First Out)
• LC Search (Least Cost Search)
• DFS Search (Depth First Search)

Why does FIFO Search match BFS?
In FIFO (First-In, First-Out) Branch-and-Bound, the live nodes are maintained in a queue. The node that was generated first is explored first. This is exactly the basic principle of Breadth First Search (BFS).
BFS (Breadth First Search) explores a tree or graph level by level, visiting all nodes at the current depth or level before moving on to the next deeper level. This naturally requires a Queue.

Comparison of Branch-and-Bound Search Strategies:

Option C

In C file handling, files are accessed using a FILE pointer and functions such as fopen(), fclose(), fscanf(), fprintf(), etc.
The statement in option (C) is incorrect because fclose() does not delete a file. It only closes the file that was previously opened using fopen().
FILE *fp;
fp = fopen("myfile.txt", "r");
/* File operations */
fclose(fp);
Here, fclose(fp) releases the resources associated with the opened file and closes the file stream. The file still exists on the storage device.

Option C

XPath is a language used to navigate through elements in an XML document, kind of like giving directions to find a specific element inside a tree-structured document. An XPath expression describes the location of a particular node or group of nodes.

• XPath (XML Path Language) is used to navigate through an XML document and select specific elements, attributes, or text.

Important XPath Symbols:

E.g.:
<?xml version="1.0" encoding="UTF-8"?>
<library>
    <book id="101" category="programming">
        <title>Learn C++</title>
        <author>ABC</author>
        <price>500</price>
    </book>
    <book id="102" category="database">
        <title>Learn SQL</title>
        <author>DEF</author>
        <price>600</price>
    </book>
    <book id="103" category="web">
        <title>Learn HTML</title>
        <author>GHI</author>
        <price>400</price>
    </book>
</library>

Option D

Operator overloading in C++ is a form of Compile-Time Polymorphism, also called Static Polymorphism.
Operator overloading allows us to give an existing operator, such as +, -, ==, or *, a special meaning when it is used with objects of a class.
E.g.:
class Complex
{
public:
    int real, imag;
    Complex operator+(Complex c)
    {
        Complex temp;
        temp.real=real+c.real;
        temp.imag=imag+c.imag;
        return temp;
    }
};
Complex c3 = c1 + c2;
Here, the + operator is overloaded to add two Complex objects.

Option D

Fan-out is the maximum number of standard logic-gate inputs that can be connected to the output of a single logic gate while still maintaining valid logic levels and proper operation.
Fan-out is not determined by the driving gate alone. It depends on the electrical characteristics of both the driving gate and the inputs of the gates being driven.
For example, the driving gate must be capable of supplying enough current when its output is HIGH and absorbing enough current when its output is LOW. Therefore, fan-out is checked for both logic states.

Option D

A Group is an algebraic structure in which a set and a binary operation satisfy four basic properties:

• Closure : The result of the operation remains within the set.
• Associativity : The grouping of elements does not affect the result.
• Identity Element : There exists an element that does not change another element when the operation is performed.
• Inverse Element : Every element has an inverse in the set.

An Abelian group satisfies all the properties of a group plus one additional property: Commutativity.
The commutative property means that changing the order of the operands does not change the result : A*B = B*A or A+B = B+A
Therefore, commutativity is guaranteed in an Abelian group but is not required in a general group.

Option C

A Binary Search Tree (BST) is a binary tree in which, for each node:

• All keys in the left subtree are smaller than the node's key.
• All keys in the right subtree are larger than the node's key.

The time required for searching in a BST depends mainly on its height.
For a well-balanced BST, the height is approximately O(log n). So, searching can be performed in O(log n) time.
A skewed tree is a BST where every node has only one child (either only a left child, or only a right child), meaning the tree looks less like a proper "tree" and more like a straight line.
In skewed BST, each node has only one child. Therefore, the height (h) of the tree becomes: h=n-1. 
In the worst case, the element we are searching for may be at the last node. We may therefore have to examine all n nodes. Hence the complexity becomes O(n).

Balanced vs Completely Skewed BST:

Option D

In Java, System.out and System.err are predefined objects of the PrintStream class.

• System.out is used to display normal output.
• System.err is used to display error messages.

Here, System is a predefined class in Java, provided by the java.lang package. The System class provides several static fields and methods that allow a Java program to interact with the system environment, standard input/output, and other system-level resources.
When we write, System.out.println("Suraku Academy");

• System : A Java class (java.lang.System).
• out : A static object/field of the System class.
• PrintStream : The class/type of the out object.
• println() : A method of PrintStream used to print output.

Option B

In Java GUI programming (AWT or Swing), an event is any action performed by the user, like clicking a button, typing on the keyboard, moving the mouse, etc. 
Java provides different Event Classes, each specifically designed to represent a particular type of user interaction.
When such an action occurs, Java automatically creates an object of the matching event class and passes it to the appropriate event-handling code.

Option A

This question tests the working of the continue and break statements inside a while loop.

• The continue skips the remaining statements of the current iteration and moves to the next iteration of the loop.
• The break immediately terminates the loop.

Therefore, the output is 1 3.

Option B

Linear Search checks elements one by one, from the start to the end, until it finds the target or reaches the end. It works on any list either sorted or unsorted. Its time complexity is O(n).
Binary Search works by repeatedly dividing the search range in half. It checks the middle element, and depending on whether the target is smaller or larger, it eliminates half of the remaining elements each time. Its time complexity is O(log n), which is much faster than linear search for large datasets.
But Binary Search only works on sorted data. If the data is not already sorted, you would need to sort it first before you can apply binary search.
So, in this situation, sorting the data just to use binary search ends up being more expensive than simply doing a linear search directly on the unsorted data.

Option C

DOM stands for Document Object Model. When a browser loads an HTML page, it converts the entire page into a tree-like structure made of objects, so that JavaScript can access, read, and modify any part of the page. This tree structure is called the DOM.
At the top of the DOM hierarchy is the document object. It represents the entire HTML document and acts as the root from which the elements of the document can be accessed.
For example, JavaScript commonly uses methods such as:

• document.getElementById("…");
• document.querySelector("…");

In both cases, we start with document and then access a particular HTML element. This is possible because the document object represents the whole HTML document and provides the starting point for accessing its elements.
E.g.:
<html>
    <body>
        <h1>Welcome</h1>
        <p>Hello World</p>
    </body>
</html>

DOM Hierarchy:
Document
     |
  html
    |
  body
   /    \
 h1      p
  |        |
Text   Text
 

Option D

A T (Toggle) flip-flop  is a memory element used in digital circuits that has a very simple rule:

• If T = 1 then the output toggles, meaning 0 becomes 1, or 1 becomes 0.
• If T = 0 then the output does not change (stays the same).

T Flip-Flop Truth Table:

We have a 3-bit counter with bits labeled A₂, A₁, A₀ from left to right.

Let's check each bit one by one, comparing Present vs Next:

Therefore, (T_A2,T_A1,T_A0)=(1,1,1)

Option B

VLSI stands for Very Large Scale Integration. VLSI refers to the process of creating integrated circuits (ICs) by combining millions or billions of transistors onto a single small chip.
Since so many transistors are packed together in such a tiny space, power consumption and heat generation become extremely important factors when choosing which technology to build these chips with.
CMOS (Complementary Metal-Oxide-Semiconductor) and TTL (Transistor-Transistor Logic) are two important digital logic technologies used to build logic circuits.

• TTL is an older technology built using bipolar transistors.
• CMOS is a newer technology built using MOSFETs.

VLSI involves placing a very large number of transistors on a single integrated circuit. Therefore, low power consumption is extremely important because millions or billions of devices may operate on the same chip.
The major advantage of CMOS technology is its very low static power dissipation. In a CMOS circuit, ideally, there is almost no direct current path from the power supply to ground when the circuit is in a stable logic state.
Therefore, CMOS is highly suitable for VLSI circuits, where low power consumption, high packing density, and efficient operation are important.

Option B

In a Binary Search Tree, every node follows this rule:

• All values in the left subtree are smaller than the node.
• All values in the right subtree are larger than the node.

When you search for a key (say 363), you start at the root and compare:

• If the key value is less than current node value then moves to the left child (left subtree).
• If the key value is greater than current node value then moves to the right child (right subtree).

The Key Idea: Every Visited Node Restricts the Range
As the search proceeds, every node you visit narrows down the possible range for all future nodes in the sequence:

• When you go left (key < node), that node becomes the New Upper Bound, every future node in the sequence must be smaller than it.
• When you go right (key > node), that node becomes the New Lower Bound, every future node in the sequence must be greater than it.

If any node in a given sequence falls outside the range built up so far, that sequence is impossible because it could never actually happen during a real BST search.

Checking Option (A): 924, 220, 911, 244, 898, 258, 362, 363
Starting Range: (-∞, +∞)

This is a valid, possible search sequence.

Checking Option (B): 925, 202, 911, 240, 912, 245, 363
Starting Range: (-∞, +∞)

This is not a valid, possible search sequence.

Checking Option (C): 2, 399, 387, 219, 266, 382, 381, 278, 363
Starting Range: (-∞, +∞)

This is a valid, possible search sequence.

Checking Option (D): 2, 252, 401, 398, 330, 344, 397, 363
Starting Range: (-∞, +∞)

This is a valid, possible search sequence.

Option A

A Circular Queue is a queue in which the last position is connected back to the first position. It follows the FIFO (First In, First Out) principle.
In a normal linear queue, when rear reaches the last position, we may not be able to reuse empty positions at the beginning. 
A circular queue solves this problem by allowing rear to wrap around to the beginning using the modulo operator %.
For a circular queue of size n, the next position of rear is calculated as: (rear+1)%n
The queue is considered full when this next position is equal to front: (rear+1)%n==front

Option C

In Java, Throwable is the topmost class in the exception hierarchy. It is the parent class of both Exception and Error.

Option D

Validation is the process of checking whether the data entered by a user is present, valid, and in the expected format before it is processed or submitted. There are two main places where validation can happen:
Client-Side Validation:

• This happens in the user's browser, before the form data is even sent to the server.
• It is done using HTML attributes like required, min, max or JavaScript.
• It gives instant feedback to the user. If something is wrong, the browser shows a message immediately, without needing to contact the server.

E.g.:
<form>
    <label>Name:</label>
    <input type="text" name="username" required>
    <button type="submit">Submit</button>
</form>
Here, the required attribute tells the browser that the Name field cannot be left empty. If the user tries to submit the form without entering a name, the browser displays a validation message and prevents the form from being submitted.
Server-Side Validation:

• This happens on the server, after the data has been submitted.
• It is done using server-side languages like PHP, Python, Node.js, etc.
• It's considered more secure, because client-side validation can be bypassed. So, the server should always double-check the data too.

Option C

DHTML stands for Dynamic HTML. DHTML actually a combination of technologies (HTML + CSS + JavaScript + DOM) used together to make web pages interactive and dynamic.
An event is an action that occurs in a web page, such as:

• Clicking a button.
• Moving the mouse.
• Pressing a keyboard key.
• Submitting a form.
• Loading a web page.

JavaScript is commonly used to handle these events. JavaScript event handlers contain the code that is executed when a particular event occurs.
E.g.:
<button onclick="showMessage()">Click Me</button>
<script>
function showMessage() 
{
    alert("Button was Clicked!");
}
</script>
Here, onclick is an event handler. When the user clicks the button, the showMessage() function is executed.

Option D

An Adjacency List represents a graph by maintaining a list of adjacent (connected) vertices for each vertex.
Suppose a graph has:

• V number of Vertices.
• E number of Edges.

The adjacency-list representation requires space for two main things:

• Vertices: We need one list/header for each of the V vertices, requiring O(V) space.
• Edges: Each edge must be stored in the adjacency lists. Thus, the total edge-related storage is O(E) for a directed graph. For an undirected graph, each edge appears in two adjacency lists, giving 2E entries, which is still O(E).

Therefore, the total space is O(V)+O(E) = O(V+E) (Total Entries)

Option C

In JavaScript, comparison operators are used to compare two values. The strict equality operator (===) checks both the value and the data type of the operands.
The == Operator : Loose equality

• This compares only the value, and it ignores the data type.
• It tries to convert the values to the same type first, and then compares them.
• E.g.: 15 == "15" is true because JavaScript converts the string "15" into the number 15 before comparing.

The === Operator : Strict equality

• This compares both the value and the data type. In this no conversion happens.
• Both sides must be exactly the same type and the same value to return true.
• E.g.: 15 === "15" is false because one is a number and the other is a string.