UPPSC Polytechnic Lecturer 2021 Previous Year Questions (PYQs) with Solutions

Key insight: To rotate a point about a pivot, first translate the point so the pivot is at the origin, apply the rotation, then translate back.

1. Step 1: Translate the point by subtracting the pivot: (5, 1) − (2, 2) = (3, −1).

2. Step 2: Rotate 90° counterclockwise using the rule (x, y) → (−y, x): (3, −1) → (1, 3).

3. Step 3: Translate back by adding the pivot: (1, 3) + (2, 2) = (3, 5).

Final answer: (3, 5).

Concept: A postfix (Reverse Polish) expression is evaluated with one stack by scanning tokens from left to right. Each operand is pushed when encountered.

For a binary operator, pop the top value as b and the next value as a, compute a op b, and push the result. The order matters for subtraction, division, and exponentiation; the current stack after any token prefix is the complete evaluation state at that point.

Application: Process the expression only through the first multiplication, recording the stack from bottom to top after each token.

1. Push 8 → stack: [8]

2. Push 2 → stack: [8, 2]

3. Push 3 → stack: [8, 2, 3]

4. '^' pops b = 3 and a = 2, computes 2 cubed (23) = 8 → push 8 → stack: [8, 8]

5. '/' pops b = 8 and a = 8, computes a/b = 8/8 = 1 → push 1 → stack: [1]

6. Push 2 → stack: [1, 2]

7. Push 3 → stack: [1, 2, 3]

8. First '*' pops b = 3 and a = 2, computes a×b = 2×3 = 6 → push 6 → stack: [1, 6]

Result: The stack is [1, 6] from bottom to top, so its top two values listed from top to bottom are 6, 1.

Cross-check: Pair each postfix operator with its two preceding operands to obtain ((8 / 2 cubed) + (2×3)) − (5×1). Direct evaluation gives (8/8 + 6) − 5 = (1 + 6) − 5 = 2. The two subexpressions completed before '+' are 8/2 cubed = 1 and 2×3 = 6, independently confirming that immediately after the first '*' the stack is [1, 6] from bottom to top.

Diffie–Hellman is a public-key key agreement (key exchange) protocol used to let two parties securely establish a shared secret over an insecure channel. Purpose: Establish a shared secret (typically used to derive symmetric keys) rather than directly encrypting or signing messages.

The Shortest Path First (SPF) algorithm is also known as Dijkstra’s algorithm , which is used by Link State routing protocols such as OSPF

For complex software problems, the Open paradigm team is considered best because: It enables free and frequent communication among team members, improving problem understanding.
Members can share ideas openly, encouraging creativity and diverse solutions.

Collaboration is flexible and adaptive, allowing the team to respond quickly to changing requirements.

This approach supports scalable, iterative problem-solving suitable for large, complex, and dynamic projects.

Definition: Logical database structures define how data is organized and how relationships between data items are represented and accessed. Common logical database models include: Tree structure — hierarchical parent–child organization (used in hierarchical databases).

For two relations R(X tuples) and S(Y tuples) : The maximum number of tuples in a join result is obtained in a Cartesian product , which yields X × Y tuples.

Natural join or equi-join will produce ≤ X × Y , but the maximum possible is X × Y .

Using linear search : 1️⃣ Unordered list: You may need to check every element in the worst case. ➡ Worst-case time = O(n) 2️⃣ Ordered list: Even though the list is sorted, linear search still checks elements one by one until the key is found or list ends. ➡ Worst-case time = O(n) Thus for unordered and ordered lists respectively: ➡ O(n) and O(n)

A functional dependency X → Y is trivial when: ➡ Y is a subset of X That means: ✔ All attributes of Y are already contained in X This is written as: ➡ X ⊇ Y Therefore, the dependency is trivial.

The original readable message given as input is called Plain Text .

The coded/encoded message produced as output is called Cipher Text .

TCL stands for Transaction Control Language . TCL commands manage transactions in a database. The two main TCL commands are: COMMIT — saves the transaction permanently

ROLLBACK — undoes the transaction

Key idea: Binary search halves the search space each step and does only constant work (a few comparisons) at each step.

• One recursive call on n/2

• Plus constant-time work (comparison), i.e., Θ(1)

• Base case: T(1) = Θ(1)

Therefore the recurrence is:

T(n) = T(n/2) + Θ(1)

Quick derivation by unfolding:

• T(n) = T(n/2) + 1 = T(n/4) + 2 = ... = T(n/2^k) + k

• Stop when n/2^k = 1, so k = log2 n. Hence T(n) = T(1) + log2 n = Θ(log n).

Master theorem confirmation:

• a = 1, b = 2 so n^{log_b a} = n^0 = 1; f(n) = Θ(1). This matches the case that yields Θ(log n).

Conclusion: The correct recurrence for binary search is T(n) = T(n/2) + Θ(1), which solves to Θ(log n).

Why the other recurrences are not appropriate:

• T(n) = T(n/2) + O(n): Implies linear extra work per level, not constant, so it does not describe binary search.

• T(n) = 2T(n/2) + O(n): Describes algorithms that recurse on both halves and do linear merging work (e.g., mergesort), giving higher complexity.

• T(n) = 2T(n/2) + 1: Two recursive calls process both halves and lead to Θ(n) overall, not the logarithmic behavior of binary search.

Answer: 200 — the program prints 200. In main(), variable a is initialized to 100.

A Minimum Spanning Tree (MST) of a connected weighted graph is a subset of edges that connects every vertex using the minimum possible total edge weight, contains no cycles, and uses exactly (number of vertices − 1) edges. Kruskal's algorithm builds an MST greedily: sort all edges by weight and repeatedly add the smallest remaining edge, skipping any edge that would create a cycle, until every vertex is connected.

For the 5 cities, list every usable edge (finite entries only) with its weight and sort by increasing cost:

1. (1-2) = 3

2. (2-3) = 3

3. (1-3) = 5

4. (4-5) = 7

5. (2-5) = 8

6. (2-4) = 9

7. (1-5) = 9

8. (3-5) = 10

9. (1-4) = 11

The edge (3-4) is not usable, since C(3, 4) = ∞.

Apply Kruskal's rule, adding an edge only if it does not close a cycle:

1. Add (1-2) = 3 — connects {1, 2}.

2. Add (2-3) = 3 — connects {1, 2, 3}.

3. Skip (1-3) = 5 — both endpoints are already in {1, 2, 3}, so adding it would form a cycle.

4. Add (4-5) = 7 — connects {4, 5}.

5. Add (2-5) = 8 — the smallest remaining edge that joins the two separate groups {1, 2, 3} and {4, 5}.

6. Stop — 4 edges have now been added for 5 vertices, so every city is in one connected component.

Total MST cost = 3 + 3 + 7 + 8 = 21.

Cross-check: the tree uses exactly 5 − 1 = 4 edges and every city — 1, 2, 3, 4, 5 — appears in the final connected set, confirming it is a valid spanning tree. No cheaper alternative exists: the only other edges crossing between {1, 2, 3} and {4, 5} at this stage were (1-5) = 9 and (3-5) = 10, both costlier than the chosen (2-5) = 8, and every unchosen edge inside a single group only closes a cycle, so 21 cannot be improved.

Therefore, the least cost of making all cities reachable from each other is 21.

Key idea: indirect addressing uses part of the address field to indicate indirection, reducing the bits available for the page offset.

• If the address space has k bits, normally up to 2ᵏ addresses are representable.

• Indirect addressing consumes one bit to indicate indirection, leaving k−1 bits available for the actual offset/page addressing.

• Therefore the maximum page size is 2ᵏ⁻¹, so the restriction is:

Conclusion: Page-size ≤ 2ᵏ⁻¹. This ensures the indirect address fits within the available bits.

An activation record (stack frame) of a function contains: Local variables (non-static)

Return address

Control link / pointer to caller's activation record

Temporary values

But global variables are not stored in the activation record because they are stored in a separate data segment , not on the stack. Therefore, global variables do not reside in the activation record block.

Split A → BC into two dependencies: A → B and A → C .

We now have: A → B, A → C, B → C, AB → C.

Check AB → C : it is implied by B → C (so AB → C is redundant ) — remove it.

Check A → C : since A → B and B → C hold, A → C is implied by transitivity (A→B and B→C ⇒ A→C). So A → C is redundant — remove it.

Remaining minimal set (canonical cover) is { A → B, B → C } , which is equivalent to the original set.

A multiplexer with n selection inputs can select 2ⁿ inputs. We need to select one of 16 registers, so 2ⁿ = 16 → n = log₂16 = 4 . Hence, each multiplexer needs 4 selection inputs .

Concept: A DBMS transaction moves through a fixed set of states. On the success path it goes Active -> Partially Committed -> Committed. On the failure path, any error while Active (or Partially Committed) pushes it into the Failed state; from Failed, a rollback runs and it then reaches Aborted, finally settling in Terminated.

Application: Here the abort/error happens while the transaction is still in the Active state -- the exact trigger for the failure path above. So it moves immediately into the Failed state; only after the subsequent rollback does it reach Aborted/Terminated.

• Terminated state -- this is the last stage of the lifecycle, reached only once rollback (after a failure) or a commit has fully completed; it is not the state entered the instant the abort occurs.

• Committed state -- only reached when a transaction finishes all operations successfully and those changes are made permanent; an abort rules this out entirely.

• Partially committed state -- only reached once every operation has executed successfully but before commit is finalised; it belongs to the success path, so an abort during Active execution never reaches it.

So an abort during the Active state takes the transaction to the Failed state.

JVM’s built-in security components include: Class Loader → controls how classes are loaded & prevents unauthorized loading

Bytecode Verifier → checks correctness & prevents malicious code

Security Manager → enforces runtime permissions (file access, network access, etc.)

Servlets , however, are not part of the JVM security model. Servlets are part of Java EE (server-side web technology) and run on a servlet container, not inside JVM’s core security architecture.

The correct option is C (63).

Explanation

In any binary tree, there is a strict relationship between the number of leaf nodes (nodes with 0 children) and the number of nodes with degree 2 (nodes with 2 children).

Let:

• n₀ = number of leaf nodes (degree 0)

• n₁ = number of nodes with exactly 1 child (degree 1)

• n₂ = number of nodes with exactly 2 children (degree 2)

The total number of nodes (N) is:

N = n₀ + n₁ + n₂

In any tree, the total number of edges (E) is one less than the total number of nodes:

E = N - 1

Therefore,

E = n₀ + n₁ + n₂ - 1

We can also count edges based on the number of children:

• Each degree 0 node contributes 0 edges.

• Each degree 1 node contributes 1 edge.

• Each degree 2 node contributes 2 edges.

Hence,

E = n₁ + 2n₂

Equating both expressions for E:

n₀ + n₁ + n₂ - 1 = n₁ + 2n₂

Subtracting n₁ and n₂ from both sides:

n₀ - 1 = n₂

Conclusion

For any binary tree:

n₂ = n₀ - 1

That is, the number of nodes with two children is always exactly one less than the number of leaf nodes.

Given:
n₀ = 64

Therefore:

n₂ = 64 - 1 = 63

Hence, the correct answer is C (63).

Fact table stores the primary business data (measurements, numeric facts).

Other tables (dimension, lookup) only describe the facts.

✔ Therefore, the fact table contains the primary information.

Group By groups the rows.

Having applies conditions on groups (group condition).

✔ Therefore, <group condition> is used in HAVING clause.

The stem specifies that the algorithm repeatedly finds and removes the current maximum element (this is the well-known partial-selection-sort approach). Finding the maximum of m elements by pairwise comparison always takes exactly m − 1 comparisons, so each successive pass over the shrinking list costs one comparison less than the pass before it.

1. Pass 1: scan all n elements and find the maximum (the 1st largest) — this takes n − 1 comparisons. Remove it from consideration.

2. Pass 2: scan the remaining n − 1 elements and find their maximum (the 2nd largest) — this takes n − 2 comparisons. Remove it.

3. Pass 3: scan the remaining n − 2 elements and find their maximum (the 3rd largest) — this takes n − 3 comparisons. Remove it.

4. Pass 4: scan the remaining n − 3 elements and find their maximum (the 4th largest) — this takes n − 4 comparisons.

5. Total comparisons = (n − 1) + (n − 2) + (n − 3) + (n − 4) = 4n − 10 = 2(2n − 5).

In general, finding the k-th largest this way needs (n − 1) + (n − 2) + … + (n − k) = k(2n − k − 1)/2 comparisons. Substituting k = 4 gives 4(2n − 5)/2 = 2(2n − 5), matching the total above. As a check with a small case, n = 5 and k = 4: the formula gives 4×5 − 10 = 10 comparisons, the same as counting the four passes directly (4 + 3 + 2 + 1 = 10).

So the number of comparisons required to find the 4th largest element is 2(2n − 5).

Code Red was a famous internet worm that infected Microsoft IIS servers in 2001. ✔ Hence, it is a computer worm .

A server's socket count depends on whether its transport protocol is connectionless or connection-oriented. A connectionless (UDP) server can exchange datagrams with any number of remote peers through a single bound socket, because the socket itself carries no per-peer connection state — the peer's address arrives with each datagram. A connection-oriented (TCP) server, by contrast, keeps one socket permanently open just to listen for and accept new connection requests, and a separate, independent socket is created for every connection it accepts and keeps alive — that listening socket is never reused as a session socket.

1. S₁ is UDP and is simultaneously serving 100 different clients. Since UDP needs no per-client socket, S₁ uses exactly one socket for all 100 sessions: S₁ = 1.

2. S₂ is TCP and is simultaneously maintaining 100 established sessions. Each of the 100 sessions occupies its own connected socket, contributing 100 sockets.

3. On top of those 100 connected sockets, S₂'s original listening socket (the one used to accept these connections in the first place) is still open and doing its own job — it is not one of the 100 connected sockets. Adding it gives S₂ = 100 + 1 = 101.

This matches how the sockets API behaves in practice: each accepted TCP connection returns a brand-new connected-socket descriptor while the server's original listening-socket descriptor is left completely untouched and still bound to the well-known port, ready to accept the next client. So a server with 100 live TCP sessions holds 101 open sockets in total, while the UDP server needs only its one shared socket.

Result: S₁ = 1, S₂ = 101.

Convert 0.4375 to binary by multiplying the fractional part by 2 and recording the integer parts:

1. 0.4375 × 2 = 0.875 → bit 0

2. 0.875 × 2 = 1.75 → bit 1

3. 0.75 × 2 = 1.5 → bit 1

4. 0.5 × 2 = 1.0 → bit 1

Collect the bits after the point (in order): 0.0111

Alternate method: express 0.4375 as a sum of negative powers of 2:

• 0.25 = 2⁻2 → binary 0.01

• 0.125 = 2⁻3 → binary 0.001

• 0.0625 = 2⁻4 → binary 0.0001

Summing these binary fractions: 0.01 + 0.001 + 0.0001 = 0.0111

Therefore, the binary equivalent of 0.4375 is 0.0111

Concept

A prime attribute is one that belongs to at least one candidate key; a non-prime attribute belongs to none. The normal forms differ in what they demand of every non-trivial functional dependency X → A. 3NF requires that, for each such FD, X is a superkey OR A is a prime attribute. BCNF drops the second escape clause: it requires X to be a superkey for every non-trivial FD, with no exception for prime A.

Application

1. Suppose every attribute of R(A, B, C) is prime, so the relation has no non-prime attribute at all.

2. Take any non-trivial FD X → A that holds on R. Its right-hand side A is an attribute of R, and by assumption A is prime.

3. The 3NF rule offers two ways to be satisfied: X is a superkey, or A is prime. Here the second clause holds for every FD because A is always prime, so the 3NF condition is met automatically.

4. 2NF and 1NF are weaker requirements implied by 3NF, so they also hold. 1NF needs only atomic values; 2NF forbids a non-prime attribute depending on part of a key, which cannot arise when there are no non-prime attributes.

Cross-check

BCNF is not guaranteed: it ignores whether A is prime and insists X be a superkey. A relation can have an FD whose left side is not a superkey while its right side is prime. Concrete witness: R(A, B, C) with candidate keys AB and AC and the FD C → B. Every attribute is prime, yet C is not a superkey, so this FD breaks BCNF while still passing 3NF. Hence the strongest form guaranteed purely from 'all attributes prime' is 3NF, not BCNF.

A memory resident virus loads itself into RAM and stays active there, hiding from detection. This hiding nature → same behavior as a stealth virus . ✔ So it is also called a stealth virus .

Average time = (hit_fraction × hit_time) + (miss_fraction × miss_time) Hit fraction = 0.8, Miss fraction = 0.2 Average = 0.8×5 + 0.2×50 = 4 + 10 = 14 ns

----------------------------------------

Short answer: 47 comparisons.

• Initial values: i = 200, n = 110 → difference (gap) = i - n = 90.

• Each iteration decreases i by 1 and increases n by 1, so the gap decreases by 2 each iteration.

• After m iterations the gap = 90 - 2m. The loop runs while i ≥ n, i.e., while gap ≥ 0. Find smallest m with gap < 0: 90 - 2m < 0 ⇒ m > 45, so the smallest integer m = 46. Therefore the loop executes 46 iterations.

• The condition i ≥ n is evaluated once before each iteration and one final time when it fails. Total comparisons = iterations + 1 = 46 + 1 = 47.

Conclusion: The comparison i ≥ n is performed 47 times.

Programming languages are commonly grouped by their organizing paradigm — procedural, object-oriented, functional, logic, and module-based. A module-based language builds programs around the module/package as the core unit: a construct that separates a public interface (specification) from a private implementation (body), enforces encapsulation, and supports separate compilation of units.

Among the given options, Ada is built around exactly this construct — the package. An Ada package splits into a public specification and a private body, hides implementation details behind that interface, and can be compiled separately from the units that use it. This package-centric design is why Ada is the standard textbook example cited for the module-based category.

• C has no package/module keyword at all — modularity is only a convention of splitting code into header (.h) and source (.c) files, tied together by the linker, not a language-level construct.

• Classical C++ (pre-C++20) still relies on the same header/source-file convention as C; in this paradigm taxonomy C++ is placed under the object-oriented category, not module-based.

• ML has a genuine module system — structures, signatures, and functors — but the paradigm taxonomy classifies ML under functional languages, not module-based.

So, of the four options, only Ada is classified as the module-based programming language.

Operator overloading: Operator overloading allows existing C++ operators (for example +, -, *) to be given definitions that work with user-defined types (classes or structs). Key idea: You implement operator functions (such as operator+) to specify how an operator behaves for your class. These functions can be member functions or non-member functions.

Example: To add two Complex objects, define a function such as Complex operator+(const Complex& a, const Complex& b) that returns their sum.

All AWT events in Java are subclasses of AWTEvent , which is the root of the AWT event hierarchy.

Quick Heal, McAfee, and Kaspersky are all antivirus software. Microsoft Office is not antivirus software. ✔ So correct answer = Microsoft Office

Concept

A circuit-switched network reserves a dedicated end-to-end path before data transfer. Each switching node on that path stores local connection state and commits a channel or capacity to that circuit.

Teardown reverses setup: the network must notify every switching node that holds part of the reservation so that each node can remove its cross-connect state and return the capacity to the free pool.

Application

1. The established circuit passes through a sequence of circuit switches between the two end systems.

2. Each such switch holds local state and reserved capacity for this circuit.

3. A release signal therefore propagates along the established path and is processed by each switch, which frees its local reservation.

Contrast and cross-check

• A router primarily forwards individual packets using routing and forwarding tables rather than holding the circuit cross-connect described here.

• A computer or server is an end system; it is not the repeated intermediate resource holder along the circuit path.

• If even one circuit switch were not notified, its reserved channel would remain occupied, so complete release requires notifying each switch.

Therefore, the release signal is sent to each switch on the established circuit path.

TCP Wrappers control access to network services using allow/deny rules.

A tautology is a statement that is always true. P ∨ ¬P is always true; this is the law of excluded middle . If P is true, then ¬P is false, so P ∨ ¬P is true.

Digital Signature proves ownership/control of the private key by the certificate holder. The signer creates a signature using their private key.

In a min-heap , the minimum is at the root, but the maximum can be anywhere in the heap. Therefore, we must scan all n elements → θ(n) time

Answer: Arithmetic shift left causes overflow sometimes. Reason (English): Arithmetic shift left multiplies a value by 2. For fixed-width signed representations, shifting left can move the sign bit out of range or otherwise exceed the representable range, producing arithmetic overflow.

Example: In 4-bit two's complement, 0100 (+4) shifted left by one becomes 1000 (which represents −8). This change of sign and incorrect numeric result indicates overflow.

Why other shifts do not cause arithmetic overflow:

Circular (rotate) shifts preserve all bits by rotating them, so no bits are lost and this does not produce arithmetic overflow.

Logical shift left also shifts in zeros and can discard the most significant bit; however, in the ALU context the term "overflow" typically refers to arithmetic overflow for signed values, and the operation that corresponds to multiplying by two (arithmetic shift left) is the standard cause of such overflow.

Arity = number of attributes in a relation

Cardinality = number of tuples

In C++, function parameters are passed by value by default , meaning a copy of the variable is sent, not the original.

Stalking = repeatedly following, contacting, watching, or harassing someone in a way that causes fear or distress.

Formula: The number of different binary trees with n nodes equals the nth Catalan number,

C_n = 1/(n+1) * (2n choose n).

Compute for n = 8:

1. Step 1: Calculate the binomial coefficient (2n choose n) = (16 choose 8) = 12870.

2. Step 2: Apply the Catalan formula: C_8 = 1/(8+1) * 12870 = 12870 / 9 = 1430.

Answer: There are 1430 different binary trees with 8 nodes.

------------------------------------------------------------------------------------------------------

The Core Idea: Splitting the Nodes

Every binary tree has exactly one root node at the very top.

If you have n nodes total, and you use 1 for the root, you have n - 1 nodes left over. These leftover nodes must be split between the left branch and the right branch.

To find the total number of possible trees, you look at every possible way to split those leftover nodes, find out how many tree shapes each side can make, and multiply them together.

Building from Scratch (Starting with 0)

Let's call the number of possible trees for a given number of nodes T(n).

0 Nodes: T(0) = 1

If you have 0 nodes, there is only 1 way to draw it: an empty space. (This might sound weird, but it's mathematically necessary for the next steps!)

1 Node: T(1) = 1

If you have 1 node, it is just the root. There is exactly 1 way to draw this.

2 Nodes: T(2) = 2

You use 1 node for the root, leaving 1 node. You can split that 1 leftover node two ways:

1 on the left, 0 on the right: (1 way for left × 1 way for right) = 1
0 on the left, 1 on the right: (1 way for left × 1 way for right) = 1
Total: 1 + 1 = 2 ways.

3 Nodes: T(3) = 5

You use 1 node for the root, leaving 2 nodes. You can split them:

2 on left, 0 on right: (T(2) ways × T(0) ways) → 2 × 1 = 2
1 on left, 1 on right: (T(1) ways × T(1) ways) → 1 × 1 = 1
0 on left, 2 on right: (T(0) ways × T(2) ways) → 1 × 2 = 2
Total: 2 + 1 + 2 = 5 ways.

Finding the Pattern

Do you see the pattern? For any number of nodes, we just pair up the answers from the smaller trees we already calculated. We multiply the outer numbers, move inward, multiply those, and add them all up.

Let's use our known list so far: 1, 1, 2, 5 (for 0, 1, 2, and 3 nodes).

4 Nodes: T(4) (Leaves 3 nodes to split)

(Left 3, Right 0): 5 × 1 = 5
(Left 2, Right 1): 2 × 1 = 2
(Left 1, Right 2): 1 × 2 = 2
(Left 0, Right 3): 1 × 5 = 5
Total T(4) = 5 + 2 + 2 + 5 = 14

5 Nodes: T(5) (Leaves 4 nodes to split)

(14 × 1) + (5 × 1) + (2 × 2) + (1 × 5) + (1 × 14)
14 + 5 + 4 + 5 + 14 = 42

6 Nodes: T(6) (Leaves 5 nodes to split)

(42 × 1) + (14 × 1) + (5 × 2) + (2 × 5) + (1 × 14) + (1 × 42)
42 + 14 + 10 + 10 + 14 + 42 = 132

7 Nodes: T(7) (Leaves 6 nodes to split)

(132 × 1) + (42 × 1) + (14 × 2) + (5 × 5) + (2 × 14) + (1 × 42) + (1 × 132)
132 + 42 + 28 + 25 + 28 + 42 + 132 = 429

8 Nodes: T(8) (Leaves 7 nodes to split)

(429 × 1) + (132 × 1) + (42 × 2) + (14 × 5) + (5 × 14) + (2 × 42) + (1 × 132) + (1 × 429)
429 + 132 + 84 + 70 + 70 + 84 + 132 + 429 = 1430

“Complement Accumulator” instruction does not specify any operand . The operand (Accumulator) is already known to the CPU, so the instruction is implicit . Therefore, it uses Implied addressing mode .

The Assignment problem is solvable in polynomial time using the Hungarian Algorithm → therefore it is NOT NP-Hard. Other problems listed (TSP, Non-linear programming, Hamiltonian cycle) are NP-Hard.

Answer: 2 Array contents by row: Row 0

1 byte = 8 bits 200 bits / 8 = 25 bytes

Concept

A topological ordering of a directed acyclic graph places every vertex before every vertex reached by one of its outgoing edges.

Equivalently, for each directed edge u → v, u must occur before v in the sequence.

Application

1. Read the DAG constraints: A precedes B and C; B precedes D and E; C precedes D and F; and D precedes E and F.

2. In CBDAFE, C and B occur before A. This contradicts the edges A → C and A → B, which require A to occur before both vertices.

3. Therefore, CBDAFE is not a topological ordering of the given DAG.

Cross-check

Each of ABCDEF, ACBDEF, and ACBDFE places A before B and C, both B and C before D, and D before E and F. Thus, each of those sequences satisfies every directed-edge constraint.

Result

The ordering that is not topological is CBDAFE.

Answer: Proxy firewall filters at the Application Layer (Layer 7). A proxy firewall acts as an intermediary between clients and servers and inspects application-layer data. It understands application protocols and can allow or block traffic based on protocol semantics and message content. Examples of what it inspects: HTTP requests (URLs, headers, cookies), FTP commands, SMTP messages.

Concept.

A CRC treats bit strings as polynomials over GF(2). For a generator G(x) of degree n, the message M(x) is first multiplied by xn (equivalently, n zero bits are appended). The CRC is the remainder R(x) of the modulo-2 division of that padded message by G(x); the remainder always has n bits. All arithmetic is XOR-based with no carries or borrows, and the transmitted codeword is, by construction, exactly divisible by G(x).

How many zeros to pad? A generator whose highest power is n has n + 1 bits; the number of appended zeros equals n, the degree of the generator (one less than its bit length).

Application.

1. Write the generator. x5 + x4 + x2 + 1 has degree n = 5, so its binary form is 110101 (6 bits) and we append 5 zeros.

2. Pad the message. M = 1010001101 becomes 101000110100000 (five zeros appended).

3. Divide modulo-2. Align the generator under each leading 1 of the running dividend and XOR; bring down bits and repeat until every bit is processed.

4. Read the remainder. The final 5 bits left after the last XOR form the CRC: 01110.

Polynomial view.

M(x) = x9 + x7 + x3 + x2 + 1, and multiplying by x5 gives x14 + x12 + x8 + x7 + x5. Dividing this by G(x) = x5 + x4 + x2 + 1 over GF(2) leaves the remainder x3 + x2 + x, whose coefficients from x4 down to x0 are 01110 — the same result as the bit-wise division.

Cross-check.

Form the codeword by appending the remainder to M: 101000110101110. Dividing this codeword by 110101 modulo-2 leaves remainder 00000. A zero remainder confirms the CRC is correct.

Quick tip (do it faster).

You do not have to write out all 15 bits at once. Keep only a 5-bit register (n = degree of the generator), initialised to 0, and feed in the padded message one bit at a time:

1. Note the register's current leftmost bit, then shift the register left by one and bring in the next message bit on the right (keep only the last 5 bits).

2. If the leftmost bit noted in step 1 was 1, XOR the register with the generator's own lower n bits — here 10101 (110101 without its own leading 1). If it was 0, do nothing this step.

3. Repeat for every bit of the message and every appended zero. Whatever is left in the register at the end is the CRC — no need to track a full 15-bit row at each step.

This is exactly how a hardware CRC circuit (an LFSR) works, and it is faster to execute on paper than rewriting the whole padded string at every row.

Set A = {1, {2}, 3} contains three elements: 1 → an element {2} → a set , and treated as a single element 3 → an element So every subset must use 1 , {2} , and 3 exactly as they appear. {2} ✗ NOT valid , because 2 is NOT an element of A , only {2} is.

Correct C syntax for array initialization uses curly braces { } , not parentheses. Correct initialization example: int num[] = {2, 4, 12, 5, 45, 5}; You can omit the size in the square brackets; the compiler infers the array length from the number of initializer elements.

Given f(n) = n^2 log n.

• Compare with n sqrt(n) = n^{3/2}: (n^2 log n)/(n^{3/2}) = n^{1/2} log n → ∞, so f(n) grows faster than n sqrt(n) and therefore is not O(n sqrt(n)).

• Compare with n^2 sqrt(n) = n^{5/2}: (n^2 log n)/(n^{5/2}) = (log n)/n^{1/2} → 0, so f(n) is asymptotically smaller and hence f(n) = O(n^2 sqrt(n)).

• Compare with n^3: (n^2 log n)/n^3 = (log n)/n → 0, so f(n) = o(n^3) and therefore f(n) is not Ω(n^3).

Conclusion: The only true statement is that f(n) = O(n^2 sqrt(n)). The other two statements are false.

Software process qualities include: Productivity

Timeliness

Visibility

Portability is not a process quality. It is a software product quality .

TCP sender window = min(Advertised Window, Congestion Window) min⁡(20,10)=10 kB ✔ Final Answer: 10 kB

Preorder: abdefcg → first element a = root Inorder: dbef a gc Left subtree inorder: dbef

SMTP is used for sending emails. POP3 is used for retrieving emails. Key point: SMTP handles outgoing mail delivery, and POP3 downloads incoming mail to the client, so the correct order for 'send then retrieve' is SMTP followed by POP3. SMTP

Cloud services are standardly: IaaS

PaaS

SaaS

“Typing as a Service” is not a real cloud computing model.

Key idea: keep P pointing to the rear node of the circular linked list.

Then front = P -> next; rear = P.

• Enqueue requires quick access to the rear.

• Dequeue requires quick access to the front.

Enqueue (insert element x):

1. If P == NULL (queue is empty): create new node; set new.next = new; set P = new.

2. Else: create new node; set new.next = P.next; set P.next = new; set P = new.

Dequeue (remove front element):

1. If P == NULL: queue is empty (underflow).

2. Let front = P.next.

3. If front == P (only one node): set P = NULL.

4. Else: set P.next = front.next (unlink front). Return front's value.

Because each operation uses a fixed number of pointer updates (and no traversal), both enqueue and dequeue run in O(1) time.

IPSec works at Network Layer (Layer 3).

Class C begins with bits 110 , i.e., 3 bits fixed. So usable network bits = 24 − 3 = 21 bits . Number of Class C networks=2 21

HIPAA = Health Insurance Portability and Accountability Act It relates to health: HIPAA sets national standards for protecting patients' medical information, ensuring privacy and security. Protects medical and health records (protected health information).

Angry IP Scanner is a well-known tool used specifically for IP address and port scanning .

Correct answer: Travelling Salesperson Problem (TSP) does NOT use divide-and-conquer. Merge sort — uses divide-and-conquer: split the array into halves, sort each half recursively, then merge the sorted halves.

The floor function ⌊x⌋ gives the greatest integer that is less than or equal to x, so it always moves down to the nearest whole number and never rounds up.

The ceiling function ⌈x⌉ gives the least integer that is greater than or equal to x, so it always moves up to the nearest whole number whenever a fractional part exists.

Applying this to the given expression:

1. Since 8 ≤ 8.4 < 9, the greatest integer not exceeding 8.4 is 8; so Floor(8.4) = 8.

2. Since 9 < 9.9 ≤ 10, the least integer not less than 9.9 is 10; so Ceil(9.9) = 10.

3. Adding these: 8 + 10 = 18.

As an independent check, 8.4 lies strictly between 8 and 9, and the floor always selects the lower of the two regardless of how large the decimal part is; 9.9 lies strictly between 9 and 10, and the ceiling always selects the upper of the two regardless of how small the remaining gap is. This confirms Floor(8.4) + Ceil(9.9) = 8 + 10 = 18.

Virtual inheritance ensures that only one shared instance of a common base class exists when using multiple inheritance—this prevents duplicate base-class subobjects in the diamond problem. Problem: If class B and class C both inherit from class A, and class D inherits from both B and C, then without virtual inheritance D will contain two separate A subobjects (diamond problem).

A threat vector describes where a threat comes from and how it reaches the target .

Concept

A data bus transfers a number of bits equal to its width in each access.

When the instruction size is an exact multiple of the bus width, the required number of accesses is instruction size divided by bits transferred per access.

Application

1. Instruction size = 128 bits; bus width = 16 bits per access.

2. Number of accesses = 128 bits ÷ 16 bits per access = 8.

3. Therefore, reading the complete instruction requires 8 bus accesses.

Cross-check

8 accesses × 16 bits per access = 128 bits, which exactly equals the instruction size.

Nyquist formula:

Use R_max = 2 B log2 M.

• Given bandwidth B = 1000 Hz and number of signal levels M = 2.

• Compute log2 M = log2 2 = 1.

• So R_max = 2 × 1000 × 1 = 2000 bits/sec (2000 bps).

8/3 is integer division in Java (both operands int) → result 2. That 2 is then assigned to double → 2.0. So printed 2.0.

Key idea: Unroll the recurrence and sum the arithmetic series.

• Unwrap the first values: T(1) = 7, T(2) = 7 + 3·1, T(3) = 7 + 3(1+2), and so on.

• General form: T(n) = 7 + 3(1 + 2 + ... + (n - 1)).

• Sum formula: 1 + 2 + ... + (n - 1) = (n - 1)n/2.

• Compute T(n): T(n) = 7 + 3·(n - 1)n/2 = (3/2)n^2 - (3/2)n + 7.

Conclusion: The dominant term is (3/2)n^2, so T(n) = Θ(n^2).

Concept

A historical-identification question is solved by matching a named institution with the person specifically credited with founding or establishing it. General patronage or prominence is not equivalent to founding that institution.

For Mughal cultural history, aliases, family relationships, and documented literary activity help distinguish figures who otherwise share courtly backgrounds.

Application

Bait-ul-Uloom, the literary centre in Delhi, is attributed to Zeb-un-Nisa, the Mughal princess and poet who wrote under the pen name Makhfi. She was the eldest daughter of Emperor Aurangzeb.

Contrast

• Jahanara Begum was Shah Jahan's eldest surviving daughter and is noted for Sufi patronage and architectural and urban projects in Shahjahanabad.

• Gauhar Ara Begum was the youngest daughter of Shah Jahan and Mumtaz Mahal and lived as a Mughal princess of the Shah Jahan era.

• Nur Jahan was Emperor Jahangir's influential consort and is chiefly associated with imperial politics, court patronage, and architecture.

Result

Therefore, the person who established Bait-ul-Uloom was Zeb-un-Nisa.

Hierarchical classification means forming parent–child class structure → supported by Inheritance.

Concept

Department-related Parliamentary Standing Committees are reconstituted periodically, so a chairperson statement must be checked against the notification applicable to the date named. In a two-statement code question, verify each statement independently before selecting the combination.

Application

1. The October 2021 reconstitution named Sushil Kumar Modi as Chairperson of the Committee on Personnel, Public Grievances, Law and Justice. Therefore statement 1 records the full committee title and chairperson correctly.

2. The October 2021 reconstitution retained Shashi Tharoor as Chairperson of the Committee on Information Technology. The committee was renamed the Committee on Communications and Information Technology in November 2021, so the October-specific name must be used here. Therefore statement 2 is correct.

Cross-check and contrast

• “Only 1” accepts statement 1 but excludes the independently verified statement 2.

• “Only 2” accepts statement 2 but excludes the independently verified statement 1.

• “Both 1 and 2” includes both independently verified statements.

• “Neither 1 nor 2” excludes both independently verified statements.

Result

Therefore, the applicable October 2021 list supports both statements, so the answer is “Both 1 and 2”.

Concept. A B-tree of order m is a balanced multi-way search tree: every node stores at most m − 1 keys and has at most m children, and every internal node other than the root has at least ⌈m/2⌉ children. All leaves sit on the same level, so the height of such a tree is bounded by exactly two things — its order m and the number of keys n it has to store — and among the shapes a given m and n allow, the tightest packing is the shortest.

1. Level 0 holds 1 node, level 1 holds up to m nodes, and level 2 holds up to m2 nodes — each level multiplies the node count by at most m.

2. A tree of height h therefore holds at most 1 + m + m2 + … + mh nodes, which can index at most mh+1 − 1 keys.

3. Solving mh+1 − 1 ≥ n for h gives the shallowest legal shape, h ≥ ⌈logm(n + 1)⌉ − 1.

4. The sparsest legal shape gives the opposite bound: the root may keep just 2 children and every other internal node only ⌈m/2⌉, so h ≤ log⌈m/2⌉((n + 1)/2).

Application. Every choice here is a tree of the same family over the same set of keys, so the only variable is the order m. Both bounds move the same way as m grows: ⌈logm(n + 1)⌉ − 1 falls, and log⌈m/2⌉((n + 1)/2) never rises. Comparing the four structures at their tightest packing — the reading that a “least height” comparison assumes — a larger order can therefore never need more levels than a smaller one for the same keys.

Putting the four offered orders side by side for an illustrative load of n = 1,000,000 keys:

Cross-check. Check the extremes independently: with order 3 each level multiplies the node count by at most 3, so about log3(106) ≈ 12.6 levels of branching are needed to reach a million keys, while with order 6 each level multiplies by up to 6, so about log6(106) ≈ 7.7 levels are enough.

Three honest qualifications. First, the separation is not strict at every key count: for small key counts several orders share the same minimum height, and with 6 keys all four of them need height 1. Second, the worst-case bound uses the minimum branching ⌈m/2⌉, which equals 3 for both order 5 and order 6, so those two share the same upper bound. Third, because the exact shape depends on the insertion history, a sparsely filled high-order tree can be taller than a densely filled low-order one, which is why the comparison is made at equal packing. None of these lets a smaller order win: at equal packing a larger order never needs more levels than a smaller one.

Result. Of the four offered structures the one of order 6 has the largest branching factor, so at equal packing it never needs more levels than the rest, and for large key counts it needs strictly fewer — a million keys fit into 8 levels instead of the 13 that order 3 requires. The B-tree of order 6 therefore has the least height.

Boundary condition problems happen when array or memory limits are exceeded → buffer overflow .

Answer: Azimullah Khan — अज़ीमुल्लाह ख़ान Explanation: Azimullah Khan, who served as Nana Sahib's secretary and envoy, was sent to plead before the Court of Directors for the right to the pension previously paid to Baji Rao II. Role: acted as secretary and representative of Nana Sahib.

Purpose: to petition the Court of Directors for the pension rights associated with Baji Rao II.

Key direction: The option is read from the owning strong entity set to the weak entity set.

• One strong owner can be associated with many weak entities.

• Each weak entity must be associated with exactly one strong owner so it can be identified using the owner key plus its partial key.

• Therefore, from weak entity to strong owner, the same relationship can be described as many-to-one. The question now states the direction explicitly.

Answer: One-to-many relationship

Java automatically promotes int to double , so comparison is: 2.0==2.0⇒true

Compute powers of 2 until exceeding 250: ans = 1 (count 0)

ans = 2 (count 1)

ans = 4 (count 2)

ans = 8 (count 3)

ans = 16 (count 4)

ans = 32 (count 5)

ans = 64 (count 6)

ans = 128 (count 7)

ans = 256 (count 8) → now ans > 250, stop

Return count = 8

WW conflict = two transactions write the same item → one overwrites another → Lost Update anomaly.

Final answer: 142 is inserted at index 6.

Reasoning:

• Hash table has 10 buckets (indexes 0–9). Hash function: key % 10. Linear probing is used to resolve collisions.

• Insert 43: 43 % 10 = 3 → index 3 empty → place 43 at index 3.

• Insert 165: 165 % 10 = 5 → index 5 empty → place 165 at index 5.

• Insert 62: 62 % 10 = 2 → index 2 empty → place 62 at index 2.

• Insert 123: 123 % 10 = 3 → index 3 occupied → probe to index 4 → index 4 empty → place 123 at index 4.

• Insert 142: 142 % 10 = 2 → index 2 occupied (62) → probe to index 3 (occupied by 43) → probe to index 4 (occupied by 123) → probe to index 5 (occupied by 165) → probe to index 6 which is empty → place 142 at index 6.

Note: The question statement mentions 10 buckets; the answer 6 depends on using modulus 10. If the table size were actually 8, the insertion positions would change and you should use key % 8.

Key idea: Cycle stealing occurs during DMA-based data transfer. Definition: A DMA controller temporarily "steals" CPU bus cycles to transfer data directly between memory and peripherals.

Big-O and Big-Theta compare how fast one function grows against another as n → ∞, ignoring constant multipliers and lower-order terms:

• f(n) = Θ(g(n)) when positive constants c1, c2, and n0 exist such that c1·g(n) ≤ f(n) ≤ c2·g(n) for every n ≥ n0 — f and g grow at exactly the same rate.

• f(n) = O(g(n)) when a positive constant c and n0 exist such that f(n) ≤ c·g(n) for every n ≥ n0 — f grows no faster than g, once a constant factor is allowed.

A direct consequence used below: any constant multiple of g(n) is O(g(n)); a polynomial (n+k)m with fixed constants k, m keeps nm as its dominant term, so it is Θ(nm); but if the ratio f(n)/g(n) itself grows without bound as n increases, f(n) is NOT O(g(n)).

1. Claim I: (n+k)m = Θ(nm), for constants k and m. Expanding by the binomial theorem, (n+k)m = nm + m·k·nm-1 + … + km — every term besides the leading one carries a strictly smaller power of n. Since k and m are fixed and don't grow with n, these lower-order terms and constant coefficients never change the asymptotic rate, so (n+k)m grows at exactly the rate of nm. This satisfies the Θ definition — TRUE.

2. Claim II: 2n+1 = O(2n). Since 2n+1 = 2 · 2n, it is exactly 2 times 2n — a constant multiple. Taking c = 2 and n0 = 1 in the O-definition, 2n+1 ≤ c·2n holds for every n ≥ n0. A constant multiplier never changes the O-class, so this holds — TRUE.

3. Claim III: 22n = O(2n). Here 22n = (2n)2 = 4n — not a constant multiple of 2n. The ratio 22n / 2n = 2n itself grows without bound as n increases, so no constant c can satisfy 22n ≤ c·2n for large n. This fails the O-definition — FALSE.

A quick numeric check confirms this: at n = 10, 2n+1 = 2048 is exactly twice 2n = 1024 — a fixed ratio of 2, matching claim II. But 22n = 220 = 1,048,576 against 2n = 1024 gives a ratio of 1024, and this ratio doubles every time n increases by 1 — it can never be capped by a fixed constant, confirming claim III fails.

So claim I and claim II both hold, while claim III does not — the correct combination is I and II.

Rule: For an array representation of a binary max-heap using 1-based indexing, each parent at index i must be greater than or equal to its children at indices 2i and 2i+1 (if they exist).

• For [25, 12, 16, 13, 10, 8, 14]: index 2 has value 12 and its left child at index 4 has value 13. Since 12 < 13, the max-heap property is violated.

• For [25, 14, 13, 16, 10, 8, 12]: index 2 has value 14 and its left child at index 4 has value 16. Since 14 < 16, the max-heap property is violated.

• For [25, 14, 16, 13, 10, 8, 12]:

  • Index 1 has value 25 and children 14 and 16; 25 ≥ 14 and 25 ≥ 16.

  • Index 2 has value 14 and children 13 and 10; 14 ≥ 13 and 14 ≥ 10.

  • Index 3 has value 16 and children 8 and 12; 16 ≥ 8 and 16 ≥ 12.

• For [25, 14, 12, 13, 10, 8, 16]: index 3 has value 12 and its right child at index 7 has value 16. Since 12 < 16, the max-heap property is violated.

Conclusion: [25, 14, 16, 13, 10, 8, 12] is the only array that satisfies the binary max-heap property.

(a) In a 2-attribute relation any nontrivial functional dependency A→BA\to BA→B (or B→AB\to AB→A) makes the left side a key (it determines the whole relation). Hence such a relation satisfies BCNF. → (a) true .

(b) If every key is a single attribute there are no composite keys, so no possibility of partial dependency; therefore the relation is in 2NF . → (b) true .

(c) 3NF allows dependencies X→AX\to AX→A when AAA is a prime attribute even if XXX is not a superkey. So a prime attribute may be transitively dependent in a 3NF relation. → (c) true .

(d) BCNF requires every nontrivial X→AX\to AX→A to have XXX as a superkey. A transitive dependency (key → B → primeAttr) implies an intermediate non-key determines the prime attribute, which would violate BCNF (unless that intermediate determinant is also a superkey). So in general (d) is false .

A stereoscopic system that lets users step into a scene and interact with the environment is called Virtual Reality . In virtual reality, the user feels present inside a 3D world and can interact with objects or surroundings.

Time-sharing systems need fast switching among users. The best scheduling algorithm for this is Round Robin .

Correct answer: Turing test. Alan Turing proposed this as an operational (practical) definition of intelligence: if a machine can converse in such a human‑like way that an examiner cannot reliably tell it from a human, it is judged intelligent.

For sequential/direct access: Logical address of record N = ((N − 1) × S) + 1

Weighted sum = (1×4) + (4×8) + (3×5) = 4 + 32 + 15 = 51 . For a linear transfer function y = k×(weighted sum) with k = 3, output = 3×51 = 153 .

Answer: ISO 9000 is not a software quality model.

Short explanations:

• ISO 9126 / ISO/IEC 25010: Defines software product quality characteristics (functionality, reliability, usability, efficiency, maintainability, portability).

• Boehm Model: A software quality model that relates high-level quality attributes to measurable criteria and helps assess product quality.

• McCall Model: A software quality model defining factors and criteria (such as correctness, reliability, efficiency, integrity, usability) used to evaluate software quality.

• ISO 9000: A family of standards for quality management systems (process and organizational requirements for ensuring quality). It focuses on management processes and certification, not on defining software product quality characteristics, so it is not a software quality model.

JPEG compression uses: DCT (Discrete Cosine Transform)

Zig-Zag scan

Run-length encoding

Huffman coding

KL Transform is NOT used in JPEG.

Page size is determined by the hardware architecture (MMU and address-translation support), not solely by the operating system or the amount of memory. Hardware (MMU, page-table format, and TLB) defines which page sizes are supported; the operating system can only use sizes provided by the hardware.

The correct answer is: Unity based AI agent

Artificial Intelligence (AI) agents are systems that perceive their environment and take actions to achieve specific goals. Standard types of AI agents commonly studied in Artificial Intelligence include:

1. Simple Reflex AI Agent
   These agents act only on the basis of the current percept and follow condition-action rules.

2. Goal-Based AI Agent
   These agents take actions to achieve predefined goals and evaluate possible future outcomes before acting.

3. Learning AI Agent
   These agents can learn from past experiences and improve their performance over time.

Other standard AI agent types include Model-Based Agents and Utility-Based Agents.

However, Unity based AI agent is not a recognized category of AI agents. Unity is a game development platform used for creating games, simulations, and interactive applications. Although AI techniques can be implemented using Unity, it is not itself a type of AI agent.

Therefore, the correct answer is:

Unity based AI agent

Win/Lose decisions in Game Trees are made using the Minimax algorithm , commonly used in games like Chess, Tic-tac-toe etc.

Cluster computing is commonly categorized by its purpose, such as load balancing clusters, failover clusters, and high-availability clusters. A load balancing cluster is a valid type where incoming tasks are distributed across multiple machines to share workload and improve performance.

Metadata in an HTML file is stored inside the <head> section, which includes information like title, meta tags, links to CSS, and scripts.

Answer: First-come-first-serve (FCFS) Reason: FCFS is non-preemptive. The scheduler does not forcibly remove a running process; a process runs until it completes or blocks. No context switches due to preemption: because FCFS is non-preemptive, the OS does not interrupt a running process to switch to another.

Run-length coding and quad tree coding are standard region representation methods in image processing. They describe the pixels belonging to a region (either as runs or as hierarchical blocks). Chain code is mainly a boundary/contour representation method for an object’s shape, and is still used to represent objects/regions via their borders. Projection is used for feature extraction (e.g., horizontal/vertical profiles) rather than encoding a region itself. इसलिए region representation के लिए projection का उपयोग नहीं होता। इसलिए सही उत्तर है: Projection

RT Linux, QNX, and VxWorks are all real-time operating systems designed to respond within strict time limits. Palm OS does not provide guaranteed real-time behavior, so it is not a real-time operating system. RT Linux, QNX

In genetic algorithms, chromosome selection methods such as rank selection, tournament selection, and Boltzmann selection all choose chromosomes with probabilities based on their fitness. Uniform selection would choose every chromosome with equal probability, ignoring fitness, so it is not used as a standard chromosome selection method.

Browsers convert HTML into a tree structure called DOM (Document Object Model) .

Concept

During a mass movement, nationalist leaders often combined political mobilization with public associations, volunteer groups, and physical-training bodies.

To identify the founder of such a body, match its documented origin with the leader's regional network and period of activity.

Application

The Lathi Club was formed to organize lathi practice and physical preparedness among volunteers. Historical accounts of nationalist physical-culture initiatives attribute the start of this club to Bal Gangadhar Tilak.

Contrast

• Bhagat Singh advanced youth political organization in Punjab through the Naujawan Bharat Sabha, founded in 1926.

• Lala Lajpat Rai founded the Servants of the People Society in 1921 to train workers for public service.

• Bipin Chandra Pal spread Swadeshi ideas in Bengal through journals such as New India and through public lectures.

• Bal Gangadhar Tilak promoted mass organization in Maharashtra through public Ganapati festivals and Shivaji festivals.

Cross-check

The club's Swadeshi-era physical-training purpose fits Tilak's documented program of organized public mobilization. Therefore, Bal Gangadhar Tilak is the best-supported answer among the given names.

CONCEPT

Traditional authorship of ancient religious texts is identified by matching the text’s sectarian tradition, subject matter, and transmitted attribution. Such attributions express a historical tradition rather than a modern claim of individually documented composition.

APPLICATION

The Kalpasutra is a Shvetambara Jain text containing accounts of the Tirthankaras, especially Mahavira, and rules for monastic life. Jain tradition attributes its compilation to the acharya Bhadrabahu. Therefore, the named author among the choices is Bhadrabahu.

CONTRAST AND CROSS-CHECK

• Katyayan is associated with Sanskrit grammar and the varttika tradition.

• Buddhaghosa is a Theravada Buddhist commentator associated with the Visuddhimagga.

• Nagsen (Nagasena) is the Buddhist monk in the dialogue Milindapanha.

The other three names belong to Sanskrit grammatical or Buddhist traditions, whereas Bhadrabahu belongs to the Jain monastic tradition connected with this text.

RESULT

Thus, the traditionally credited author is Bhadrabahu.

Concept

Democratic decentralisation distributes governing authority among elected bodies at village, intermediate, and district levels.

Committees on local government are distinguished by their purpose: initial institutional design, administrative strengthening, or constitutional recognition.

Application

The 1957 committee chaired by Balwant Rai Mehta evaluated the Community Development Programme and National Extension Service. It recommended democratic decentralisation through a three-tier Panchayati Raj structure, which makes Balwant Rai Mehta the person associated with the architecture of the system.

Contrast and cross-check

• Acharya Narendra Dev is chiefly associated with socialist thought and education.

• G. V. K. Rao chaired the 1985 committee that focused on administrative arrangements for rural development.

• L. M. Singhvi chaired the 1986 committee that recommended constitutional recognition for Panchayati Raj institutions.

Official government accounts trace adoption of the three-tier Panchayat framework to the Balwant Rai Mehta Committee, while the later Rao and Singhvi committees dealt with strengthening administration and constitutional status.

Therefore, the best-supported offered value is B. R. Mehta, meaning Balwant Rai Mehta.

Concept

Under India’s constitutional scheme, international relations and treaty-making fall within the Union executive sphere. Article 53 vests the Union’s executive power in the President, while Article 74 requires the President to act on the aid and advice of the Council of Ministers.

This separates the formal constitutional authority from the officials and ministries that conduct negotiations in practice, and from Parliament’s role in implementing treaty obligations through domestic law.

Application

Among the listed authorities, the President represents the Union’s formal executive authority for treaty-making. The Prime Minister, Cabinet and Ministry of External Affairs direct and conduct the practical negotiations, but they do so through the Union executive acting constitutionally in the President’s name.

Contrast

• Parliament may legislate under Article 253 to implement treaties, but that is a legislative implementation role.

• The Prime Minister heads the Council of Ministers and directs foreign policy in practice, while the formal Union executive authority is vested in the President.

• The Speaker of the Lok Sabha presides over the House and has no separate treaty-making authority.

Cross-check

Articles 53 and 74 identify the constitutional location and manner of exercising Union executive power; Article 253 separately identifies Parliament’s implementation power. This division confirms the President as the intended constitutional answer among the choices.

Therefore, the answer is President.

Concept

Medieval rulers used honorifics and regnal titles to express rank, legitimacy, or sovereignty. Such a title must be matched through historical usage, not inferred merely from a ruler’s fame or dynasty.

The Persian honorific “Hazrat-i-Ala” conveys the sense of an exalted or high personage.

Application

Historical accounts associate “Hazrat-i-Ala” with Sher Khan, who later ruled as Sher Shah Suri. Born Farid Khan, he established the Sur Empire after defeating Humayun and ruled northern India from 1540 to 1545.

Contrast

• Babur, born Zahir-ud-din Muhammad, founded Mughal rule in India in 1526.

• Akbar, formally Jalal-ud-din Muhammad Akbar, was a Mughal emperor who began his reign in 1556.

• Shah Jahan, born Prince Khurram, was the Mughal emperor from 1628 to 1658.

• Sher Shah, born Farid Khan and earlier known as Sher Khan, was the Sur ruler linked with the honorific in the question.

Result

Therefore, the ruler who adopted the title “Hazrat-i-Ala” was Sher Shah.

A system using multiple bits per pixel is called a Pixmap (pixel map).

An operating system performs: Memory management

Process management

Processor management

But Virus protection is NOT an OS function (it is done by antivirus software).

An NFA with n states can be converted to an equivalent DFA that has at most 2ⁿ states. Reason: In the subset construction, each DFA state represents a subset of the NFA's n states. An n-element set has 2ⁿ possible subsets, so in the worst case the DFA can have up to 2ⁿ states (though often it will have fewer).

Operations like zooming, shrinking, and rotating rely on Interpolation , which estimates pixel values during resizing or transformation.

HTML void elements are empty tags with no closing tag. <br> is a void (empty) element.

Concept

An atomic commit protocol (such as two-phase commit) is a variation of the distributed consensus problem: every participant must reach one agreed-upon outcome for a transaction. Such a protocol is defined by a fixed set of correctness properties — Agreement, Validity, and Termination (with Integrity) — and any term outside this set is simply not a property of the protocol.

Application

Check each listed term against the defined correctness properties of an atomic commit / consensus protocol:

Result

Three of the listed terms are genuine required properties, so each correctly describes the protocol. “Sincerity” is not a property of any atomic commit or consensus protocol, so it is the statement that is incorrect for the protocol — which is exactly what the question asks for.

Concept

The India State of Forest Report (ISFR), published biennially by the Forest Survey of India (FSI) under the Ministry of Environment, Forest and Climate Change, includes a dedicated chapter assessing forest cover in "tribal districts" — districts notified as having a significant Scheduled Tribe population. In this chapter, states are compared by the absolute COUNT of tribal districts they contain, which is a separate metric from a state's tribal population percentage.

Application

The ISFR 2023 (Volume II) state profiles list the following tribal-district counts for the four states offered:

Reading the table: 24 is the largest of the four counts, so Madhya Pradesh has the maximum number of tribal districts among the states offered.

Cross-check

This is consistent with Madhya Pradesh's size and administrative structure: it has one of India's largest Scheduled Tribe populations in absolute numbers, spread across a large number of its districts. Mizoram and Nagaland, by contrast, have a HIGH PERCENTAGE of tribal population but a small total number of districts overall, which caps how many tribal districts they can have even though nearly all of their districts qualify. Count-of-districts and population-percentage are two different rankings, and this question specifically asks about the count.

In regular expressions, the operator * means iteration (zero or more repetitions).

Concept

Soil names and properties are distinct kinds of facts. A soil type may be identified by a regional name, while its mineral profile is established from its characteristic constituents; each statement must therefore be tested independently.

Application

Apply the two checks separately:

• The name check: black soil is also called Regur, so the first statement records its accepted regional name.

• The composition check: black soil is characteristically rich in calcium carbonate or lime, calcium, potash and iron-bearing minerals, so the second statement records recognized constituents of this soil.

Contrast

Contrast the offered combinations by value:

• Only 1 accepts the name fact but excludes the mineral-composition fact.

• Only 2 accepts the mineral-composition fact but excludes the name fact.

• The combination “Both 1 and 2” accepts the name fact and the mineral-composition fact together.

• The combination “Neither 1 nor 2” rejects both the name fact and the mineral-composition fact.

Result

Both independent checks hold; therefore, the result is Both 1 and 2.

• Not Regular → because rules like S → aSb are not allowed in regular grammar

• Not Context-Free → LHS must be a single non-terminal (violated by bca → ...)

• Not Context-Sensitive → length decreases in bca → b

✔️ Therefore, the grammar belongs to Type-0 (Unrestricted Grammar)

Concept

A river island is a landform enclosed by channels within a river system. To locate one, identify its region and match that region with the river system that contains it.

Application

Majuli is in Assam and lies within the channel system of the Brahmaputra. The Brahmaputra carries a heavy sediment load and has shifting braided channels that create and reshape river islands.

Contrast

• Krishna: a peninsular river draining toward the Bay of Bengal.

• Godavari: a peninsular river system of central and southern India.

• Indus: a river system flowing mainly through Ladakh and Pakistan toward the Arabian Sea.

Cross-check and result

Authoritative references on Majuli identify it as an island in the Brahmaputra River in Assam. Therefore, Majuli Island is situated in the Brahmaputra River.

Concept

In a Presidential election, the validity of a nomination paper depends on statutory support from electors in two separate roles: proposers and seconders.

The law sets a minimum for each role independently; meeting one count does not compensate for a shortfall in the other.

Application

Section 5B(1)(a) of the Presidential and Vice-Presidential Elections Act, 1952 requires a nomination paper to be subscribed by at least fifty electors as proposers and at least fifty electors as seconders.

Therefore, the required pair is 50 proposers and 50 seconders.

Contrast

• 10-10 assigns ten electors to each role, which is below the separate statutory minimum for each role.

• 25-25 assigns twenty-five electors to each role, which is below the separate statutory minimum for each role.

• 15-15 assigns fifteen electors to each role, which is below the separate statutory minimum for each role.

• 50-50 assigns fifty electors to each role and reaches the statutory minimum in both roles.

Cross-check

Checking the two roles separately gives proposer count = 50 and seconder count = 50; neither count is below the legal minimum.

Result

The minimum requirement is 50 proposers and 50 seconders.

Correct answer: E–Shram

Concept

A constitutional-right question is solved by matching the right named in the stem with the operative subject of the relevant Article.

Nearby Articles may all protect liberty in a broad sense, but each has a distinct legal scope: conviction, life and personal liberty, arrest and detention, or religious administration.

Application

The stem uses the expression ‘protection of life and personal liberty’. Article 21 provides that no person shall be deprived of life or personal liberty except according to procedure established by law. Thus, the value asked for is Article 21.

Contrast

• Article 20 deals with safeguards relating to conviction for offences, including ex post facto punishment, double jeopardy, and self-incrimination.

• Article 22 deals with safeguards associated with arrest and detention, including information about the grounds of arrest and access to legal counsel.

• Article 26 deals with the freedom of religious denominations to establish institutions and manage religious affairs.

Cross-check

The exact constitutional phrase ‘life or personal liberty’ appears in Article 21, confirming the match by wording as well as by legal scope.

Correct answer: Benjamin List

Concept: The Constitution establishes key institutions through specific articles. To identify the relevant provision, match the institution named in the question with the subject assigned to each article rather than relying on the numerical sequence.

Application: Article 324 vests the superintendence, direction and control of the preparation of electoral rolls and the conduct of elections in an Election Commission.

Contrast:

• Article 322 concerns the expenses of the Union and State Public Service Commissions.

• Article 324 concerns constitutional supervision, direction and control of electoral rolls and elections.

• Article 352 governs a Proclamation of Emergency when India's security is threatened by war, external aggression or armed rebellion.

• Article 361 provides specified immunities to the President and Governors during their terms of office.

Cross-check: These four provisions cover distinct constitutional subjects. Only Article 324 deals with the constitutional authority responsible for election administration. Therefore, the required provision is Article 324.

An XML document that follows all XML 1.0 syntax rules , so that both its physical structure and logical structure are correct (proper nesting, required start and end tags, correct attribute format and structure), is called a well-formed XML document . A valid XML document is one that is well-formed and also follows the rules of a DTD or schema, but the question is only about following syntax rules, so the correct term here is well-formed .

Concept

For institutional-history questions, distinguish an institution's original founder from people associated with a later successor institution.

The founding date and the institution's continuity are stronger evidence than a person's broader association with the same city or university.

Application

Banaras Hindu University's Central Hindu Boys School records that Dr Annie Besant established the school on 7 July 1898 in a rented house at Karnaghanta, Varanasi. It later moved to Kamachha and was handed to the Banaras Hindu University Society in 1914.

Contrast

• Vivekananda founded the Ramakrishna Mission, a separate religious and service organization.

• Annie Besant founded the Central Hindu institution at Banaras in 1898.

• Madan Mohan Malaviya led the movement that created Banaras Hindu University in 1916, the later university connected with the school.

• Dayanand Saraswati founded the Arya Samaj, a different reform organization.

Cross-check

BHU's 2022–23 annual report independently states that Annie Besant established the Central Hindu Boys School on 7 July 1898, so the university record agrees with the school's history.

Result

Therefore, the Central Hindu School at Banaras was established by Annie Besant.

To obtain the negative of a digital image, each input gray level r (between 0 and L - 1) is mapped to an output gray level using the negative transformation formula: s = (L - 1) - r When r = 0 (black), s becomes L - 1 (white), so the darkest pixels become the brightest.

State space search problems can be solved mainly in two ways : Uninformed (Blind) Search

Informed (Heuristic) Search

Key idea: From P and R being regular and PQ = R, we cannot deduce that Q must be regular. Q may be regular or non-regular. Given: P is regular

R is regular

PQ = R (concatenation of P and Q)

Regular languages are closed under concatenation: if both P and Q are regular, then PQ is regular. However, the converse is not true: even if PQ is regular, Q itself need not be regular. Example where Q is regular: Let the alphabet be {a, b}. Take P = a* (regular) and Q = b* (regular). Then PQ = a*b*, which is regular.

Example where Q is not regular but PQ is still regular: Let the alphabet be {a, b}. Take P = Σ* (the set of all strings over {a, b}), which is regular.

Let Q = {a^n b^n

शिक्षक जातिवाचक संज्ञा है।

जातिवाचक संज्ञा वे शब्द होते हैं जो किसी व्यक्ति, वस्तु या प्राणी की पूरी जाति या वर्ग का बोध कराते हैं। उदाहरण के लिए: लड़का, पुस्तक, नदी, शिक्षक।

• रामायण: व्यक्तिवाचक संज्ञा — किसी विशेष ग्रंथ/नाम का बोध कराता है।

• लोहा: द्रव्यवाचक संज्ञा — किसी पदार्थ या पदार्थ के प्रकार का बोध कराता है।

• सेना: समूहवाचक संज्ञा — व्यक्तियों के समूह का बोध कराती है।

पहचानने का तरीका: यदि शब्द किसी पूरे वर्ग या पेशे को दर्शाता है तो वह जातिवाचक संज्ञा होती है।

The compiler can detect syntax errors because they break the grammar rules of the programming language before the program is run. It cannot detect logical errors automatically, because logical errors depend on the meaning of the program and usually appear only when you run it and see wrong output.

In fuzzy logic, random variables can be of two types : Discrete fuzzy random variable

Continuous fuzzy random variable

Concept: An activation record (stack frame) is the block of storage a compiler allocates for a single procedure call. The classical runtime-environment model fixes its standard fields as actual parameters, returned value, control link, access link, saved machine status, local data, and temporaries — nothing beyond that list is a distinct field.

Application: checking each option against that standard field list —

• Actual parameters — named directly in the standard list, so this is a field of the activation record.

• Returned value — named directly in the standard list, so this is a field of the activation record.

• Saved machine status — named directly in the standard list; it holds the caller's register values, program counter, and return address needed to resume execution, so this is a field of the activation record.

• Formal parameters — not named in that list. A formal parameter is only the name a function's own code uses for an incoming value; the compiler binds that name to the storage already reserved for the actual parameter (or treats it as ordinary local data), so no separate field is ever reserved for it.

Cross-check: three of the four options map onto fields explicitly named in the standard activation-record layout; the fourth, formal parameters, maps onto no field of its own — it is only an alias for storage that already exists elsewhere in the record, never a fresh allocation.

Therefore, the item that is not part of the activation record is formal parameters.

A histogram centered near the origin on the X-axis means pixel values are near 0 , indicating dark pixels .

सही उत्तर: ए, ओ

व्याख्या: संयुक्त स्वर वे होते हैं जिनमें उच्चारण के समय दो अलग स्वर की तरह की ध्वनि मिलकर सुनाई देती है।

• ए — यह संयुक्त स्वर माना जाता है क्योंकि इसका उच्चारण अ + इ के मिलन जैसा लगता है।

• ओ — यह भी संयुक्त स्वर है क्योंकि इसका उच्चारण अ + उ के सम्मिश्रण जैसा होता है।

• उ — यह एक सरल (एकल) स्वर है, इसलिए अकेला 'उ' संयुक्त स्वर नहीं है।

• ऐ — यह संयुक्त स्वर है, पर 'उ' में संयुक्त स्वर नहीं है इसलिए वह जोड़ी सही नहीं है।

• ई और ऊ — ये दोनों दीर्घ एकल स्वरों में आते हैं और संयुक्त स्वर नहीं माने जाते।

इसलिए केवल ए और ओ दोनों एक साथ ऐसे स्वर हैं जिन्हें संयुक्त स्वर कहा जा सकता है, अतः उत्तर "ए, ओ" सही है।

We count tokens (keywords, identifiers, operators, constants, parentheses, strings). Statement: For i = 1 to 10 Print (“xyz”) Next Let's count: For

i

=

1

to

10

Print

(

"xyz"

)

Next

Total = 11 tokens

Concept: An operating system manages hardware resources and provides a controlled environment in which programs execute.

Its standard services include input/output handling, protection, resource allocation, and usage accounting. Language translation is performed by system programs such as compilers.

Application: Protection controls access to shared resources; accounting records their use; and I/O handling coordinates program requests with devices. Compilation instead translates source code through a compiler.

• Protection concerns access control for memory, files, and devices.

• Accounting concerns measurement and recording of resource use.

• Compilation concerns translating source code into target or executable code.

• I/O operation handling concerns communication between programs and devices.

Cross-check: Classifying each value by its responsible component separates operating-system resource services from language-processing work.

Result: Compilation is not an operating-system service among the offered choices.

Alpha–beta pruning can be applied to any depth in a game tree. It only eliminates branches that need not be explored, regardless of depth.

A predictive parser is a kind of LL(1) parser , which follows a top-down parsing approach that builds the parse tree from the start symbol using lookahead. It does not use bottom-up or shift–reduce parsing techniques, so only the top-down approach is correct for predictive parsers.

A lexical analyzer (scanner) reads source code and breaks it into tokens such as keywords, identifiers, operators, literals, etc. Hence, its output is tokens .

Concept: A distributed mutual-exclusion algorithm is deadlock-free only if it forces one global order on all pending requests, so no set of processes can end up circularly waiting on each other's permissions. Timestamp-based total-ordering schemes guarantee this; permission/voting-based schemes in which each process waits on only an overlapping subset of the others do not guarantee it unless extra ordering or priority rules are added.

Cross-check: Lamport's and Ricart–Agrawala's algorithms are both provably deadlock-free because of their total ordering, and among the given choices only one other named algorithm remains besides “none of these” — so the deadlock-prone one must be that remaining algorithm, which also rules out “none of these.”

Therefore, the algorithm prone to deadlock is Maekawa's algorithm.

The interdisciplinary field that builds precise, testable theories about how the human mind works, combining psychology, neuroscience, linguistics, computer science and philosophy, is called Cognitive Science .

An FSM's limit is on how many internal states it holds, not on how long an input it can process. Whenever the decision at each step depends on the input only through a fixed, bounded summary of what came before it (never through the growing input itself), a finite-state machine can compute it, no matter how long the stream is.

1. Feed the two binary numbers bit by bit, starting from the least significant bit (LSB) of each.

2. Keep exactly one bit of state, the carry into the current position, so only two states are ever needed: carry = 0 and carry = 1.

3. At each step, on input bits (a, b) with incoming carry c, output (a XOR b XOR c) and move to carry' = 1 when at least two of {a, b, c} are 1, else carry' = 0, the standard full-adder rule.

4. After the last bit pair, output the final carry as the most significant bit of the sum.

Cross-check with 111 (7) + 001 (1), read LSB first: (1,1) with carry 0 gives output 0, carry 1; (1,0) with carry 1 gives output 0, carry 1; (1,0) with carry 1 gives output 0, carry 1. After the last pair the outgoing carry is 1, so it is emitted as the next (most significant) bit. Reading the bits from most significant to least significant gives 1000 in binary, which is 8, matching 7 + 1 = 8. This confirms the two-state construction and the final-carry flush work together for operands of any length.

So the remark is True. A common trap is confusing "an FSM cannot hold an arbitrarily large integer written out in its state" (true) with "an FSM cannot compute the sum of two such integers" (false). The machine never stores the whole number; it only ever tracks the single carry bit at each step, and that never grows with the operands' length.

Concept: A source coding technique removes redundancy from the source data so that the same information can be represented using fewer bits before transmission or storage. Huffman coding is a classic entropy-based source coding method that assigns shorter codewords to more probable symbols and longer codewords to less probable symbols, which reduces the average number of bits per symbol. Other techniques such as arithmetic coding, run-length coding, and DPCM are also used for data compression, but in this question the correct choice is the Huffman coding technique because it is taken as the standard example of source coding here.

Definition: An operator-precedence (operator) grammar must not have ε-productions and must not contain two adjacent nonterminals on the right-hand side of any production. These restrictions ensure well-defined operator-precedence relations.

• No ε-productions (no production whose right-hand side is ε).

• No two adjacent nonterminals on any right-hand side.

Check each grammar against these rules:

• G₁: E → E+T | T; T → T*F | F; F → i | d.

  No ε-productions and every pair of nonterminals is separated by an operator, so G₁ satisfies the operator-grammar conditions.

• G₂: same as G₁ but F → i | d | ε.

  Contains an ε-production (F → ε), which disqualifies it as an operator grammar.

• G₃: E → E+T | T; T → T*F | F | ε; F → i | d.

  Contains an ε-production (T → ε), so G₃ is not an operator grammar.

• G₄: E → E+T | T; T → F; F → i | d | F * i | ε.

  Includes an ε-production (F → ε), so G₄ is not an operator grammar.

Conclusion: Only G₁ meets the operator-grammar requirements. Because none of the provided answer choices lists only G₁, the correct choice among the given options is 'None of these'.

An agent perceives (senses) the environment using sensors . For humans: eyes, ears, nose are sensors; For robots: cameras, microphones, IR sensors, etc.

Fuzzy logic systems are modeled mainly using IF–THEN rules (fuzzy rule base). Examples: IF temperature is HIGH THEN fan speed is FAST IF–THEN–ELSE is not typical in fuzzy rule representation.

An agent perceives the environment using sensors , but an agent acts on the environment using actuators . Examples of actuators: Robot arms

Motors

Speakers

Wheels

Given: Number of processes P = 3

Total resources R = 4

Maximum need per process 2 units

To guarantee deadlock prevention , the rule is: R≥P×(max need−1)+1 Let's check: R≥3×(2−1)+1=3+1=4 And here: R=4⇒condition satisfied Since the system satisfies the condition for deadlock-free operation , 👉 deadlock can never occur .

Key idea: The Java Servlet specification defines the standard API that allows a web server to communicate with and invoke server-side Java applications (servlets). Defines how the web server passes requests to servlets and receives responses.

In a DFA with n states : Minimum final states = 0

Maximum final states = n (All states can be final)

So the sum = 0+n = n

Soft computing includes: Fuzzy Logic

Neural Networks

Genetic Algorithms

These methods are not strict and not precise , but instead: Handle uncertainty

Provide approximate solutions

Adapt to dynamically changing environments

Therefore, soft computing is characterized by adaptability , not formal or precise control. Important Points (English) Soft computing is a computational approach that deals with imprecision and uncertainty .

It includes techniques like Fuzzy Logic , Neural Networks , and Genetic Algorithms .

Soft computing does not require exact models or precise inputs .

It focuses on providing approximate but acceptable solutions .

These methods can learn and adapt to changing environments.

Soft computing systems are flexible and robust .

It is widely used in AI, machine learning, control systems, pattern recognition , and decision-making.

The key characteristic of soft computing is adaptability , not strict formal control.

When comparing entities like: points

curves

shapes

The method used is Structural Matching , because it compares the internal structure, geometry, or form of two shapes. Important Points (English) A cluster is a group of computers (nodes) that work together as a single system.

Clustering middleware manages and coordinates these computers.

It handles communication between nodes in the cluster.

It provides resource sharing , such as CPU, memory, and storage.

Clustering middleware ensures load balancing across nodes.

It supports fault tolerance by detecting node failures and reallocating tasks.

It makes the cluster appear as one unified system to users and applications.

Examples include Hadoop YARN, Kubernetes, MPI, and OpenMPI .

In distributed systems, to detect link failure or site failure , the common technique is handshaking (exchange of signals to check if the other node is alive). Token passing is for access control, not failure detection. Polling is used but not primarily for failure detection across all nodes. Important Points (English) In a distributed system , detecting link failure or site (node) failure is critical.

Handshaking is the most common technique used for this purpose.

In handshaking, nodes periodically exchange signals/messages (heartbeats).

If a node does not receive a response within a fixed time, the other node is assumed to have failed .

Handshaking helps in detecting both communication link failures and node crashes .

Token passing is mainly used for mutual exclusion and access control , not for failure detection.

Polling can be used in some cases, but it is not the standard or primary technique for failure detection in distributed systems.

Handshaking is widely used due to its simplicity and reliability .

Correct Technique: ✅ Handshaking

Adaptive grids (used in numerical methods, PDE solving, image processing, CFD, etc.) adjust the grid resolution dynamically depending on the solution behavior. They aim to balance: Accuracy → higher resolution where needed

Efficiency → avoid unnecessary computation in uniform regions

Hence, adaptive grids provide high accuracy while maintaining computational efficiency . Adaptive grids dynamically adjust grid resolution based on solution behavior.

Regions with rapid changes or high gradients use finer grids for better accuracy.

Regions with smooth or uniform solutions use coarser grids to save computation.

This approach reduces unnecessary calculations compared to uniform grids.

Adaptive grids are widely used in numerical methods, PDE solving, CFD, image processing , and simulations.

They provide a balance between high accuracy and computational efficiency .

Adaptive grids also help in reducing memory usage and execution time .

In a Distributed File System (DFS) : A file name should be independent of its physical storage location .

Users should not know or care where the file is physically stored.

File name only represents the file logically , not its real location.

Therefore, the file name does NOT reveal physical storage location . Important Points (English) In a Distributed File System (DFS) , the file name is independent of its physical storage location .

Users do not need to know where the file is actually stored in the network.

The file name provides only a logical identity , not the real (physical) location.

This property is known as location transparency .

Location transparency allows files to be moved or replicated without changing their names.

DFS improves scalability, reliability, and ease of use for distributed environments

CPU scheduling allows multiple processes to share the CPU efficiently. This is the core of a multiprogramming operating system , where: CPU utilization is maximized

Multiple programs execute concurrently

Processes are interleaved

Hence, CPU scheduling forms the basis of multiprogramming OS . Important Points (English) CPU Scheduling decides which ready process gets the CPU next.

It is essential when multiple processes are present in memory at the same time.

This situation exists in a multiprogramming operating system .

CPU scheduling helps in maximizing CPU utilization .

It allows concurrent execution of multiple programs by interleaving processes.

Without CPU scheduling, multiprogramming cannot function efficiently .

Hence, CPU scheduling forms the foundation of a multiprogramming OS .

Correct Answer: ✅ Multiprogramming operating system

Answer: <list>

• <select> is a valid HTML tag for drop-down lists.

• <input> is a valid HTML tag for form input controls.

• <textarea> is a valid HTML tag for multi-line text input. It must be written as one word.

• <list> is not a valid HTML tag; HTML lists use <ul>, <ol>, and <li>.

Therefore, <list> is the only option that is not an HTML tag.

Concept

A successful fork() call creates one new child for every process that executes it. If all existing processes reach the next fork() call, the total process count doubles after each call.

Application

1. Let P0 be the initial number of processes. Before the loop starts, P0 = 1.

2. At iteration k, every one of the Pk processes creates one child, so Pk+1 = 2Pk.

3. Applying this recurrence n times gives Pn = 2n.

4. The original process is not a child. Therefore, created children = Pn − P0 = 2n − 1.

Cross-check

For n = 3, the total process count follows 1 → 2 → 4 → 8. Thus 8 − 1 = 7 new child processes.

Result: 2n − 1 child processes.

A synapse is the junction where one neuron communicates with the next, and this junction is classified into two general types: an electrical synapse, where ionic current passes directly between the two cells through gap-junction channels, and a chemical synapse, where a chemical messenger (a neurotransmitter) is released by one neuron, diffuses across a narrow gap, and binds receptors on the neighbouring neuron to regenerate the signal. The vast majority of synapses in the vertebrate nervous system are of the chemical type; electrical synapses are the much rarer exception.

The introductory biological-neuron model taught alongside Artificial Neural Networks — and the "typical synapse" this question refers to — is the standard, chemical-type synapse: the presynaptic terminal releases neurotransmitter molecules that diffuse across the synaptic cleft and bind postsynaptic receptors, regenerating an electrical impulse in the receiving neuron. This is why the syllabus for ANN (and this UPPSC Computer Science paper) tests the biological neuron before introducing the artificial one — the artificial neuron's weighted inputs are a simplified stand-in for how a real neuron receives many such synaptic inputs of varying strength.

• Physical Process and Chemical Process both — a given synapse is classified as electrical or chemical, not both operating together at the same junction; the typical synapse this question refers to uses only the chemical route.

• Physical Process — this names the electrical (gap-junction) mechanism found at the rarer, non-typical synapse type; the typical synapse this question refers to crosses the gap chemically, not electrically.

• None of the above — the typical synapse's crossing mechanism is well-described as chemical, one of the given categories, so ruling out every listed description misses that match.

To generate a PDF response in JSP, set the contentType attribute in the page directive to a PDF MIME type (typically application/pdf). JSP

A process in the blocked state is waiting for an I/O event. When the I/O completes, the process becomes ready to run, so it moves to the Ready state (ready queue). It will enter the Running state only when the CPU scheduler selects it.

The OM (Oral Messages) algorithm is used in the Byzantine Generals (Byzantine agreement) problem to achieve consensus even when some processes may be faulty or malicious. Therefore, it is used for consensus .

Waterfall model is the least suitable for accommodating changes because it is a rigid, sequential process. Once a phase (like requirements or design) is completed, making changes typically requires going back and redoing earlier work, which is difficult and costly.

Key idea: The first derivative measures the rate of change of intensity. If the intensity is constant, it does not change, so the rate of change (first derivative) is 0.

Cloud computing is generally operating-system independent . You can access cloud services from Windows, macOS, or Linux (typically via a web browser or supported client tools). Therefore, the correct choice is: All of these operating systems.

Key idea: The exec*() family is what loads an executable file into a process. exec*() replaces the current process image with a new program from an executable binary (e.g., execve()).

fork() only creates a new process by duplicating the current one; it does not load a new executable.

Z-buffer keeps a depth (z) value for each pixel . When rendering multiple objects, the depth at a pixel is compared and the closest surface is kept. So it can represent an arbitrary number of objects ; objects are processed during rendering, but there is no fixed limit on how many objects can be handled.

Concept. McCabe's cyclomatic complexity V(G) counts the linearly independent paths through a program graph. For a graph with E edges, N nodes and P connected components, V(G) = E − N + 2P, which becomes V(G) = E − N + 2 when the graph is a single connected component. Equivalently, a planar drawing of such a graph is divided into exactly V(G) regions, counting the unbounded outer region.

Applying this to the graph shown.

1. Count the nodes. The vertices drawn are a, b, c, d, e and f, so N = 6.

2. Count the edges, one per arrow: a → b, a → c, c → b, c → e, b → d, d → b, e → d, e → f and f → d. The vertices b and d are joined by two arrows pointing opposite ways, and each arrow is its own edge, so E = 9.

3. The whole drawing is one connected component, so P = 1 and the formula reduces to V(G) = E − N + 2.

4. Substitute the counts: V(G) = 9 − 6 + 2 = 5.

Cross-check by regions. The drawing has no crossing lines, so its regions can be counted directly: the a-b-c cycle, the two-arrow loop between b and d, the area bounded by b, c, e and d, and the d-e-f cycle give 4 bounded regions, and the outer region makes 5. The cycle-space form (E − N + 1) + 1 = (9 − 6 + 1) + 1 = 5 agrees.

A common slip. Reading the two arrows between b and d as a single edge gives E = 8 and V(G) = 8 − 6 + 2 = 4, so each arrow must be counted separately.

Hence the cyclomatic complexity of the graph is 5.

Image redundancy exists because neighboring pixels are often highly correlated . This correlation creates unnecessary repeated information in the image.

Suzuki–Kasami is a token-based mutual exclusion algorithm . Message complexity: When requesting the token → (N−1) messages

When holding the token → 0 messages

So message requirement = 0 or (N−1) .

Concept: Fragmentation is wasted memory produced by a scheme's own allocation mechanics. Internal fragmentation is unused space left inside an already-allocated fixed-size unit (e.g., a page or a fixed partition), because that unit rarely matches a process's exact requirement. External fragmentation is unused space that appears between allocated blocks, as variable-size allocations and deallocations scatter free memory into small, non-contiguous holes over time.

Application: Trace what happens under each scheme:

1. Fixed-size allocation (paging/frames, fixed partitions) grants a process whole units; when its actual requirement is not an exact multiple of the unit size, the leftover space inside the last unit is internal fragmentation.

2. That leftover space stays locked inside the allocated unit and cannot be reassigned to another process, nor reduced to zero, without shrinking the unit size itself (which only trades it for higher management overhead) - so internal fragmentation persists as long as fixed-size allocation is used.

3. Variable-size allocation (dynamic partitioning, segmentation) instead lets processes take exactly the size they need; but as processes arrive and leave, the freed spaces get scattered into small, non-contiguous holes between allocated blocks - this is external fragmentation.

4. External fragmentation has a direct operational cure: compaction relocates every currently-allocated block together so the scattered holes merge into one contiguous block, removing external fragmentation completely, in principle.

5. Because external fragmentation has a technique that removes it entirely while internal fragmentation has no such fix short of abandoning fixed-size allocation altogether, the type that cannot be fully eliminated is internal fragmentation.

Cross-check:

• External fragmentation is not the answer, because compaction is a standard, well-documented technique that consolidates its scattered free memory into a single contiguous block.

• Both types together is not accurate either, since external fragmentation does have a full removal technique - treating the two as equally unremovable overstates that case.

• None of the listed options is also not right, since internal fragmentation does correctly name a fragmentation type that is structurally impossible to reduce to zero without changing the allocation scheme itself.

Note: everyday explanations sometimes stress how costly compaction is to run in practice and describe external fragmentation as the one that 'cannot be removed' - but strictly, compaction is a genuine complete-removal technique for external fragmentation, while internal fragmentation has no equivalent fix, which is why internal fragmentation is the standard keyed answer here.

PROLOG is based on First-Order Predicate Logic .

SNMP uses UDP port 161 for general communication. (Port 162 is used for traps/notifications.)

GKS basic primitives are:

• Polyline

• Polymarker

• Fill area

• Text

• Cell array

Polydraw is not a GKS primitive. Therefore, Polydraw is the correct choice for the item that is not a basic GKS primitive.

Zero-crossing based edge detection is performed by the Laplacian of Gaussian (LoG) operator.

In fuzzy logic, set membership is represented by degree of truth , not by probability. A membership function μ_A(x) assigns each element x a value in the interval [0, 1]. μ_A(x) = 0 means x is not a member of the fuzzy set.

A shadow mask CRT uses three electron beams corresponding to RGB colors. Each pixel emits Red, Green, and Blue lights.

A group of computers working together is managed by clustering middleware . It handles coordination, communication, and resource sharing.

Clipping means removing portions of objects that lie outside the viewing area . Important Points (English) Clipping is the process of removing parts of objects that lie outside the viewing area .

The viewing area is also called the clipping window or viewport .

Clipping improves display efficiency by showing only visible portions.

It is commonly applied to lines, polygons, text, and curves .

Popular algorithms include Cohen–Sutherland (line clipping) and Sutherland–Hodgman (polygon clipping) .

Clipping is widely used in computer graphics, CAD systems, and GUI rendering .

Given:

(R ∨ Q) ∧ (P ∨ ¬Q)

Using Boolean algebra:

(R + Q)(P + Q̅)

Expanding,

= RP + RQ̅ + PQ + QQ̅

Since,

QQ̅ = 0

therefore,

= RP + RQ̅ + PQ

Now check Option B:

(R + Q)(P + Q̅)(R + P)

First compute:

(R + Q)(P + Q̅)

= RP + RQ̅ + PQ

Now multiply by (R + P):

(RP + RQ̅ + PQ)(R + P)

Using absorption laws:

RP(R + P) = RP

RQ̅(R + P) = RQ̅

PQ(R + P) = PQ

Hence,

= RP + RQ̅ + PQ

which is exactly the original expression.

Therefore,

(R ∨ Q) ∧ (P ∨ ¬Q)

≡ (R ∨ Q) ∧ (P ∨ ¬Q) ∧ (R ∨ P)

Correct Option: B

The two major computer graphics types are Raster graphics and Vector graphics . Important Points (English) Computer graphics are mainly classified into Raster graphics and Vector graphics .

Raster graphics are made of pixels arranged in rows and columns.

Image quality in raster graphics depends on resolution ; enlarging causes pixelation .

Examples of raster formats include JPEG, PNG, BMP, GIF .

Vector graphics are created using mathematical equations (lines, curves, shapes).

Vector images are resolution independent and can be scaled without loss of quality.

Common vector formats are SVG, EPS, PDF, AI .

Raster graphics are widely used in photographs , while vector graphics are preferred for logos and diagrams .

LZW encoding uses fixed-length codes , not variable-length. The others (Huffman, Shannon-Fano, Adaptive Huffman) are variable-length encodings . Important Points (English) LZW (Lempel–Ziv–Welch) encoding uses fixed-length codes during encoding.

LZW works by building a dictionary dynamically and replacing repeated strings with fixed-size codewords.

Since code length remains constant, LZW decoding is simpler and faster .

Huffman encoding uses variable-length codes , where frequent symbols get shorter codes.

Shannon–Fano encoding is also variable-length , based on symbol probabilities.

Adaptive Huffman encoding updates code lengths dynamically, so it is variable-length as well.

Variable-length encodings generally achieve better compression than fixed-length methods.

When a plane is parallel to the projection plane , it appears in its true size . Important Points (English) When a plane is parallel to the plane of projection , its true size and shape are seen.

There is no foreshortening because all points of the plane are at the same distance from the projection plane.

True size is visible on the projection plane to which the object is parallel .

If the plane is parallel to HP (Horizontal Plane) , true shape appears in the top view .

If the plane is parallel to VP (Vertical Plane) , true shape appears in the front view .

This concept is widely used in engineering drawing to understand object geometry clearly.

Mirror image is always obtained using reflection transformation. Important Points (English) A mirror image is produced using a reflection transformation .

Reflection creates a flipped image across a mirror line (axis).

The size and shape of the object remain unchanged after reflection.

Orientation changes: left becomes right and right becomes left .

The mirror line is the perpendicular bisector of the line joining a point and its image.

Reflection is an isometric transformation , so distances are preserved.

Complement of a fuzzy membership value is: μ′=1−μ So: For X 1 ​: 1−0.8=0.2

For X 2 ​: 1−0.2 = 0.8

Thus complement = {(X₁, 0.2), (X₂, 0.8)}

In a distributed system, each processor works independently and therefore must have: Its own local memory

Its own clock

Important Concept (English) In a distributed system , multiple processors (nodes) work independently and communicate through a network. Each processor must have its own local memory because there is no shared global memory. Each processor also has its own clock , as there is no single global clock controlling all processors. Because of different clocks, clock synchronization becomes an important issue in distributed systems.

In UNIX, cpio (copy in–copy out) is a standard command used for backup and restore operations. Important UNIX Backup-Related Commands (English) tar – Used to create and extract backup archives

cpio – Used for creating and restoring backups

rsync – Used for incremental backup and data synchronization

dump / restore – Used for full filesystem backup and recovery

dd – Used to take disk or partition-level backup

“Happy” or “Unhappy” states refer to how good or bad a situation is , which is evaluated using a utility function . Only Utility-based agents use utility to select the best action.

सही उत्तर: शिक्षक — जातिवाचक संज्ञा

परिभाषा: जातिवाचक संज्ञा किसी वर्ग, प्रकार या पेशे के लोगों/वस्तुओं का सामान्य नाम होती है।

• रामायण → यह एक ग्रंथ/पुस्तक का विशेष नाम है, इसलिए व्यक्तिवाचक (विशेष नाम) संज्ञा।

• लोहा → यह किसी पदार्थ/धातु का नाम है, इसलिए द्रव्यवाचक संज्ञा।

• शिक्षक → यह किसी वर्ग/पेशे के लोगों का सामान्य नाम है (उदा. एक शिक्षक, कई शिक्षक), इसलिए जातिवाचक संज्ञा।

• सेना → यह लोगों का समूह बताने वाला शब्द है, इसलिए समूहवाचक संज्ञा।

याद रखने का उपाय: किसी शब्द को देखें और सोचें कि वह किसी विशेष नाम बताता है, किसी पदार्थ को बताता है, किसी वर्ग/प्रकार को बताता है या किसी समूह को — इससे संज्ञा का प्रकार तुरंत पहचान में आ जाएगा।

ऊष्म ध्वनियाँ (Fricatives) — वे ध्वनियाँ जो उच्चारण में वायु के संकुचित मार्ग से गुजरते समय घर्षण (friction) उत्पन्न करती हैं। हिन्दी में ऊष्म ध्वनियाँ हैं: श, ष, स, ह — उदाहरण: श (शेर), ष (विष), स (सूर्य), ह (हाथ)।

• समास का अर्थ है — दो या अधिक शब्दों का संयोग।

• विलोम: व्यास — जिसका अर्थ है विस्तार, फैलाव, या अलग‑अलग होना।

सही उत्तर: व्यास।

संक्षिप्त स्पष्टीकरण:

• क्यों सही: 'समास' शब्दों के मिलन का भाव देता है; 'व्यास' मिलन के विपरीत फैलाव/अलग‑अलग होने का भाव देता है, इसलिए यह विलोम है।

• क्यों अन्य विकल्प गलत हैं: 'मधुमास', 'कपास', और 'प्रयास' इन शब्दों के अर्थ 'संयोग/विभाजन' से संबंधित नहीं हैं और इसलिए वे समास के विलोम नहीं हैं।

“कोटि” के अर्थ होते हैं:

• प्रकार / वर्ग / श्रेणी