Solution

Nyquist Sampling Theorem states:

Sampling frequency must be at least twice the maximum frequency present in the signal.

$ f_s \ge 2f_{max} $

Solution

Dual is obtained by interchanging:

$+$ ↔ $\cdot$

$0$ ↔ $1$

Applying dual rule:

A → III

B → IV

C → II

D → I

Solution

Tokens are the smallest meaningful units of a program.

Break the statement:

for | i | in | range | ( | begin | : | end | : | step | ) | :

Tokens:

for

i

in

range

(

begin

:

end

:

step

)

:

Total tokens = 12

Solution

From the diagrams:

• Both machines are deterministic (each state has exactly one transition for each input symbol).

• The first machine has states A and B with transitions on a and b.

• The second machine has states A, B, C, but the accepted language behavior matches the first machine.

Both machines accept the same language, even though the number of states differs.

Thus they are equivalent machines.

Solution

Complement of fuzzy set:

$\mu_{A'}(x) = 1 - \mu_A(x)$

Compute:

$x_1$: $1 - 0.3 = 0.7$

$x_2$: $1 - 0.7 = 0.3$

$x_3$: $1 - 0.4 = 0.6$

Thus,

$A' = {(x_1,0.7),(x_2,0.3),(x_3,0.6)}$

Solution

Interrupt Service Routine (ISR) steps:

Save processor registers → C

Check which device raised interrupt → D

Service the device → B

Restore processor registers → E

Re-enable interrupt facility → A

Correct sequence:

C, D, B, E, A

Solution

Number of spanning trees:

For complete graph:

$\tau(K_n)=n^{n-2}$

A: $K_3 = 3^{1} = 3$

B: $K_4 = 4^{2} = 16$

For complete bipartite graph:

$\tau(K_{m,n}) = m^{n-1} n^{m-1}$

C: $K_{2,2} = 2^{1} \times 2^{1} = 4$

For cycle graph:

$\tau(C_n)=n$

D: $C_5 = 5$

Thus:

A = 3

C = 4

D = 5

B = 16

Increasing order:

A, C, D, B

Solution

Standard I/O techniques are:

• Programmed I/O

• Interrupt-driven I/O

• Direct Memory Access (DMA)

Rotational I/O and Channelized I/O are not standard CPU I/O techniques.

Thus:

A, B, D are correct.

Solution

Common properties of social networks:

• Scale-free degree distribution → True

• Small world property → True

• Short average path length → True

However, most social networks are not necessarily directed; many are modeled as undirected networks.

Thus the statement that is not a common property is:

Solution

A grammar is ambiguous if a string generated by it has more than one parse tree.

Equivalent definitions:

• More than one leftmost derivation

• More than one rightmost derivation

Thus the correct statements are:

B and C.

Solution

Steps in page replacement:

No frame is free → D

Find a frame to replace → A

Free that frame → E

Update the page table → B

Use the freed frame for the new page → C

Solution

Typical DBMS query processing steps:

Scanning, parsing and validating → C

Query optimizer → A

Query code generator → D

Runtime database processor → B

Correct order:

C → A → D → B

Solution

Insert words sequentially into BST.

banana → root

peach → right of banana

apple → left of banana

pear → right of peach

coconut → left of peach

mango → right of coconut

papaya → right of mango

Longest path:

banana → peach → coconut → mango → papaya

Number of edges = 4

Solution

Verification → Quality Assurance → IV

Validation → Quality Control → III

Internal logic exercise → White box testing → I

Software requirement exercise → Black box testing → II

Matching:

A → IV

B → III

C → I

D → II

Solution

Memory required:

$2048 \times 8$

Each chip:

$128 \times 4$

First match word size:

$8 / 4 = 2$ chips per word.

Now match number of words:

$2048 / 128 = 16$

Total chips:

$16 \times 2 = 32$

Solution

A: False when $r=1, p=0$ → Not tautology

B: False when $p=1, r=0$ → Not tautology

C:

$\sim p \rightarrow (p \rightarrow r)$

Always true → Tautology

D:

$(p \land r) \rightarrow (p \rightarrow r)$

Always true → Tautology

E:

$\sim(p \rightarrow r) \rightarrow p$

Always true → Tautology

Thus tautologies:

C, D, E

Solution

Sequential circuits depend on previous state (memory).

• Flip-flop → sequential circuit

• Counter → sequential circuit

Multiplexer, Decoder and Adder are combinational circuits.

Solution

Union → User defined data type → IV

Function → Subroutine → III

Interactive Environment → Virtual Reality → I

Output device → Shadow mask → II

Matching:

A → IV

B → III

C → I

D → II

Solution

A Perceptron is a single-layer feed-forward neural network used for linear classification.

Solution

Backtracking → Predictive parsing may require backtracking → III

Infinite languages with matching numbers → handled using Automata → I

Canonical LR parser → requires large number of states → IV

Post Correspondence Problem → Undecidable problem → II

Matching:

A → III

B → I

C → IV

D → II

Solution

Transmission delay

$= \frac{\text{Frame size}}{\text{Bandwidth}}$

$= \frac{10\times10^6}{6\times10^6}$

$= 1.6667\ s$

Propagation delay

Distance $=5000\ km =5\times10^6\ m$

$= \frac{5\times10^6}{2\times10^8}$

$=0.025\ s$

Router delay

Each router delay $=2\mu s+1\mu s=3\mu s$

Total routers $=20$

Total delay $=20\times3\mu s=60\mu s=0.00006\ s$

Total latency

$=1.6667+0.025+0.00006$

$\approx1.691726\ s$

Solution

First bit is fixed as 0, so remaining 3 bits are free.

Possible strings:

0000

0001

0010

0011

0100

0101

0110

0111

Total outcomes $=8$

Strings with at least two consecutive 0's:

0000

0001

0010

0011

0100

Favourable outcomes $=5$

Probability

$=\frac{5}{8}$

Solution

In LR parsing, shift-reduce conflicts occur when the parser can either shift the next input symbol or reduce using a rule.

These conflicts are resolved using operator precedence and associativity rules.

Solution

Backpropagation computes error at the output layer (sink) and propagates the error backwards through hidden layers toward the input layer (source) to update weights.

Solution

Speed hierarchy of memory/storage:

CPU Registers → fastest

SRAM → cache memory

DRAM → main memory

Hard Disk → secondary storage

Magnetic Tape → slowest storage

Order:

C → B → A → E → D

Solution

A → False (only owner or DBA can grant privileges)

B → True

C → False (system error is not a malicious attack)

D → True

False statements:

A and C

Solution

Solution

Regular languages:

Closed under union, concatenation, intersection, complement, kleene star.

Context-free languages:

Closed under union, concatenation, kleene star.

Not closed under intersection and complement.

Thus incorrect statements:

C and D

Solution

• Digital Signature → Confirms authenticity and integrity 
• Hash Function → Produces a fixed-size digest 
• AES → Symmetric encryption algorithm 
• RSA → Asymmetric encryption algorithm

Solution

Effective address:

$EA = ADR + XR$

This is indexed addressing, where the address field is added to the index register.

Solution

• LL(0) is the weakest (no lookahead, top-down).
• LR(0) is stronger than LL(0) (bottom-up, no lookahead).
• SLR(1) adds 1-symbol lookahead using FOLLOW sets → accepts more grammars than LR(0).
• LALR(1) merges LR(1) states; more powerful than SLR(1) but below LR(1).
• LR(1) is the most powerful among these deterministic bottom-up parsers.

Solution

For 8-bit signed integer (two’s complement):

Range = $-2^{7}$ to $2^{7}-1$

Least value = $-128$

For 8-bit unsigned integer:

Range = $0$ to $2^{8}-1$

Least value = $0$

Solution

• An adjacency matrix represents a graph using a 2D array (matrix).
• This type of storage uses sequential memory allocation — rows and columns are stored in contiguous memory.
• Hence, this method is called a Sequential Representation of a graph.

Solution

Cardinality means number of elements in the set.

$|A_1| = 2$

$|A_2| = 4$

$|A_3| = 1$

$|A_4| = 3$

$|A_5| = 5$

Increasing order:

$1 < 2 < 3 < 4 < 5$

So order becomes:

$A_3, A_1, A_4, A_2, A_5$

Solution

• User-Mode Programs have the lowest priority and are preemptible.
• Kernel System Service Routines run in kernel mode and can be preempted by higher priority tasks like interrupts.
• Bottom Half Interrupt Handlers execute after the top half and have higher priority than kernel threads.
• Top Half Interrupt Handlers handle immediate hardware responses and have the highest priority.

Solution

A:

For every integer $n$, choose $m=n^2+1$

Then $n^2<m$ → True

B:

$\exists m$ such that $n<m^2$ for all integers $n$.

But integers are unbounded → False

C:

$n^2+m^2=5$

Example: $1^2+2^2=5$ → True

D:

$n^2+m^2=6$

No integer solution → False

E:

$n+m=4$

$n-m=1$

Add equations:

$2n=5$ → $n=2.5$ (not integer) → False

True statements: A and C

Solution

Complexity increases as follows:

Rule-based system → simplest

Shallow neural network → moderate complexity

CNN image classification → more complex

Autonomous driving → highly complex system

Thus increasing order:

A → B → C → D

Solution

Complement → used in negative number representation → III

Ex-OR → used in arithmetic and logic operations → IV

Accumulator → used with adder → I

Control Unit → instruction decoding → II

Correct Matching:

A → III

B → IV

C → I

D → II

Solution

IPv4 header order (relevant fields):

Type of Service → Identification → Flags → Protocol → Options

Thus order:

E → D → A → C → B

Solution

RAID-2 → error correcting codes (Hamming) → II

RAID-3 → bit interleaved parity → IV

RAID-4 → block interleaved parity → I

RAID-6 → Reed–Solomon codes → III

Correct Matching:

A → II

B → IV

C → I

D → III

Solution

Cyclomatic complexity formula:

$V(G) = E - N + 2P$

Where

$E$ = number of edges

$N$ = number of nodes

$P$ = number of connected components (here $P=1$)

From the graph:

Nodes = 10

Edges = 12

So,

$V(G) = 12 - 10 + 2(1)$

$V(G) = 4$

Solution

Goals of reverse engineering:

• Recover lost design information

• Understand system structure

• Detect side effects

• Manage system complexity

Data flow itself is not a goal, but rather a representation or analysis technique.

Solution

Properties of complete/full binary tree:

• If internal nodes = $n$ → leaves = $n+1$ ✔

• If leaves = $l$ → internal nodes = $l-1$ ✔

• Total vertices = $2n-1$ when leaves = $n$ ✔

• Such trees always have odd number of vertices ✔

Thus all statements are correct.

Solution

Thread spawn → thread gets its own register context → IV

Block thread → CPU switches to another ready thread → III

Jacketing → convert blocking system call to nonblocking → I

Flush → reclaim pages → II

Matching:

A → IV

B → III

C → I

D → II

Solution

$2^{50} \times 2^{-38} = 2^{12}$ seconds

$2^{12} = 4096$ seconds

Convert to minutes:

$4096/60 \approx 68.27$ minutes

$\approx 1.14$ hours

Solution

Letters: 26 (A to Z)

Two digit positive integers:

01 to 99 → 99 numbers

Total combinations:

$26 \times 99 = 2574$

Solution

Typical modeling steps:

Formulate model mathematically → B

Solve mathematically → C

Fit solution with data → A

If poor fit, reformulate → D

Interpret results → E

Correct sequence:

B → C → A → D → E

Solution

This grammar produces the dangling-else problem.

In such cases the else can be associated with more than one if, producing more than one parse tree.

Thus the grammar is ambiguous.

Solution

Batch Multiprogramming → maximize CPU utilization → III

Time sharing → minimize response time → IV

Monitor → user does not directly control processor → II

Reentrant procedures → efficient use of memory → I

Matching:

A → III

B → IV

C → II

D → I

Solution

In uniform crossover, a mask (binary mask) determines which parent contributes each gene.

Thus mask-based crossover = uniform crossover.

Solution

Defect Removal Efficiency (DRE):

$\text{DRE} = \frac{\text{Errors found before delivery}}{\text{Errors before + after delivery}}$

Thus the metric described is Defect Removal Efficiency.

Solution

Typical construction steps:

Problem statement → D

Convert to regular expression → B

Convert to NFA-ε → C

Convert to DFA → E

Minimize DFA → A

Order:

D → B → C → E → A

Solution

p is a pointer variable and must store the address of x, written as:

p = &x;

But the program assigns:

p = x;

which means an integer is assigned to a pointer, causing a compilation error (type mismatch).

Solution

In fuzzy set theory, cardinality is the sum of membership values:

$|A| = \sum \mu_A(x)$

The result depends on membership values and may vary.

Solution

Properties of segmentation:

• Segments can be loaded independently → True

• No internal fragmentation → True

• Large virtual address space → True

Segmentation does not reduce multiprogramming; it usually supports better memory utilization.

Thus incorrect statement:

Solution

In genetic algorithms, Actual Count refers to the expected number of copies of a chromosome in the next generation, used in selection (fitness proportionate selection).

Solution

Software Quality Assurance (SQA):

• Focuses on process improvement

• Works as a preventive technique

• Usually involves reviews, audits and standards

• Does not require execution of code

Thus:

B → True

C → True

A → False

D → False (corrective is more related to debugging/testing)

Solution

The right parts of the parents are exchanged:

Parent₁: 10110 | 010

Parent₂: 10101 | 111

After crossover:

Child₁: 10110 | 111

Child₂: 10101 | 010

This is exactly what is shown in figure (2).

Thus it represents one-point crossover.

Solution

$a*b=a+b+2$

Associativity

$(a*b)*c=(a+b+2)+c+2=a+b+c+4$

$a*(b*c)=a+(b+c+2)+2=a+b+c+4$

Identity element:

$a*e=a$

$a+e+2=a$

$e=-2$

Inverse:

$a*b=-2$

$a+b+2=-2$

$b=-a-4$

Solution

Characteristic equation

$r^2-8r+16=0$

$(r-4)^2=0$

$r=4$

General solution

$a_n=(c_1+c_2n)4^n$

Thus valid sequences:

$4^n$

$n4^n$

Solution

Python → OOP

Smalltalk → pure OOP

Perl → supports OOP

SQL Plus → database query interface.

Solution

Predicate logic → symbolic syntactic structure

Slot-and-filler → symbolic frame representation

Conceptual dependency → semantic

Nonmonotonic systems → reasoning method

Solution

$A\rightarrow aB|a$ → Regular grammar → Finite Automata → IV

$A\rightarrow BC|a$ → Chomsky Normal Form → III

$LL(1)$ grammar → Recursive Descent Parser → I

Halting problem → Turing Machine → II

Matching:

$A\rightarrow IV$

$B\rightarrow III$

$C\rightarrow I$

$D\rightarrow II$

Solution

Line drawing algorithms used in computer graphics are:

DDA algorithm

Bresenham algorithm

Mid-point algorithm is generally used for circle drawing.

Solution

Software development process:

Communication → Planning → Modeling → Construction → Deployment

Order:

$D \rightarrow A \rightarrow C \rightarrow B \rightarrow E$

Solution

Embedded OS features:

• real-time scheduling

• interrupt handling

• memory partitioning

File system features like non-sequential files are typical for general purpose OS.

Solution

Linux 4-level paging:

register → page directory → page middle directory → page table → offset

Order:

$A \rightarrow C \rightarrow E \rightarrow D \rightarrow B$

Solution

Let

$f(2^k) = g(k)$

Then recurrence becomes

$g(k) = 5g(k-1) + 3$

with

$g(0) = f(1) = 7$

Solve recurrence.

Homogeneous solution:

$g_h(k) = C5^k$

Particular solution:

Assume constant $A$

$A = 5A + 3$

$-4A = 3$

$A = -\frac{3}{4}$

General solution:

$g(k) = C5^k - \frac{3}{4}$

Use initial condition

$g(0) = 7$

$C - \frac{3}{4} = 7$

$C = \frac{31}{4}$

Thus

$f(2^k) = \frac{31}{4}5^k - \frac{3}{4}$

Solution

We need the number of distinct customers who placed orders, so we count unique customer_id from orders table.

Correct query:

Select COUNT(DISTINCT customer_id) As total_customers From orders;

Solution

Orders table usually contains:

customer_id → referencing Customers table

Thus it contains a foreign key.

Solution

From passage:

• customers can place multiple orders

• orders can contain multiple products

• representatives manage customer accounts

Thus correct statement:

Each sales representative can manage multiple customer accounts.

Solution

From passage:

• customers can place multiple orders

• orders can contain multiple products

• representatives manage customer accounts

Thus correct statement:

Each sales representative can manage multiple customer accounts.

Solution

One customer can place multiple orders.

Thus relationship:

Customer → Orders

$1 : N$

Solution

Solution

Using Master Theorem / recurrence expansion:

(A)
$T(n) = T(n/2) + 1$
Complexity → $O(\log n)$

(E)
$T(n) = T(n-1) + 1$
Complexity → $O(n)$

(D)
$T(n) = 2T(n/2) + \sqrt{n}$

$n^{\log_2 2} = n$

Since $\sqrt{n} < n$

→ $O(n)$

(B)
$T(n) = 2T(n/2) + n$

$n^{\log_2 2} = n$

→ $O(n \log n)$

(C)
$T(n) = 3T(n/3) + n$

$n^{\log_3 3} = n$

→ $O(n \log n)$

Increasing order

$O(\log n) < O(n) < O(n) < O(n\log n) < O(n\log n)$

Solution

A. Representation of bits → Physical layer

B. Physical Address → Data Link Layer

(MAC address)

C. Logical Address → Network Layer

(IP address)

D. Segmentation and reassembly → Transport Layer

Thus:

A → II

B → IV

C → III

D → I

Solution

Access time order (slowest → fastest):

Magnetic Tape → Optical Disk → Magnetic Disk → Main Memory → Registers

Thus ascending order:

C → E → B → D → A

Solution

Unit Testing → Testing individual components

Integration Testing → Testing interaction between modules

System Testing → Testing the complete system

Acceptance Testing → Verifying business/user requirements

Thus mapping:

A → I

B → II

C → IV

D → III

Solution

Chomsky hierarchy order:

Regular Languages

< Context-Free Languages

< Context-Sensitive Languages

< Recursively Enumerable (Unrestricted) Languages

Thus order:

C → A → B → D

Solution

Chomsky hierarchy order:

Regular Languages

< Context-Free Languages

< Context-Sensitive Languages

< Recursively Enumerable (Unrestricted) Languages

Thus order:

C → A → B → D

Solution

Dijkstra Algorithm → shortest path with non-negative weights

Floyd-Warshall → all pairs shortest paths

Bellman-Ford → handles negative edge weights

Prim → Minimum Spanning Tree

Thus correct matching:

A → II
B → I

Remaining pair becomes

C → IV
D → III

Solution

DMA transfer sequence:

Device initiates DMA request

CPU grants bus control to DMA controller

DMA transfers data between memory and device

DMA signals completion

Order:

A → C → B → D

Solution

Dirac’s theorem states that if a simple graph with $n \ge 3$ vertices satisfies

$deg(v) \ge \frac{n}{2}$

for every vertex $v$, then the graph is Hamiltonian.

Thus the degree of each vertex must be at least half of the number of vertices.

Solution

Typical DNS resolution process:

Client queries Local DNS Server

Local DNS server checks cache

If not found → Root DNS server queried

Root server refers to TLD DNS server

TLD server refers to Authoritative DNS server

Thus the correct order is

(B) → (C) → (D) → (E) → (A)

Solution

Given FDs

$CH \rightarrow C$

$A \rightarrow BC$

$B \rightarrow CEH$

$E \rightarrow A$

$A \rightarrow EFG$

From

$A \rightarrow BC$

$A \rightarrow EFG$

we get

$A \rightarrow BCFG E$

Then

$B \rightarrow CEH$

Thus

$A^+ = {A,B,C,D,E,F,G,H}$

So $A$ is a candidate key.

Now check dependency

$E \rightarrow A$

Since $E$ is not a superkey, but RHS contains a prime attribute, it satisfies 3NF but violates BCNF.

Therefore the relation is

in 3NF but not in BCNF.

Solution

Solution

Solution

Solution

Solution

Solution

Solution

Solution

Solution

Solution

Solution

Solution

Solution

Solution

Solution

Subnet mask A

$255.255.128.0$

Network range:

$203.197.0.0$ → $203.197.127.255$

B address $203.197.5.201$ lies in this range
So A thinks B is in same network

Subnet mask B

$255.255.192.0$

Network blocks:

$203.197.0.0$ → $203.197.63.255$

A address $203.197.2.53$ lies in this range
So B also thinks A is same network

Thus both assume same network.

Solution

IP class ranges

Class A → $1-126$
Class B → $128-191$
Class C → $192-223$
Class D → $224-239$
Class E → $240-255$

Check first octet:

A: $10$ → Class A → (III)
B: $210$ → Class C → (IV)
C: $180$ → Class B → (II)
D: $252$ → Class E → (I)

Thus

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

Solution

Solution

SQL (Structured Query Language) is used to:

• create tables

• insert data

• update data

• delete data

• query data

Thus its primary purpose is managing and manipulating relational databases.

Solution

Productivity relation:

$Productivity = \dfrac{Effort}{Size}$

Given:

$Effort = 2000$ person-month
$Productivity = 5$ person-month per KLOC

So

$Size = \dfrac{Effort}{Productivity}$

$Size = \dfrac{2000}{5}$

$Size = 400$ KLOC

Solution

Goal: Find a set of attributes whose closure covers all attributes of R = {A, B, C, D, E}.

Check (1) CD⁺:
From C → F we get F. D gives nothing further. So CD⁺ = {C, D, F}.
Missing A, B, E ⇒ not a key.

Check (2) EC⁺:
Start {E, C}. Using E → A ⇒ add A. Using A → B ⇒ add B. Using EC → D ⇒ add D.
Therefore EC⁺ = {E, C, A, B, D} = {A, B, C, D, E}. Covers all attributes of R ⇒ key.

Check (3) AE⁺:
A → B gives B; E → A adds nothing new. No way to reach C or D ⇒ not a key.

Check (4) AC⁺:
A → B gives B; C → F gives F. No E or D ⇒ not a key.

Answer: (2) EC

Note: F is outside R, so while C → F is valid, a key must cover only attributes of R. EC⁺ covers {A, B, C, D, E}.

Solution

efinitions:

Cohesion → elements of a module belong together → (III)

Coupling → dependency between modules → (I)

Abstraction → simplify complexity → (IV)

Modularity → divide system into modules → (II)

Thus:

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

Solution

Answer: 4) B and C only

• Binary Search Tree (BST): Not necessarily balanced; height can degrade to O(n).
• AVL Tree: Height-balanced by definition (balance factor −1, 0, +1); height is O(log n).
• Red-Black Tree: Enforces black-height properties that keep height O(log n); treated as a height-balanced binary tree.
• B-Tree: Balanced (all leaves at the same level) but not a binary tree; the term “height-balanced tree” typically refers to binary trees. Hence excluded here.

Solution

To check conflict serializability we build precedence graph.

For $S_1$

Conflicts:

$T_1 \rightarrow T_3$
$T_3 \rightarrow T_2$
$T_2 \rightarrow T_1$

Cycle exists:

$T_1 \rightarrow T_3 \rightarrow T_2 \rightarrow T_1$

Therefore

$S_1$ not conflict-serializable

For $S_2$

Conflicts:

$T_3 \rightarrow T_1$
$T_2 \rightarrow T_1$
$T_3 \rightarrow T_2$

Graph has no cycle

Serializable order:

$T_3 \rightarrow T_2 \rightarrow T_1$

Thus

$S_2$ is conflict-serializable

Solution

Translate each statement:
(a) “If intelligent then unhappy” ⇒ P → ¬Q.
(b) “Neither intelligent nor happy” ⇒ ¬P ∧ ¬Q.
(c) “Being not intelligent is necessary for being happy” ⇒ Q → ¬P.
(d) “Not intelligent implies unhappy” ⇒ ¬P → ¬Q.

Only Option 3 matches all four translations.

Answer: 3

Solution

(A) True

PC stores address of next instruction

(B) False

Instruction Register stores current instruction, not address

(C) True

Accumulator stores ALU result

(D) False

PC tracks every next instruction, not only first

Thus correct statements:

(A) and (C)

Solution

Solution

Agile models include iterative and flexible development approaches.

Check each:

(A) Extreme Programming (XP) → Agile methodology ✔

(B) Waterfall → Traditional sequential model ✘

(C) Scrum → Agile framework ✔

(D) Spiral → Risk-driven traditional model ✘

(E) Incremental → Development strategy but not strictly Agile model here

Thus Agile models are:

Extreme Programming and Scrum

Solution

Answer: (4) C, B, D, A

Explanation:
The standard steps for designing a dynamic programming algorithm are:

1. (C) Characterize the structure of an optimal solution.
2. (B) Recursively define the value of an optimal solution.
3. (D) Compute the value of an optimal solution (usually bottom-up).
4. (A) Construct the optimal solution from the computed information.

Hence, the correct order is C → B → D → A.

Solution

Standard database design process:

Requirement Analysis

Conceptual Design

Logical Design

Physical Design

Thus order:

(D) → (B) → (C) → (A)

Solution

Solution

(A) True

Mutual exclusion ensures only one process enters critical section at a time.

(B) True

It prevents conflicts on shared resources.

(C) True

Algorithms like Peterson, Dekker, semaphore, mutex ensure mutual exclusion.

(D) False

Critical section cannot be accessed simultaneously by multiple processes.

Thus correct statements:

(A), (B), (C)

Solution

Functional dependencies:

$U \rightarrow V$

$VW \rightarrow X$

$Y \rightarrow W$

$X \rightarrow U$

Start with $UY$:

$U \rightarrow V$

$Y \rightarrow W$

Thus we get $V,W$

Then

$VW \rightarrow X$

Then

$X \rightarrow U$

So closure:

$UY^+ = {U,V,W,X,Y}$

Add $Z$ to cover all attributes.

Thus minimal key:

$UYZ$

Similarly:

$VYZ$ and $XYZ$

Thus candidate keys:

$UYZ,; VYZ,; XYZ$

Solution

Solution

(A) TTL → Decreases at every router ✔

(B) Header checksum → Recomputed whenever TTL changes ✔

(C) Fragment offset → May change if fragmentation occurs ✔

(D) Source IP → Does not change ✘

(E) Destination IP → Does not change ✘

Thus fields that may differ:

TTL, Checksum, Fragment offset

Solution

• A. Address Space → Virtual Address (IV)
  Address space refers to the range of virtual addresses a process can use in memory.
• B. Memory Space → Physical Address (III)
  Memory space corresponds to the actual physical memory locations in RAM.
• C. Cache Memory → Associative Mapping (I)
  Cache memory uses mapping techniques such as associative mapping to store data efficiently.
• D. Segmented Program → Logical Address (II)
  In segmentation, programs are divided into segments, each referenced by logical addresses.

Solution

Minimum frame size:

$1250 \text{ bytes} = 1250 \times 8 = 10000 \text{ bits}$

Transmission rate:

$100 \text{ Mbps} = 100 \times 10^6 \text{ bits/sec}$

Transmission time:

$T = \frac{10000}{100 \times 10^6}$

$T = 10^{-4} \text{ sec}$

In CSMA/CD:

$T = 2 \times$ propagation delay

So propagation delay:

$\frac{T}{2} = 5 \times 10^{-5}$ sec

Distance = 1 km

Signal speed:

$v = \frac{distance}{time}$

$v = \frac{1}{5 \times 10^{-5}}$

$v = 20000 \text{ km/sec}$

Solution

Using perceptron learning rule: Δw = η (t − y) x, where y = 1 if y_in > 0 else 0.

S1 (0,0,t=0): y_in=0 ⇒ y=0 ⇒ no change ⇒ (w1,w2)=(0,0)

S2 (0,1,t=1): y_in=0 ⇒ y=0 ⇒ Δw=0.1(1−0)(0,1) ⇒ (w1,w2)=(0,0.1)

S3 (1,0,t=1): y_in=0 ⇒ y=0 ⇒ Δw=0.1(1−0)(1,0) ⇒ (w1,w2)=(0.1,0.1)

S4 (1,1,t=1): y_in=0.1+0.1=0.2>0 ⇒ y=1 ⇒ no change

Final Weights: w1=0.1, w2=0.1

Answer: (1)

Solution

Initial values

$a = 5,; b = 10$

First call

swap(a,b)

$a = 10,; b = 5$

Second call

swap(a,b)

$a = 5,; b = 10$

Thus final output

5 10

Solution

TCP 3-way handshake:

Step 1

A → B

SYN = 1

SEQ = S

Step 2

B → A

SYN = 1

ACK = 1

SEQ = R

ACK = S + 1

Thus correct header fields:

SYN = 1

SEQ = R

ACK = 1

ACK = S + 1

Solution

Correct file handling sequence in C:

Open file

Check for error

Read / Write

Close file

Thus order:

(C) → (D) → (B) → (A)

Solution

Quick Sort → Not stable ✘

Bubble Sort → Stable ✔

Insertion Sort → Stable ✔

Merge Sort → Stable ✔

Shell Sort → Not stable ✘

Thus stable algorithms:

Bubble Sort, Insertion Sort, Merge Sort

But among given options, only

(B) and (C)

appear together correctly.

Solution

Paging → Logical to physical address mapping → (III)

LRU → Replace least recently used page → (I)

C-SCAN → Circular disk scheduling → (IV)

Virtual Memory → Extends physical memory → (II)

Thus:

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

Solution

(A) True

PCB stores process state (running, ready, waiting).

(B) False

Program code and data are stored in process memory, not in PCB.

(C) True

PCB stores memory management information (page tables, segment tables).

(D) True

PCB contains CPU registers and scheduling information.

Thus correct statements:

(A), (C), (D)

Solution

Standard FDD lifecycle steps:

1. Develop overall model

2. Build feature list

3. Plan by feature

4. Design by feature

5. Build by feature

Thus order:

(A) → (E) → (C) → (D) → (B)

Solution

(A) $T(n)=2T(n/2)+n$

Master theorem

$a=2,; b=2,; f(n)=n$

$\Rightarrow T(n)=\theta(n\log n)$

So (A) → (I)

(B) $T(n)=T(n/2)+1$

Divide size halves each step

$\Rightarrow T(n)=O(\log n)$

So (B) → (IV)

(C) $T(n)=2T(n/2)+1$

Master theorem

$\Rightarrow T(n)=\theta(n)$

So (C) → (III)

(D) $T(n)=T(n-1)+1$

Linear recurrence

$\Rightarrow T(n)=O(n)$

Closest option given:

(D) → (II)

Thus matching: