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

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

Effective address:

$EA = ADR + XR$

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

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

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

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

Stock available:

Red wool = $8$

Green wool = $10$

Blue wool = $15$

Dual objective function uses resource quantities.

Thus

$Min\ P = 8u + 10v + 15w$

Solution

Let

$x$ = unit of cloth A

$y$ = unit of cloth B

Income:

$Max\ Z = 30x + 50y$

Constraints

$2x + 3y \le 8$

$3x + 2y \le 10$

$2y \le 15$

Corner point:

$x = 0.8,\ y = 2$

$Z = 30(0.8) + 50(2)$

$Z = 24 + 100$

$Z = 124$

Solution

Red wool constraint

$2x + 3y \le 8$

Green wool constraint

$3x + 2y \le 10$

Blue wool constraint

$2y \le 15$

or

$y \le 7.5$

Solution

At optimal point

$2x + 3y = 8$

$3x + 2y = 10$

Solve

$x = 0.8$

Solution

Income per unit cloth

A = ₹30

B = ₹50

Thus objective function

$Max\ Z = 30x + 50y$

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

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

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

(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

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

Standard database design process:

Requirement Analysis

Conceptual Design

Logical Design

Physical Design

Thus order:

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

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

(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

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

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:

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

Solution

Function pointer syntax:

return_type (*pointer_name)(arguments);

Example:

int (*func)(int,int);

Meaning:

func is a pointer

pointing to a function

returning int

taking two int parameters

Thus correct declaration:

int (*func)(int,int);

Solution

Relational databases (MySQL, PostgreSQL, Oracle etc.) store data in relations (tables).

Each table consists of:

Rows → tuples / records

Columns → attributes / fields

Thus relational model structure:

tables with rows and columns

Solution

Syntax trees (Abstract Syntax Tree – AST) are used in later compiler phases.

(A) Type Checking → Done using syntax tree ✔

(B) Code Generation → Uses syntax tree ✔

(C) Code Optimization → Uses syntax tree representation ✔

(D) Error Handling → Mainly done during lexical / syntax analysis ✘

Thus correct tasks:

(A), (B), (C)

Solution

Total effort

$1500$ person-hours

Work per day by team:

$5 \times 8 = 40$ hours/day

Days required

$= \frac{1500}{40}$

$= 37.5$

Solution

Recursive calls divide $y$ by $3$ each time.

Call sequence:

$fun(4,81)$
$fun(4,27)$
$fun(4,9)$
$fun(4,3)$

Total calls = 4

Each call increments temp.

So

$temp = 4$

Solution

Given:

$P$ : It is hot day

$q$ : Temperature is $48^\circ C$

Expression:

$\neg P \land \neg q$

Meaning:

$\neg P$ → It is not a hot day

$\neg q$ → Temperature is not $48^\circ C$

Combined with AND:

Neither $P$ nor $q$

Thus sentence:

"It is neither a hot day nor temperature is $48^\circ C$"

Solution

Statement:

“Joy is loved by everyone”

Meaning:

Every person $x$ loves Joy.

Mathematically:

$\forall x; L(x,;Joy)$

Solution

For a relation on ${1,2,3,4}$ to be reflexive, it must contain

$(1,1),(2,2),(3,3),(4,4)$

Check each:

$R_1$ → missing $(3,3)$ ✘

$R_2$ → missing $(3,3),(4,4)$ ✘

$R_3$ → contains $(1,1),(2,2),(3,3),(4,4)$ ✔

$R_4$ → missing all diagonal pairs ✘

$R_5$ → contains all $(1,1),(2,2),(3,3),(4,4)$ ✔

Thus reflexive relations:

$R_3$ and $R_5$