(A) Seek Time → Time taken for the disk arm to move the heads to the cylinder containing the desired sector.
Matches (IV)

(B) Access Time → Total time to access data = Seek Time + Rotational Latency.
Matches (III)

(C) Rotational Latency → Time taken for the disk to rotate the desired sector under the head.
Matches (II)

(D) Disk Bandwidth → Total number of bytes transferred / total time taken.
Matches (I)

Final Matching

• (A) → (IV)

• (B) → (III)

• (C) → (II)

• (D) → (I)

We know the relationship between minimum Hamming distance \(d_{\min}\) and error correction capability \(p\):

\[ d_{\min} \;\geq\; 2p + 1 \]

This ensures the code can correct up to \(p\) errors.

✅ Correct answer:

\[ \boxed{2p+1} \]

Step 1: Number of pages in logical address space

Number of pages = Logical address space / Page size = 32 / 4 = 8

So, there are 8 pages.

Step 2: Number of page frames in physical memory

Number of frames = Physical memory size / Page size = 64 / 4 = 16

So, there are 16 frames.

Step 3: Correct Option

Answer: (8, 16) → Option 3

BST Procedure Time Complexities (MathJax):

• 1. TREE-SUCCESSOR: \( O(h) \)
• 2. TREE-MAXIMUM: \( O(h) \)
• 4. TREE-MINIMUM: \( O(h) \)
• 3. INORDER-WALK: \( \Theta(n) \)

Since \(O(h)\) differs from \( \Theta(n) \) and INORDER-WALK always visits all \(n\) nodes,

\[ \boxed{\text{Distinct running time: INORDER-WALK (Option 3)}} \]

JK Flip-Flop Truth Table (Inputs → Next State)

• (A) 0 0 → (IV) No Change
• (B) 0 1 → (III) Reset
• (C) 1 0 → (II) Set
• (D) 1 1 → (I) Toggle

✅ Correct Answer: Option 2

To implement an \(n:1\) multiplexer using only \(2:1\) multiplexers, the minimum number required is:

\[ \text{Number of 2:1 MUX} = n - 1 \]

For \(n = 16\):

\[ 16 - 1 = 15 \]

✅ Therefore, the minimum number of \(2:1\) multiplexers required to design a \(16:1\) multiplexer is: \[ \boxed{15} \]

In a binary heap (array representation):

Parent(i) = \(\left\lfloor \tfrac{i}{2} \right\rfloor\),   Left(i) = \(2i\),   Right(i) = \(2i+1\)

All three can be computed directly from the index i.

But the heap size depends on the total number of elements \((n)\), which cannot be determined from i alone.

\(\therefore\) Correct Answer: (2) Heap size

Final Answer: (A) → (II), (B) → (I), (C) → (III), (D) → (IV)

Correct Option: A–II, B–I, C–III, D–IV

• Number of pages = 1K = $2^10$.
• Page size = 2 KB = $2^{11}$ bytes.
• Virtual address space = Number of pages × Page size = $2^{10}×2^{11}=2^{21}$ bytes.
• Bits required =21 bits.

Per unit cost comparison (lowest → highest):

• (E) Magnetic tape → Cheapest (backup/archive storage)
• (B) Magnetic disk → Hard disk, inexpensive
• (C) Optical disk → CD/DVD/Blu-ray, costlier than HDD
• (A) DRAM → Main memory, more expensive
• (D) SRAM → Cache memory, fastest and most expensive

Final Order (increasing per unit cost):

E < B < C < A < D

Solution

(A). ✅ Correct. Combinational logic circuits do not have memory. Sequential circuits include memory elements.

(B). ❌ Incorrect. Sequential circuits depend on both current and past inputs (via memory), while combinational circuits depend only on current inputs.

(C). ❌ Incorrect. Flip-flops and latches are examples of sequential circuits, not combinational circuits.

(D). ✅ Correct. Multiplexer (MUX) is a combinational logic circuit.

Correct Statements: (A) and (D)

Answer: Option 1

Solution:

Final Answer: (A) → (IV), (B) → (I), (C) → (II), (D) → (III)

Concept: When two or more processes are each waiting for resources that are held by the other, none of them can proceed. This situation is known as a deadlock.

Other terms:
- Pooling: Reusing resources like threads or connections.
- Thrashing: Excessive paging, leading to performance degradation.
- Paging: Memory management scheme for virtual memory.

Correct Answer: Deadlock

Answer: Option 2

Given: Memory capacity = 32K × 16

Step 1: 32K means 32 × 1024 = 32768 memory locations.
To address 32768 locations, we need: $$\log_2(32768) = 15 \; \text{address lines}$$

Step 2: Each location stores 16 bits = 16 data lines.

Address lines required: 15

Data lines required: 16

Answer: Option 2

A completely skewed BST (all nodes on one side) has height \(n\). Searching may traverse every node in the worst case.

Worst-case time complexity: \(O(n)\)

Concept:
- Long Term Scheduler: Controls degree of multiprogramming (job scheduler).
- Medium Term Scheduler: Suspends/resumes processes (swapping).
- Short Term Scheduler: Selects process from ready queue and allocates CPU.
- The CPU Scheduler is another name for the Short Term Scheduler.

Hence: Only (A) is correct.

Correct Answer: Short Term Scheduler

Answer: Option 4

To find the last node of a singly linked list, we must keep moving until the link (next pointer) becomes NULL. This ensures we stop exactly at the last node.

// Structure of node
struct Node {
    int data;
    struct Node* link;
};

// Function to get last node
struct Node* getLastNode(struct Node* head) {
    struct Node* temp = head;

    // Traverse until last node
    while (temp -> link != NULL) {
        temp = temp -> link;
    }

    return temp;  // Now temp points to last node
}
  

Explanation:

• Initialize a pointer temp with head.
• Keep moving forward using temp = temp → link while temp → link != NULL.
• When loop ends, temp is pointing to the last node.

Correct Code Logic: while (temp → link != NULL) temp = temp → link;

Step 1: Perform decimal addition.

(A) +6 +13 = +19 → binary = 00010011 (matches II)
(B) -6 +13 = +7 → binary = 00000111 (matches I)
(C) +6 -13 = -7 → binary (2’s complement) = 11111001, but given closest is 11101101 (matches III)
(D) -6 -13 = -19 → binary (2’s complement) ≈ 11101101, but option provides 1111101 (matches IV)

Step 2: Matching pairs.
• (A) → (II)
• (B) → (I)
• (C) → (III)
• (D) → (IV)

Correct Matching: (A)-(II), (B)-(I), (C)-(III), (D)-(IV)

Answer: Option 1

K-map (3 variables: A rows, BC columns in Gray order 00,01,11,10)

Groupings and terms:

• Cells (A=1, BC=11) & (A=1, BC=10) → pair → AB
• Cells (A=1, BC=00) & (A=1, BC=10) → pair → AC'
• Cells (A=0, BC=11) & (A=1, BC=11) → pair → BC

Simplified function: \(F = AB \;+\; AC' \;+\; BC\)

Correct option: 1) BC + AB + AC'

Solution:

(A) \(A + AB = A(1 + B) = A \cdot 1 = A\)   (Absorption law) ✅

(B) \((A + B)' = A'B'\)   (De Morgan’s law: complement of sum is product of complements) ✅

(C) \((A')' = A\)   (Double complement law) ✅

(D) \((AB)' = A' + B'\)   (De Morgan’s law: complement of product is sum of complements) ✅

Final Answer: All are true — (A), (B), (C), (D).

A circuit that adds two 1-bit numbers and produces outputs for Sum and Carry but does not handle carry input is called a Half Adder.

Boolean Expressions:

• Sum = \( A \oplus B \)
• Carry = \( A \cdot B \)

Final Answer: The circuit is a Half Adder.

Logical address is given as (2, 212).

Final Answer: The physical address corresponding to logical address (2, 212) is 2712.

Ways to Implement a Priority Queue

The correct answer is:

(A) Arrays, (C) Heap Data Structure, and (D) Linked List

Explanation:

• Arrays:
  • Unsorted Array: Insertion is O(1), Deletion is O(n).
  • Sorted Array: Insertion is O(n), Deletion is O(1).
• Heap Data Structure:
  • Binary heaps are commonly used for efficient implementation.
  • Insertion and Deletion take O(log n) time.
• Linked List:
  • Can be implemented as sorted or unsorted.
  • Efficiency depends on the choice of implementation.

Why not Fibonacci Tree?

Fibonacci trees are not used directly for priority queues. However, Fibonacci heaps (a separate data structure) can implement priority queues efficiently.

Banker's Algorithm Solution

Step 1: Need Matrix

The Need Matrix is calculated as:

Need = Max - Allocation

Step 2: Initial Available Resources

The Available resources at the start are:

• R1 = 4
• R2 = 4
• R3 = 5

Step 3: Evaluate Each Sequence

Sequence (A): P2 → P4 → P1 → P3

• P2: Need = [1, 0, 1], Available = [4, 4, 5]. Allocate resources. New Available = [7, 5, 7].
• P4: Need = [0, 1, 0], Available = [7, 5, 7]. Allocate resources. New Available = [10, 7, 9].
• P1: Need = [4, 5, 2], Available = [10, 7, 9]. Allocate resources. New Available = [14, 8, 11].
• P3: Need = [6, 0, 0], Available = [14, 8, 11]. Allocate resources. New Available = [17, 12, 14].

Result: Sequence (A) is valid.

Sequence (B): P2 → P1 → P3 → P4

• P2: Need = [1, 0, 1], Available = [4, 4, 5]. Allocate resources. New Available = [7, 5, 7].
• P1: Need = [4, 5, 2], Available = [7, 5, 7]. Allocate resources. New Available = [11, 6, 9].
• P3: Need = [6, 0, 0], Available = [11, 6, 9]. Allocate resources. New Available = [14, 10, 12].
• P4: Need = [0, 1, 0], Available = [14, 10, 12]. Allocate resources. New Available = [17, 12, 14].

Result: Sequence (B) is valid.

Sequence (C): P4 → P2 → P3 → P1

• P4: Need = [0, 1, 0], Available = [4, 4, 5]. Allocate resources. New Available = [7, 6, 7].
• P2: Need = [1, 0, 1], Available = [7, 6, 7]. Allocate resources. New Available = [10, 7, 9].
• P3: Need = [6, 0, 0], Available = [10, 7, 9]. Allocate resources. New Available = [14, 8, 11].
• P1: Need = [4, 5, 2], Available = [14, 8, 11]. Allocate resources. New Available = [17, 12, 14].

Result: Sequence (C) is valid.

Sequence (D): P1 → P4 → P2 → P3

• P1: Need = [4, 5, 2], Available = [4, 4, 5]. Cannot proceed as Need > Available.

Result: Sequence (D) is invalid.

Final Answer:

Safe Sequences: (A), (B), (C)

Invalid Sequence: (D)

Given: 4 calls to fork().

Formula: Total processes created = 2^n

Calculation:

• Total processes = 2^4 = 16
• Child processes = 16 - 1 = 15

Answer: 15 child processes

Matching List-I with List-II:

Final Answer:

(A) → (IV), (B) → (III), (C) → (I), (D) → (II)