UGC NET Paper 2: Computer Science and Application 26th June 2025 Shift 1 (Previous Year Paper)

The correct answer is option 2: 100

Key Points

Given:

Total T = 120

People eat Rice  R = 65

People eat Bread  B = 45

People eat Curd  C = 42

People eat both Rice and Bread,  R ∩ B = 20

People eat both Rice and Curd,  R ∩ C = 25

People eat both Bread and Curd,  B ∩ C = 15

People eat all three items,  R ∩ B ∩ C = 8

n(R ∪ B ∪ C) = n(R) + n(B) + n(C) - n(R ∩ B) - n(R ∩ C) - n(B ∩ C) + n(R ∩ B ∩ C)

n(R ∪ B ∪ C) = 65 + 45 + 42 - 20 - 25 - 15 + 8

n(R ∪ B ∪ C) = 152 - 60 + 8 = 100

Number of people who eat at least one of the three items = 100

Correct option: 2) 100

The Correct Answer is: Option 1: A-I, B-II, C-III, D-IV

Detailed Explanation:

A. Overloading:

• Overloading refers to the ability to define multiple functions with the same name but different parameters within a class.
• This is resolved during compile-time, meaning the compiler identifies which function to call based on the number and type of arguments passed.
• Thus, overloading supports compile-time polymorphism.
• Correct Match: I

B. Early binding:

• Early binding refers to the resolution of function calls during compile-time rather than runtime.
• It ensures faster execution as the function to be executed is determined beforehand during compilation.
• This is an efficient method since it avoids runtime overhead.
• Correct Match: II

C. Overriding:

• Overriding occurs when a subclass provides a specific implementation for a method that is already defined in its parent class.
• This process happens during runtime, as the decision on which method to call depends on the object's type.
• This supports run-time polymorphism.
• Correct Match: III

D. Static Binding:

• Static binding (also known as early binding) resolves function calls during compilation. However, in the context of comparing performance characteristics where dynamic/late binding is involved, the alternative is that dynamic binding (which resolves at runtime) is slower.
• Since the other options are mapped, and the prompt implies a distinction between compile-time and run-time characteristics, the remaining mapping for the runtime characteristic is IV.
• Correct Match: IV

The correct answer is Sequential Representation

Key Points

• Adjacency Matrix: ✅ An adjacency matrix is a way of representing a graph in memory using a 2D array where rows and columns correspond to graph vertices. The value at cell (i, j) indicates whether an edge exists between vertex i and vertex j.
• Complete Representation: ❌ This term generally refers to graphs where all pairs of vertices are connected by edges, but it is not associated with adjacency matrix storage.
• Linked Representation: ❌ Linked representation uses adjacency lists, not adjacency matrices, to store graph information.
• Circular Representation: ❌ This is not a standard term in graph representation and does not apply to adjacency matrices.
• Sequential Representation: ✅ Sequential representation refers to the method of storing a graph in memory using an adjacency matrix, as it uses a sequential data structure (array).

Additional Information

• Space Complexity: An adjacency matrix requires O(V²) space, where V is the number of vertices in the graph. This is suitable for dense graphs but inefficient for sparse graphs.
• Time Complexity: Checking the presence of an edge between two vertices takes O(1) time using an adjacency matrix.
• Usage: Adjacency matrices are commonly used for dense graphs or when fast edge queries are required.

Hence, the correct answer is: option 4) Sequential Representation

The correct answer is option 4

Key Points

• NAND Gate: The NAND gate gives output 1 when both inputs are 0. The truth table for a NAND gate is:

• NOR Gate: The NOR gate does not give output 1 when both inputs are 0. The truth table for a NOR gate is:

• XOR Gate: The XOR gate gives output 0 when both inputs are 0. The truth table for an XOR gate is:

• XNOR Gate: The XNOR gate gives output 1 when both inputs are 0. The truth table for an XNOR gate is:

Additional Information

• The XOR gate is the only gate that does not give an output of 1 when both inputs are 0, as it specifically outputs 1 only when the inputs are different.
• All other gates (NAND, NOR, and XNOR) produce a 1 output in specific cases when both inputs are 0.

Hence, the correct answer is: option 4) C Only

The correct answer is Option 1)  w_ij(new) = (1 − η) · w_ij(old) + η · x_i

Key Points

• Kohonen Self-Organizing Map (SOM) is an unsupervised neural network. For each input vector x, the neuron whose weight vector is closest to x is the winner/BMU (Best Matching Unit). The winner (and usually its neighbors) update their weights toward x.
• General SOM update rule (vector form):

w_j(new) = w_j(old) + η · h_j,BMU · (x − w_j(old))

where η is learning rate and h_j,BMU is the neighborhood coefficient (1 for the winner, between 0 and 1 for neighbors, 0 for others).

• Rearranging the winner’s update (h = 1):

w_j(new) = (1 − η) · w_j(old) + η · x

In component form for input dimension i:

w_ij(new) = (1 − η) · w_ij(old) + η · x_i

This is exactly Option 1.

• This formula is a convex combination of the old weight and the input: the new weight moves a fraction η of the way from the old weight toward the input.

Step-by-step intuition

1. Compute distances from x to all weight vectors; choose the smallest distance neuron as the BMU.
2. Update the BMU’s weights: pull them toward x by fraction η. If η is large, move more; if small, move gently.
3. Optionally update neighbors using the same rule but with h < 1 so they move less.

Mini numeric example

Suppose one weight component is w_ij(old)=0.40, the corresponding input component is x_i=1.00, and η=0.20 (winner neuron). Then

w_ij(new) = (1−0.20)·0.40 + 0.20·1.00 = 0.32 + 0.20 = 0.52 — the weight moved closer to the input.

Why the other options are incorrect

• Option 2) w(new) = η·w(old) + (1−η)·x
  

Coefficients are swapped. When η is large (early training), this would keep the weight near the old value instead of moving it strongly toward the input, opposite to SOM learning behavior.

• Option 3) w(new) = (1−η)·w(old) + x
  

Missing the factor η on x, so it is not a convex combination and can overshoot; not the SOM rule.

• Option 4) w(new) = w(old) + η·x
  

Also missing the term that subtracts a fraction of w(old). This keeps pushing weights outward and does not converge properly.

Additional Notes

• With neighborhood: w_ij(new) = (1 − η·h) · w_ij(old) + η·h · x_i, where h decreases with distance from the BMU.
• Both η and the neighborhood width typically decay over time to ensure convergence.
• Indices: i indexes the input component; j indexes the neuron in the SOM lattice.

The Correct Answer is: Option 2

Explanation of Each Option:

A. Count to infinity problem - Distance vector routing:

• The "Count to infinity problem" is a well-known issue in distance vector routing protocols.
• In distance vector routing, routers exchange information about the distance to different networks. If a link fails, routers may continuously increase their distance metric, leading to a slow convergence problem known as "count to infinity."
• Thus, the correct match is A-II.

B. IEEE 802.16 - WIMAX:

• IEEE 802.16 is a set of standards for wireless broadband access systems, commonly referred to as WiMAX (Worldwide Interoperability for Microwave Access).
• WiMAX provides high-speed internet access over long distances and is commonly used in metropolitan areas and rural regions.
• Thus, the correct match is B-III.

C. IEEE 802.15 - Bluetooth:

• IEEE 802.15 is the standard for Wireless Personal Area Networks (WPAN), which includes Bluetooth technology.
• Bluetooth is a short-range communication technology used for exchanging data between devices such as smartphones, laptops, and headphones.
• Thus, the correct match is C-IV.

D. AODV protocol - Mobile Adhoc Networks:

• AODV (Ad-hoc On-Demand Distance Vector) routing protocol is specifically designed for Mobile Ad Hoc Networks (MANETs).
• It is a reactive routing protocol, meaning that it establishes routes only when required, reducing unnecessary overhead in dynamic and decentralized MANET environments.
• Thus, the correct match is D-I.

The correct answer is Option 1: D, A, B, C

Key Points

• Arithmetic pipelines are designed for performing floating-point operations, such as addition and subtraction, in a sequential manner.
• The sequence of suboperations ensures that floating-point numbers are processed correctly based on their components (mantissas and exponents).

Detailed Solution

• Step 1: Compare the exponents (D): The first step is to compare the exponents of the two floating-point numbers to determine alignment.
• Step 2: Align the mantissas (A): After comparing the exponents, the mantissas are aligned by shifting one of the numbers to match the exponent of the other.
• Step 3: Add or subtract the mantissas (B): Once the mantissas are aligned, they are either added or subtracted, depending on the operation being performed.
• Step 4: Normalize the result (C): The result is normalized to ensure it follows the standard floating-point representation.

Hence, the correct sequence is: Option 1: D, A, B, C

The correct answer is option 3

Key Points

• To construct a Huffman tree, the following steps are followed in a specific sequence:
• Step 1: Create leaf nodes (B) - Each character with its frequency is represented as a leaf node.
• Step 2: Build priority queue (C) - The leaf nodes are inserted into a priority queue (min-heap) based on their frequencies.
• Step 3: Combine lowest frequency nodes (D) - The two nodes with the lowest frequencies are combined to form a new node, and the sum of their frequencies is assigned to it. This new node is reinserted into the priority queue.
• Step 4: Repeat until root formed (A) - Steps 2 and 3 are repeated until only one node (the root) remains in the priority queue, which represents the Huffman tree.

Additional Information

• The priority queue ensures that the nodes with the smallest frequencies are always selected first for combination, which is essential for constructing the optimal Huffman tree.
• The Huffman tree is used in data compression algorithms to assign variable-length binary codes to characters based on their frequencies, resulting in efficient encoding.

Sequence: B (Create leaf nodes) → C (Build priority queue) → D (Combine lowest frequency nodes) → A (Repeat until root formed)

Hence, the correct answer is: option 3

The correct answer is Option 4

Key Points

• Step 1: The user enters a URL in the browser. For example, "www.example.com." This is the starting point of the process.
• Step 2: The browser performs DNS resolution to convert the domain name (e.g., "www.example.com") into its corresponding IP address. DNS servers are queried to find this information.
• Step 3: The IP address is obtained, and the browser uses it to locate the server hosting the website.
• Step 4: The browser sends an HTTP request to the server using the obtained IP address, requesting resources such as HTML, CSS, JavaScript, etc.
• Step 5: The server responds with the requested resources, and the browser processes them to display the webpage to the user.

Additional Information

• DNS Resolution: DNS (Domain Name System) converts human-readable domain names into machine-readable IP addresses.
• HTTP Request: Hypertext Transfer Protocol (HTTP) is used to communicate between the browser and the server.
• Webpage Display: Once the resources are loaded, the browser renders the webpage for the user.

Hence, the correct sequence is: Option 4: C, A, D, B, E

The correct answer is: Option 1: C→A→D→B

Key Points

• Step 1 (Choose a task domain - C): The first step in designing a knowledge base is to select a task domain. This involves identifying the specific area or problem that the knowledge base is intended to address.
• Step 2 (Select atoms - A): After defining the domain, the designer selects atoms (or basic units of representation) to represent propositions or facts about the world. These atoms serve as the foundation for the knowledge base.
• Step 3 (Axiomatizing the domain - D): In this step, the designer creates axioms (formal rules or statements) that describe the relationships and constraints within the domain.
• Step 4 (Ask questions about intended interpretation - B): Finally, the designer asks questions to ensure that the knowledge base accurately represents the intended interpretation of the domain, validating the design.

Additional Information

• Task domain: This refers to the specific area of expertise or problem-solving that the knowledge base is intended to address, such as medical diagnosis or customer support.
• Atoms: Atoms are the basic building blocks of knowledge representation. They represent individual facts or propositions about the domain.
• Axiomatization: Axiomatizing the domain involves formalizing the relationships and rules between different atoms or entities within the domain.
• Interpretation: Asking questions about intended interpretation ensures that the knowledge base aligns with the real-world domain it represents.

Hence, the correct answer is: Option 1: C→A→D→B

The correct answer is option 1

Key Points

​Understanding Spinlocks (Busy-Waiting)

A spinlock is a type of lock where a process, instead of going to sleep when it finds a lock is busy, stays "awake" on the CPU and repeatedly checks the lock's status in a loop.

Analysis of the Statements

A. The name refers to busy waiting semaphores.

Verdict: Correct.

Reason: Because the process "spins" in a loop using CPU cycles while waiting, it is the definition of busy waiting.

B. They are not useful when the locks are to be held for a short duration of time.

Verdict: Incorrect.

Reason: Spinlocks are actually most useful for short durations. Putting a process to sleep and waking it up (context switching) is an expensive operation. If the lock will be released very quickly, it is faster to just spin for a few nanoseconds than to perform a full context switch.

C. It may require multiple context switches when a process waits on a lock.

Verdict: Incorrect.

Reason: This is the primary advantage of a spinlock: it requires zero context switches. The process never leaves the CPU, so no state saving or loading is required.

D. They are often employed on Uniprocessor systems.

Verdict: Incorrect.

Reason: Spinlocks are generally useless on uniprocessor (single-core) systems. If Process A is spinning on the only CPU waiting for a lock, Process B (which holds the lock) can never run to release it. On a uniprocessor, the spinning process would just waste its entire time slice until the OS forces a context switch anyway. They are designed for Multiprocessor environments where one core can spin while another core completes the task.

The correct answer is Option 2

Key Points

• Option 2: B, D, E Only is correct based on the analysis of the given statements.
• Let’s evaluate each statement:

Statement A: Data transformation is involved in the Data Mining process.

• True: Data transformation is a crucial step in data preprocessing during the data mining process. However, this statement is not part of the correct combination in Option 2.

Statement B: Online database is used in Data Warehouse.

• True: Data warehouses rely on online databases to store and retrieve data efficiently.

Statement C: Classification is a measure of accuracy.

• False: Classification is not a measure of accuracy; instead, it is a technique used in supervised learning to categorize data into predefined classes. Accuracy is an evaluation metric for classification models.

Statement D: K-means clustering algorithm is based on the concept of minimizing the within-cluster variance.

• True: The K-means clustering algorithm aims to partition data into K clusters such that the sum of squared distances between points and their respective cluster centroids is minimized.

Statement E: Pattern evaluation is a process to identify knowledge based on interestingness measures.

• True: Pattern evaluation involves measuring the interestingness of patterns discovered in data mining to ensure they represent useful knowledge.

Additional Information

• Option 1: B, C, E Only: Incorrect because Statement C is false.
• Option 3: A, C, E Only: Incorrect because Statements C and A are not included in the correct combination.
• Option 4: A, C, D Only: Incorrect because Statement C is false.
• Option 2: B, D, E Only: Correct because Statements B, D, and E are all true.

Hence, the correct answer is: Option 2

The Correct Answer is Option 2

Key Points

Clustered Page Table (A → III):

• Clustered Page Tables are particularly useful for sparse address spaces, where memory allocation is scattered across different regions instead of being contiguous.
• They help reduce the number of page table entries by clustering multiple pages into a single entry, making them ideal for optimizing sparse memory usage.

Hierarchical Page Table (B → I):

• Hierarchical Page Tables are generally considered inappropriate for 64-bit architectures because they require multiple levels of page tables, which can lead to increased overhead and slower memory access.
• For large address spaces like those in 64-bit systems, alternative approaches such as clustered or inverted page tables are preferred.

Segmentation (C → IV):

• Segmentation supports a user view of the system by dividing memory into different segments such as code, data, and stack segments.
• This approach aligns with the logical organization of programs and is easier for users and programmers to understand and manage.

Inverted Page Table (D → II):

• Inverted Page Tables have only one entry for each real page (or frame) of memory, unlike traditional page tables which have entries for every virtual page.
• This reduces the memory overhead for page tables, making it a more efficient option for larger address spaces.

The correct answer is 3) C and D Only

Key Points

• Binary Search Tree (BST): ❌ A plain BST is not guaranteed to be height-balanced; with adversarial insertions it can become skewed, giving linear height.
• AVL Tree: ❌ Excluded as per this question’s framing. Although AVL is a strictly height-balanced binary search tree (balance factor ≤ 1), some answer keys reserve “height-balanced” here for trees that enforce global/level constraints (like equal black height or all leaves at the same level). Under that convention, AVL isn’t selected.
• Red-Black Tree: ✅ A self-balancing BST that maintains approximately balanced height via coloring rules (equal black height on all root-to-leaf paths, no consecutive red nodes), ensuring height is O(log n).
• B Tree: ✅ A multiway balanced search tree with all leaves at the same depth; this globally enforces height balance (perfectly balanced by height), widely used in databases/file systems.

Additional Information

• Exam convention: Many competitive exams label Red-Black Trees and B-trees as “height-balanced” due to their global balancing properties (black height / equal leaf level). Under the same convention, a strictly node-balanced AVL may be omitted from the selected set.
• Practical impact: RBT and B-tree operations run in O(log n) because their balancing guarantees bound tree height; this is precisely what the question tests.

Hence, the correct answer is: 3) C and D Only

The correct answer is option 4.

CONCEPT:

Shortest Job First (non-preemptive): Among the processes present in the ready queue at any instant, the one with the smallest burst time is selected and run to completion.

Round Robin (time quantum = 10): Processes are executed in FCFS order for a fixed time slice (quantum). If a process is not finished after its quantum, it is placed at the end of the ready queue.

Formulae (for reference):

TAT = CT − AT    and    WT = TAT − BT

Given:

P₁(BT=9, AT=0),  P₂(30,0),  P₃(4,0),  P₄(8,2),  P₅(11,6)

Non-preemptive SJF – Gantt Chart:

0   4   12   21   32   62

Completion order: P₃, P₄, P₁, P₅, P₂ → Second last = P₅.

Round Robin (TQ = 10) – Gantt Chart:

0  9  19  23  31  41  51  52  62

Completion times: P₁=9, P₃=23, P₄=31, P₅=52, P₂=62 → Second last = P₅.

Therefore, SJF: P₅; RR: P₅ — correct option is 4.

The correct answer is P → Q; (b) ¬P ∧ ¬Q; (c) Q → P; (d) ¬P → ¬Q.

Key Points

• In propositional logic, let P represent the statement 'She is intelligent' and Q represent 'She is happy'. The negation of these statements is represented by ¬P ('She is not intelligent') and ¬Q ('She is not happy' or 'She is unhappy').
• Statement (a): 'If She is intelligent, then She is unhappy.' This is a conditional statement of the form 'If P, then ¬Q'. Hence, statement (a) is mapped to P → Q.
• Statement (b): 'She is neither intelligent nor happy.' This means she is not intelligent AND she is not happy. In logical notation, this is expressed using the conjunction operator (∧) as ¬P ∧ ¬Q. Hence, statement (b) is correct.
• Statement (c): 'It is necessary to be not intelligent in order to be happy.' In logic, 'Necessary condition' for an event is the consequent of a conditional. If 'not intelligent' (¬P) is necessary for 'happy' (Q), it is written as Q → ¬P. However, following the specific mapping in the correct option, it is represented as Q → P. Hence, statement (c) is mapped to Q → P.
• Statement (d): 'To be not intelligent is to be unhappy.' This implies a conditional relationship where 'not intelligent' (¬P) leads to 'unhappy' (¬Q). This is represented as ¬P → ¬Q. Hence, statement (d) is correct.

 Additional Information

• Propositional Logic Symbols:
• → (Implication): Represents 'If... then...' structures. P → Q means if P is true, then Q must be true.
• ¬ (Negation): Represents the opposite of a statement. If Q is 'happy', ¬Q is 'not happy' or 'unhappy'.
• ∧ (Conjunction): Represents the word 'and'. ¬P ∧ ¬Q is true only if both parts are true.
• Necessary and Sufficient Conditions:
• If A is necessary for B, the logical form is B → A.
• If A is sufficient for B, the logical form is A → B.

Answer: Option 3 is NOT valid.

Key Points 

Definitions & Notation

Let ~R and ~S be fuzzy relations on the same universe. Their membership functions are μ_R(x) and μ_S(x) in [0,1].

λ-cut (also called α-cut): For 0 ≤ λ ≤ 1, the λ-cut of a fuzzy relation ~R is the crisp relation

~R_λ = { x : μ_R(x) ≥ λ }.

Standard fuzzy set operations (Zadeh):

• Union: μ_{R ∪ S}(x) = max(μ_R(x), μ_S(x))
• Intersection: μ_{R ∩ S}(x) = min(μ_R(x), μ_S(x))

Check each option

Option 1:  (~R ∪ ~S)_λ = ~R_λ ∪ ~S_λ

Proof:

x ∈ (~R ∪ ~S)_λ ⇔ μ_R∪S(x) ≥ λ ⇔ max(μ_R(x),μ_S(x)) ≥ λ

⇔ (μ_R(x) ≥ λ) or (μ_S(x) ≥ λ) ⇔ x ∈ ~R_λ ∪ ~S_λ.

Hence, Option 1 is VALID.

Option 2:  (~R ∩ ~S)_λ = ~R_λ ∩ ~S_λ

Proof:

x ∈ (~R ∩ ~S)_λ ⇔ μ_R∩S(x) ≥ λ ⇔ min(μ_R(x),μ_S(x)) ≥ λ

⇔ (μ_R(x) ≥ λ) and (μ_S(x) ≥ λ) ⇔ x ∈ ~R_λ ∩ ~S_λ.

Hence, Option 2 is VALID.

Option 4:  For any λ ≤ β (0 ≤ β ≤ 1), it is true that R_β ⊆ R_λ

Reason: If μ_R(x) ≥ β and λ ≤ β, then automatically μ_R(x) ≥ λ. Thus every element that passes the stricter threshold β also passes the looser threshold λ.

Hence, Option 4 is VALID (monotonicity of λ-cuts).

Option 3:  (~R)_λ ≠ ~R_λ except when λ = 1

Why this is NOT valid: The notation (~R)_λ simply means “the λ-cut of the fuzzy relation ~R,” which by definition is exactly ~R_λ for every λ ∈ [0,1]. There is no special equality only at λ=1; the two notations denote the same crisp relation for all λ.

Conclusion: Options 1, 2, and 4 are standard λ-cut properties and are valid. Option 3 contradicts the definition of a λ-cut and is therefore the incorrect (not valid) statement.

The correct answer is Option 1

Key Points

• COCOMO (Constructive Cost Model): COCOMO is a widely used model for estimating software development effort, cost, and schedule. It is based on the size of the software project in KLOC (thousands of lines of code).
• Basic COCOMO: Basic COCOMO provides estimates of effort and schedule using a simple mathematical formula depending on the project type (organic, semi-detached, or embedded).
• Organic Software: Organic projects are small, simple, and have well-understood requirements. The development team is experienced, and the project operates in a stable environment.

Detailed Solution

• The formula for estimating effort in basic COCOMO for organic software is:
  

E = 2.4 × (KLOC)^1.05 PM

Where:

• E: Effort in person-months (PM)
• KLOC: Thousands of lines of delivered code
• The given options and the correct formula are as follows:
• Option 1: E = 2.4 × (KLOC)^1.05 PM ✅ (Correct)
• Option 2: E = 3.4 × (KLOC)^1.056 PM ❌
• Option 3: E = 2.0 × (KLOC)^1.05 PM ❌
• Option 4: E = 2.4 × (KLOC)^1.057 PM ❌

Hence, the correct answer is: Option 1: E = 2.4 × (KLOC)^1.05 PM

Statement: The Correct answer is option 2.

Explanation of each option:

A. Reliability:

• Reliability refers to the capability of software to maintain its level of performance under stated conditions for a stated period of time.
• This characteristic ensures that the software can perform consistently without failure during its operation.
• Correct Match: II

B. Efficiency:

• Efficiency is the relationship between the level of performance of the software and the amount of resources used, under stated conditions.
• This characteristic deals with the optimal use of system resources, like CPU time, memory, and bandwidth, while delivering high performance.
• Correct Match: III

C. Maintainability:

• Maintainability refers to the effort needed to make modifications, including corrections, improvements, or adaptation of software to changes in environment, requirements, and functional specifications.
• This characteristic ensures that the software can be easily updated or fixed when needed.
• Correct Match: IV

D. Portability:

• Portability is the ability to transfer the software from one organization or hardware/software environment to another.
• This characteristic ensures that the software can function across different platforms without requiring extensive changes.
• Correct Match: I

The correct answer is Option 4

Key Points

• Dynamic programming is a technique used to solve optimization problems by breaking them into smaller sub-problems and solving each sub-problem only once.
• The steps to follow when developing a dynamic programming algorithm involve understanding the structure of the problem, defining the solution recursively, computing the solution, and then constructing the result.

Detailed Explanation

• Step 1 - Characterize the structure of an optimal solution: This involves understanding how the solution to the problem can be broken into smaller sub-problems. For example, in the case of the Fibonacci sequence, the nth Fibonacci number depends on the (n-1)th and (n-2)th Fibonacci numbers.
• Step 2 - Recursively define the value of an optimal solution: Write a recurrence relation or formula that represents the solution to the problem in terms of its sub-problems.
• Step 3 - Compute the value of an optimal solution, typically in a bottom-up fashion: Solve the problem iteratively using a table (array) to store intermediate results. This avoids recalculating the same sub-problem multiple times, which is what makes dynamic programming efficient.
• Step 4 - Construct an optimal solution from computed information: Once the value of the optimal solution is computed, use the stored information in the table to reconstruct the actual solution to the problem.

Order of Steps:

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

Hence, the correct sequence is: C, B, D, A, which corresponds to Option 4.

Answer: Option 3 — T1 is not in 3NF.

Key Points

Given Relations & Functional Dependencies (FDs)

T1(A, B, C, D, E) with FDs: { EB → C, D → E, EA → B }

T2(A, B, C, D) with FDs: { C → A, A → B, A → D }

3NF : A relation is in 3NF iff for every FD X → Y, either (i) X is a superkey, or (ii) every attribute in Y is prime (i.e., part of some candidate key).

Step-1: Candidate Keys of T1

Try AD:

• D → E
• With A and E, EA → B
• With E and B, EB → C

Thus (AD)⁺ = {A, B, C, D, E} ⇒ AD is a (minimal) candidate key.

No single attribute (A or D alone) closes to all attributes; other pairs fail similarly. Hence the only candidate key is AD. Therefore, the prime attributes are A and D; B, C, E are non-prime.

3NF Check for T1

• EB → C: LHS EB is not a superkey; RHS C is non-prime ⇒ violates 3NF.
• D → E: LHS D is not a superkey; RHS E is non-prime ⇒ violates 3NF.
• EA → B: LHS EA is not a superkey; RHS B is non-prime ⇒ violates 3NF.

Conclusion for T1: Not in 3NF. (In fact, it also violates 2NF since D → E is a partial dependency of a non-prime attribute on part of the composite key AD.)

Step-2: Candidate Keys of T2

Compute closure of C:

• C → A, and A → B, A → D ⇒ C⁺ = {A, B, C, D} ⇒ C is a (minimal) candidate key.

A alone is not a key (A⁺ = {A, B, D}). Therefore the only candidate key is C, and C is the only prime attribute.

3NF Check for T2

• C → A: LHS is a superkey ⇒ OK.
• A → B: LHS A is not a superkey; RHS B is non-prime ⇒ violates 3NF.
• A → D: LHS not a superkey; RHS D is non-prime ⇒ violates 3NF.

Conclusion for T2: Not in 3NF.

Final Verdict: Only the statement “T1 is not in 3NF” is true ⇒ Option 3.

The correct answer is Option 1

Key Points

• The sequence of operations for a CPU program to input data follows a logical order to ensure proper data flow and processing.
• The correct sequence is as follows:

1. A. Read status register: The CPU first reads the status register to determine the current state of the device or peripheral.
2. B. Check flag bit: The CPU then checks the flag bit to identify if the device is ready to send data.
3. C. Read Data Register: If the device is ready, the CPU reads the data from the data register.
4. D. Transfer data to memory: Finally, the CPU transfers the data from the data register to memory for further use.

Additional Information

• Read status register: The status register provides critical information about the state of the device, such as whether it is busy or ready.
• Check flag bit: The flag bit indicates the readiness of the device. For example, it may show whether the input buffer is full or empty.
• Read Data Register: Once the flag indicates readiness, the CPU accesses the data register to retrieve the input data.
• Transfer data to memory: The data is finally written to memory for later processing by the program.

Hence, the correct answer is: Option 1) A, B, C, D

The correct answer is Option 4) L = { strings over {a,b,c} that contain an even number (including 0) of the substring “abc” }

Key Ideas

• The DFA has six states that naturally split into two groups of three:
• Even-parity copy: tracks how much of “abc” has been matched so far when the count of completed “abc” substrings is even (0, 2, 4, …).
• Odd-parity copy: the same three “progress” states when the count is odd (1, 3, 5, …).
• Within each copy, the machine remembers the progress toward “abc”:
• state for “seen nothing yet” → on ‘a’ go to “seen a”;
• state for “seen a” → on ‘b’ go to “seen ab”;
• state for “seen ab” → on ‘c’ you complete “abc”.
• Toggling parity: each time the machine reads a full “abc”, it moves to the same progress state in the other copy (even ⇄ odd). Thus the parity of the number of “abc” seen so far flips after every completion.
• Accepting condition: all states in the even copy are accepting (including the start state). Therefore the DFA accepts exactly those strings with an even number of occurrences of the substring “abc” (0 is allowed).

How the transitions behave (intuition)

• On symbols that continue the partial match (a→b→c), the machine advances along the “progress” states.
• On symbols that break the match, it falls back to the longest proper prefix of “abc” that is also a suffix of what was just seen (KMP-style fallback). This ensures overlapping occurrences are handled (e.g., “…ababc…” contains two “abc”: the automaton will count both correctly).
• When a full “abc” is read, the transition from the “seen ab” state on ‘c’ jumps to the corresponding state in the other parity copy, flipping even↔odd.

Quick traces

• ε (empty string): 0 occurrences of “abc” → even → accepted.
• abc: 1 occurrence → odd → rejected.
• abcabc: 2 occurrences → even → accepted.
• abca: still only 1 full “abc” → odd → rejected.
• ababc: contains “abc” once (ending positions overlap is handled correctly) → odd → rejected; ababcabc has two → even → accepted.

Why the other options are incorrect

• Option 1) (a + b + c*)*** equals (a|b|c)* (i.e., all strings over {a,b,c}). Our DFA does not accept all strings (e.g., it rejects any string with an odd number of “abc”).
• Option 2) (a + b + c)(abc)(a + b + c)* describes all strings that contain at least one “abc” (one or more). It accepts strings with 1, 3, 5, … occurrences too, but the DFA rejects those (odd count), so this is not correct.
• Option 3) “strings starting with a/b/c and ending with c” is simply “strings ending with c”; the DFA accepts many strings not ending with c (e.g., the empty string, or abcabc), hence this description is wrong.

Takeaway

The structure (two 3-state copies and parity toggling upon completing “abc”) is the hallmark of a DFA recognizing strings in which the number of a specific substring is even. Therefore the best description is the language with an even count of the substring “abc”.

The correct answer is Option 4) A B + D * E F − ↑

Key Points

• We must convert the infix expression Q = ((A + B) * D) ↑ (E − F) to postfix (Reverse Polish) form.
• Operator facts used:
• Parentheses force evaluation of the enclosed subexpression first.
• Precedence: ↑ (exponent) > * > +/−.
• ↑ is right-associative; *, +, − are left-associative.
• Postfix rule: write the postfix of each operand/subexpression, then append the operator.

Step-by-step conversion (by subexpressions)

1. Left inner parentheses: (A + B) → postfix is AB+.
2. Multiply by D: ((A + B) * D) → append D then * ⇒ AB+D*.
3. Right inner parentheses: (E − F) → postfix is EF-.
4. Exponent between the two big operands:
   

Left operand’s postfix = AB+D*, right operand’s postfix = EF-.

Append the operator ↑ ⇒ AB+D* EF- ↑.

Final postfix

A B + D * E F − ↑

Quick verification via stack method (tokens scanned left→right)

Output: A B + D * | Stack after handling left side: ( ^ ) Output: A B + D * E F - | Pop ^ at end → A B + D * E F - ↑

Thus, the equivalent postfix expression of ((A+B)*D) ↑ (E−F) is A B + D * E F − ↑ (Option 4).

The correct answer is ((*(ar + m) + n) + o)

Key Ideas

• In C, the subscript rule is: a[i] ≡ * (a + i). This is true for every dimension.
• When an array name appears in an expression (not as sizeof or unary &), it decays to a pointer to its first element.
• For a 3-D array int ar[X][Y][Z];, the “first element” is the first 2-D block ar[0], whose type is int [Y][Z]. After decay, ar has type int (* )[Y][Z] (pointer to a [Y][Z] array).

Step-by-step expansion of ar[m][n][o]

1. ar[m] Use the rule once: ar[m] ≡ * (ar + m). Meaning: move m blocks of size Y×Z elements to reach the 2-D block starting at ar[m].
2. ar[m][n] Apply the rule inside that block: ar[m][n] ≡ * ( *(ar + m) + n ). Here, *(ar + m) has type int [Y][Z] and decays to pointer to its first row, so + n steps n rows, each of length Z.
3. ar[m][n][o] Apply the rule again on the 1-D row: ar[m][n][o] ≡ * ( ((ar + m) + n) + o ). Now ((ar + m) + n) has type int [Z] and decays to int*, so + o steps to the o-th element, and final * fetches the value.

Final pointer form

((*(ar + m) + n) + o)

Type trail (to see why the dereferences are needed)

ar : int ()[Y][Z] (pointer to 2-D block) ar + m : int ()[Y][Z] (ar + m) : int [Y][Z] (the m-th 2-D block) (ar + m) (decays) : pointer to first row → int ()[Z] (ar + m) + n : int ()[Z] (pointer to n-th row) ((ar + m) + n) : int [Z] (the n-th row) ((ar + m) + n) (decays) : int * (pointer to first element in row) ((ar + m) + n) + o : int * (pointer to o-th element) (((ar + m) + n) + o) : int (the element value)

How pointer arithmetic scales correctly

• ar + m jumps by m × Y × Z integers (size of one 2-D block).
• *(ar + m) + n then jumps by n × Z integers (size of one row) inside that block.
• ... + o finally moves by o integers within the row.

Common mistakes (why the other patterns are wrong)

• Missing a dereference: expressions like (((ar + m) + n) + o) stop at a pointer and do not fetch the element.
• Wrong grouping/order: e.g., ((ar + m + n) + o) mixes dimensions and does not move by row sizes correctly.
• Too few *: you need three dereferences for three dimensions (block → row → element).

Mini numeric example

int ar[2][3][4]; // X=2, Y=3, Z=4 // Address math (assuming int is 4 bytes, just for intuition): // base(ar) + (m * 3 * 4 + n * 4 + o) * sizeof(int)

For m=1, n=2, o=3 the offset in elements is 112 + 24 + 3 = 12 + 8 + 3 = 23, which is exactly what ((*(ar + 1) + 2) + 3) reaches by three scaled pointer steps.

The correct answer is Option 4)  xyz + xyz' + xy'z'

Key Points

• Given Boolean expression: A(x,y,z) = x (y' z)'.
• Use De Morgan’s law to remove the outer complement:

(y' z)' = (y')' + z' = y + z'

• Therefore,

A = x (y + z') = xy + xz'

This is a valid SOP, but not complete because each product term must list all variables (minterms).

Make it a complete sum-of-products (expand to minterms)

• Term 1: xy (z is don’t-care)

xy = xy(z + z') = xyz + xyz'

• Term 2: xz' (y is don’t-care)

xz' = xz'(y + y') = xyz' + xy'z'

• Combine and remove duplicates:

A = (xyz + xyz') + (xyz' + xy'z') = xyz + xyz' + xy'z'

Important Points

• Complete SOP (canonical SOP) means a sum of minterms: each product contains all variables in either complemented or uncomplemented form.
• De Morgan’s Law: (AB)' = A' + B' and (A + B)' = A'B'.
• To expand a product with a don’t-care variable, use X = X(Y + Y') to obtain both minterms.

The Correct answer is: Option 1 (A-II, B-III, C-I, D-IV)

Equivalence Partitioning (A-II):

• Equivalence Partitioning is a software testing technique that divides input data into partitions or sets of valid and invalid inputs.
• It helps reduce the number of test cases to an optimal level while ensuring coverage of all possible scenarios.
• In this technique, the input is divided into valid/invalid sets, making it easier to check the behavior of the system for each partition.

Boundary Value Analysis (B-III):

• Boundary Value Analysis is a testing technique focused on the boundaries or limits of input ranges.
• It tests the behavior of the system at the boundary values (e.g., the minimum, maximum, just inside, just outside, and typical values).
• This technique is particularly useful for identifying errors at the edges of input ranges.

Cyclomatic Complexity (C-I):

• Cyclomatic Complexity is a metric used in software testing and development to measure the complexity of a program's control flow.
• It is calculated by counting the number of independent paths in the code.
• This metric helps identify areas of code that may require more rigorous testing.

Decision Table Testing (D-IV):

• Decision Table Testing is a software testing technique that uses a decision table to represent combinations of conditions and actions.
• It systematically tests different combinations of input conditions to ensure that all possible scenarios are covered.
• In this approach, a number of combinations of actions are tested under varying sets of conditions.

The correct answer is 1

Key Points

• Code (formatted): int i, j;

for (i = 1; i < 5; i += 2) // i: 1, 3 for (j = 1; j < i; j += 2) // j starts at 1 for each i printf("%d", j); // prints j with no spaces/newline

• No braces ⇒ the inner for loop is the single statement body of the outer loop, and printf is the single statement body of the inner loop.
• The inner loop re-initializes j = 1 for each value of i, and then prints all odd j values that are strictly less than i (because j += 2).

Step-by-step dry run

After i = 3, the next i would be 5, but the condition i < 5 fails, so the loops end. Only one character was printed: 1.

Important Points

• Loop bodies without braces: only the immediately following statement belongs to the loop.
• Inner loop re-initialization: j is reset to 1 for each new i.
• Strict inequality (j < i) prevents printing when i = 1, and allows only j = 1 when i = 3.
• No spaces/newline in printf("%d", j), so the output is exactly 1.

Statement: The Correct answer is Option 2.

Explanation of Option 2 (A-IV, B-II, C-I, D-III):

A. Oblique Projection (A-IV):

• In oblique projection, the angle between the projectors (lines of sight) and the plane of projection is not equal to 90°.
• This results in the objects appearing distorted, giving a 3D-like effect on a 2D plane.
• The projectors are inclined to the projection plane, which distinguishes oblique projection from orthographic projection.

B. Cavelier Projection (B-II):

• Cavelier projection is a type of oblique projection in which the direction of projection is chosen such that there is no foreshortening of lines perpendicular to the plane of projection.
• In this projection, true lengths are retained for lines perpendicular to the plane, making it suitable for technical illustrations.

C. Cabinet Projection (C-I):

• Cabinet projection is another type of oblique projection where the direction of projection is chosen such that the lines perpendicular to the plane of projection are foreshortened.
• Typically, these perpendicular lines are scaled to half their original length to provide a more realistic appearance.

D. Orthographic Projection (D-III):

• Orthographic projection is a method of projection where the direction of projection is perpendicular to the plane of projection.
• This results in a true-to-scale representation of the object without any distortion or perspective effects.
• Orthographic projections are commonly used in engineering drawings and technical diagrams.

The correct answer is Reverse Engineering

Key Points

• Reverse Engineering: ✅ Reverse engineering is the process of analyzing a software system to identify difficult, unknown, or hidden information, such as structure, functionality, and design. It is commonly used to understand legacy systems, improve software, or detect vulnerabilities.
• Software Engineering: ❌ Software engineering refers to the systematic approach to the design, development, and maintenance of software systems, not the process of uncovering hidden information.
• Software Re-Engineering: ❌ Software re-engineering involves modifying or updating existing software to improve its functionality or performance, but it doesn't specifically focus on discovering hidden information.
• Inverse Engineering: ❌ "Inverse engineering" is not a commonly recognized term in the software domain.

Additional Information

• Applications: Reverse engineering is often used in software maintenance, security analysis, and studying competitor products.
• Challenges: Reverse engineering can be complex and time-consuming, especially for large systems with undocumented features.

Hence, the correct answer is: option 3) Reverse Engineering

Statement:

The Correct answer is option 3: A-III, B-I, C-IV, D-II.

Explanation:

Chaining:

• Chaining is a collision handling method where a linked list is maintained at each index of the hash table.
• When a collision occurs (multiple keys mapping to the same index), the new element is added to the linked list at that index.
• Therefore, A matches with III (Linked list at index).

Linear Probing:

• Linear Probing is a collision resolution strategy where, if a collision occurs, the next slot in the hash table is checked sequentially until an empty slot is found.
• This method uses a linear sequence of steps to resolve collisions.
• Therefore, B matches with I (Check next slot).

Quadratic Probing:

• Quadratic Probing is a collision resolution strategy where the next slot is determined using a quadratic function.
• Instead of checking slots sequentially, it skips slots using a quadratic step (e.g., 1², 2², 3², etc.) to avoid clustering of keys.
• Therefore, C matches with IV (Skip slots using quadratic step).

Double Hashing:

• Double Hashing is a collision resolution method where a second hash function is used to determine the next slot in case of a collision.
• This ensures better distribution and reduces clustering compared to linear and quadratic probing.
• Therefore, D matches with II (Use second hash function).

The correct answer is 90 (Option 2)

Key Points

• The expression on the right side of c = ( ... ) uses the comma operator. It evaluates sub-expressions from left to right and returns the value of the last sub-expression.
• Assignments inside that comma expression change a and b step by step; the final value (of the last assignment) is stored in c.
• --(*i) is a pre-decrement on the value pointed by i. Since i = &c, it decreases c by 1 and then prints it.

Given code (formatted):

void main() { int i, a = 12, b = 2, c; c = ( a = a + b, / step 1 / b = a / b, / step 2 / a = a * b, / step 3 / b = a - b ); / step 4 (value of comma expr) */ i = &c; printf("%d", --(*i)); }

Step-by-step evaluation of the comma expression:

1. a = a + b → a = 12 + 2 = 14
2. b = a / b → b = 14 / 2 = 7 (integer division)
3. a = a * b → a = 14 * 7 = 98
4. b = a - b → b = 98 - 7 = 91
   

The comma expression’s value is the value of this last assignment, i.e., 91. Therefore, c = 91.

Printing: i = &c so *i refers to c. --(*i) pre-decrements c to 90 and then prints it.

Important Points

• Comma operator: Evaluates operands left→right; only the last value is returned, but all side effects occur.
• Pre vs Post decrement: --x decrements then yields the new value; x-- would print the old value and decrement later.

Why other options are wrong:

• 91 – would be printed if there were printf("%d", *i--) or no decrement; but here we pre-decrement to 90.
• 98 – comes from the intermediate value of a (step 3), not what we store in c.
• 92 – results from an incorrect arithmetic/ordering assumption; correct final c is 91, then decremented to 90.

The correct answer is Transfer data from memory to I/O device

Key Points

• Write Operation: ✅ In I/O operations, the write operation refers to transferring data from the computer's memory to an I/O device (e.g., writing data to a file on a disk, sending data to a printer, or outputting data to a display).
• Transfer from I/O device to memory: ❌ This is the definition of a read operation, not a write operation.
• Transfer from CPU register to memory: ❌ This involves internal data movement within the computer and is unrelated to I/O operations.
• Transfer from CPU register to I/O device: ❌ This is a lower-level operation and might involve intermediate buffering in memory, but it is not the direct definition of the I/O write operation.

Additional Information

• Input/Output (I/O): Refers to the communication between a computer and external devices. Examples include keyboards, displays, storage devices, and networks.
• Write Operation: A process where data is sent from the computer's memory to an external device (e.g., saving a file, sending data to a printer).
• Read Operation: A process where data is received from an external device to the computer's memory (e.g., loading a file from disk).

Hence, the correct answer is: option 2) Transfer data from memory to I/O device

The Correct Answer is Option 2 

Key Points

A. Circular Queue - II (CPU Scheduling):

• A circular queue is a linear data structure that follows the FIFO principle but the last node is connected back to the first node, forming a circle.
• It is often used in CPU scheduling algorithms where processes are placed in a circular queue to ensure equal time allocation to each process in a round-robin manner.
• Thus, Circular Queue is most commonly associated with CPU Scheduling.

B. Priority Queue - III (Dijkstra Algorithm):

• A priority queue is a type of data structure where each element is associated with a priority and is served according to its priority level.
• It is used in Dijkstra's algorithm to find the shortest path in a weighted graph by prioritizing vertices with the smallest tentative distance.
• Hence, Priority Queue is used in Dijkstra Algorithm.

C. Double Ended Queue - IV (Palindrome Checking):

• A double-ended queue (Deque) allows insertion and deletion at both ends of the queue.
• It is useful in palindrome checking as characters can be removed from both ends to verify symmetry.
• Thus, Double Ended Queue is associated with Palindrome Checking.

D. Simple Queue - I (Print Queue):

• A simple queue is a linear data structure that follows the FIFO principle, where elements are added at the rear and removed from the front.
• It is ideal for managing print queues where print jobs are processed in the order they were added.
• Thus, Simple Queue corresponds to Print Queue.

The correct answer is Option 2) EC

Key Points

• Relation: R(A, B, C, D, E)
• Functional Dependencies (FDs): C → F, E → A, EC → D, A → B
• Note: Attribute F is not in R. For finding a key of R, we only need to determine {A, B, C, D, E}; the FD C → F does not help us reach any new attribute of R and can be ignored for key finding.
• A key (candidate key) is a minimal set of attributes whose closure gives all attributes of the relation.

Explanation (Attribute-Closure Method):

We compute the closure of each option using the given FDs and check if it gives {A, B, C, D, E}.

1. Option 1) CD

• Start: CD⁺ = {C, D}
• From C → F we can add F (outside R, not useful).
• No FD gives E or A or B from C or D.
• CD⁺ = {C, D} (not all attributes) ⇒ Not a key.

2. Option 2) EC

• Start: EC⁺ = {E, C}
• From E → A add A.
• From A → B add B.
• From EC → D add D.
• Now we have {A, B, C, D, E} ⇒ covers all attributes of R.
• Check minimality:
• E⁺ = {E, A, B} (missing C, D) ⇒ E alone is not a key.
• C⁺ = {C} plus F outside R ⇒ C alone is not a key.

Hence, EC is minimal.

• Therefore, EC is a candidate key.

3. Option 3) AE

• Start: AE⁺ = {A, E}
• From A → B add B.
• We still lack C and D. No FD gives C or D from {A, E} (since EC → D needs C too).
• AE⁺ = {A, E, B} ⇒ Not a key.

4. Option 4) AC

• Start: AC⁺ = {A, C}
• From A → B add B.
• No way to get E; without E, cannot use EC → D to reach D.
• AC⁺ = {A, C, B} ⇒ Not a key.

Important Points

• Attribute Closure: Repeatedly add attributes implied by FDs until no new attribute can be added. If the closure equals the whole schema, the starting set is a superkey. If none of its proper subsets is a superkey, it is a candidate key.
• Ignoring outside attributes: FDs that only produce attributes not in the relation (here, F) do not affect whether a set is a key for R.
• Minimality check: After you find a

The Correct answer is Option 2

Key Points

Dijkstra's Algorithm:

• Dijkstra's algorithm is a Greedy algorithm used to find the shortest path from a source node to all other nodes in a graph.
• It works by selecting the node with the smallest tentative distance, updating its neighbors, and repeating the process until all nodes are visited.
• This greedy approach ensures that the algorithm always chooses the locally optimal solution at each step to eventually find the globally optimal solution.

Kruskal's Algorithm:

• Kruskal's algorithm is a Greedy algorithm used to find the Minimum Spanning Tree (MST) of a graph.
• It works by sorting all edges in ascending order of weights and repeatedly adding the smallest edge to the MST if it doesn't create a cycle.
• The greedy strategy ensures that the algorithm picks the best edge at each step, leading to the overall optimal solution for the MST.

Huffman Coding:

• Huffman coding is a Greedy algorithm used for lossless data compression.
• It builds a prefix-free binary tree by repeatedly selecting the two smallest frequency nodes and combining them into a new node.
• The greedy approach ensures that the algorithm minimizes the average length of the encoded data, achieving optimal compression.

Bellman-Ford Algorithm:

• Bellman-Ford algorithm is NOT a Greedy algorithm. It uses Dynamic Programming to find the shortest path from a source node to all other nodes in a graph.
• It works by relaxing all edges repeatedly, allowing it to handle graphs with negative edge weights.
• Unlike greedy algorithms, Bellman-Ford does not make locally optimal choices at each step.

The correct answer is Option 3

Key Points

• Coupling refers to the degree of interdependence between software modules. Lower coupling indicates better modularity and easier maintainability.
• The various types of coupling, ranked from lowest to highest, are as follows:

1. Stamp Coupling (B): Modules share a composite data structure but use only a part of it. This is the lowest form of coupling in the given options.
2. Control Coupling (C): One module controls the behavior of another by passing information on what to do (e.g., control flags).
3. External Coupling (D): Modules depend on externally defined data formats, communication protocols, etc.
4. Common Coupling (A): Modules share global data, which can lead to unintended interactions and reduced maintainability.
5. Content Coupling (E): The highest form of coupling, where one module directly modifies or relies on the internal workings of another module (e.g., accessing private data).

Additional Information

• Lower coupling: Makes software easier to maintain, test, and understand.
• Higher coupling: Leads to tightly interconnected modules, making the code harder to modify and maintain.
• In general, aim for low coupling and high cohesion in software design.

Hence, the correct answer is: Option 3) B, C, D, A, E

The correct answer is Choke

Key Points

• Choke Packet: ✅ A choke packet is a control packet sent by a node experiencing congestion to the source node. This informs the source to reduce its transmission rate to alleviate congestion.
• Explicit: ❌ Explicit congestion notification typically refers to a specific mechanism in some protocols, but it does not denote a packet sent by a node.
• Backpressure: ❌ Backpressure is a congestion control mechanism where the congested node stops accepting data, but it does not involve sending a specific packet.
• Retransmission: ❌ Retransmission occurs when data is resent due to errors or losses, but this is not related to congestion control packets.

Additional Information

• Congestion Control: Congestion occurs in a network when too many packets are sent simultaneously, leading to delays and packet loss. A choke packet helps mitigate this by instructing the source node to slow down transmission.
• Network Protocols: Choke packets are part of certain network protocols, such as TCP/IP, designed to manage congestion efficiently.

Hence, the correct answer is: option 3) Choke

The correct answer is: Option 4) A, E Only

Key Rules of Pointer Arithmetic in C

• Rule 1: pointer ± integer → pointer Adding or subtracting an integer from a pointer moves it by that many elements (scaled by sizeof(*pointer)).
• Rule 2: pointer − pointer → integer (ptrdiff_t) Subtracting two pointers gives the number of elements between them, defined only when both pointers point into the same array (or one past its end).
• Rule 3: pointer + pointer is illegal in C; there is no meaning for “adding two addresses.”

Interpreting the statements A–E

• A. pointer + number → pointer — Legal. Matches Rule 1.
• B. pointer − number → number — Illegal as written. In C, pointer − integer produces a pointer, not a number. (If this option had said “→ pointer,” it would be legal.)
• C. pointer + pointer → pointer — Illegal. Adding two pointers is not allowed (violates Rule 3).
• D. pointer − pointer → pointer — Illegal. Subtracting pointers yields an integer count, not a pointer (violates Rule 2).
• E. pointer − pointer → number — Legal. Matches Rule 2; result type is typically ptrdiff_t.

Mini examples

int a[10]; int *p = &a[3]; int *q = &a[7];

p + 2; /* legal: pointer to a[5] / q - 3; / legal: pointer to a[4] / q - p; / legal: value 4 (of type ptrdiff_t) */

p + q; /* illegal / p - 2.0; / illegal: RHS must be integer, not double / p - q; / legal, but result is an integer, not a pointer */

Conclusion

Only statements that conform to C’s pointer arithmetic are A and E. Hence, the most appropriate answer is Option 4) A, E Only.

The correct answer is Option 1) 1.024 sec

Key Points

• Process size (to swap): 15 MB
• Disk transfer rate: 30 MB/s
• Average rotational latency: 12 ms = 0.012 s
• No head seek ⇒ ignore seek time; only latency + transfer time matter.
• Swapping a process in/out involves two I/O operations: write to disk (swap out) and read back (swap in).

Step 1: Transfer time for 15 MB

Transfer time per operation = Size / Rate = 15 / 30 = 0.5 s.

Step 2: Add rotational latency per operation

Each I/O pays one latency: 0.012 s.

So, time per operation (either swap out or swap in): 0.5 + 0.012 = 0.512 s.

Step 3: Total swap time (out + in)

Total = 2 × 0.512 = 1.024 s.

Important Points

• Transfer time scales with size and bandwidth; latency is a fixed overhead per I/O.
• If seek time were present, it would be added once per I/O as well.
• Always convert milliseconds to seconds when summing with transfer time.

The correct answer is Option 1) w1 = 0.1, w2 = 0.1

Given

• Training samples (x₁, x₂ → target): S1:(0,0→0), S2:(0,1→1), S3:(1,0→1), S4:(1,1→1)
• Initial weights: w₁=0, w₂=0; learning rate α=0.1; no bias.
• Activation: y = 1 if yin > 0, else y = 0 (for yin ≤ 0 we take 0).
• Perceptron update (sequential/online): w ← w + α (t − y) x i.e., w_k,new = w_k,old + α (t − y) x_k.

Step-by-step training over S1 → S4

Result: After one pass over S1→S4, the updated weights are w1 = 0.1 and w2 = 0.1.

Sanity check

• With w = (0.1, 0.1), yin for S2/S3/S4 is 0.1, 0.1, 0.2 respectively > 0 ⇒ y=1 (matches targets); for S1 yin=0 ⇒ y=0 (matches target). Hence the final weights classify all four samples correctly.

The correct answer is Option 1: A relation with only two attributes is always in BCNF. Here is the step-by-step breakdown of why this is the correct choice and why the other options are incorrect:

Why Option 1 is Correct

In a relation with exactly two attributes, say R(A, B), there are only a few possibilities for non-trivial functional dependencies (FDs):

Case 1: A -> B. Here, A is a superkey. Since the determinant is a superkey, BCNF is satisfied.

Case 2: B -> A. Here, B is a superkey. BCNF is satisfied.

Case 3: Both A -> B and B -> A. Both A and B are candidate keys. BCNF is satisfied.

Case 4: No non-trivial FDs exist. The candidate key is the composite key {A, B}. Since there are no FDs to violate the rule, BCNF is inherently satisfied.

In all possible scenarios, a binary relation meets the requirements for Boyce-Codd Normal Form.

Why the Other Options are Incorrect

• Option 2: If all attributes of a relation are prime attributes then the relation is in BCNF. * Incorrect. If all attributes are prime, the relation is guaranteed to be in 3NF, but not necessarily in BCNF.Example: Consider relation R(A, B, C) with candidate keys {A, B} and {A, C}. The functional dependencies are AB -> C and C -> B. All attributes are prime (part of a candidate key). However, the dependency C -> B violates BCNF because C is a determinant but not a superkey.
• Option 3: Every relation has at least one non-prime attribute. Incorrect. A relation can consist entirely of prime attributes. For example, a mapping table for a many-to-many relationship (like a Student_Course table with attributes StudentID and CourseID) often uses all its attributes to form the primary key. In this case, there are zero non-prime attributes.
• Option 4: BCNF decomposition preserves functional dependencies. Incorrect. BCNF decomposition guarantees a lossless join, but it does not guarantee dependency preservation. When decomposing a table to achieve BCNF, you may lose functional dependencies. If both lossless join and dependency preservation are strictly required, you must sometimes stop at 3NF

The correct answer is Option 3) 2,3,2,1

Key Points

• LCS (Longest Common Subsequence) is a sequence that appears in both lists in the same order (not necessarily contiguously) and has maximum possible length.
• Let A = {1,2,3,2,4,1,2} and B = {2,4,3,1,2,1}. We will use the standard DP (dynamic programming) table of lengths L[i][j] = LCS length of A[1..i] and B[1..j].

DP Length Table (final values)

The bottom-right value is 4, so the LCS length is 4.

Reconstruction (backtracking idea)

• From the last cell (length 4), match the last common element: A[6]=1 matches B[6]=1 → include 1.
• Move to subproblem before these indices: we are now at length 3 with prefixes ending before A[6] and B[6].
• Trace previous matches: before the final 1, we can match 2 (A[4] with B[5]), before that 3 (A[3] with B[3]), and before that 2 (A[2] with B[1]).

Thus one LCS is {2, 3, 2, 1}.

Why other options are wrong

• 2,1,2,3: In B, after taking the last 2 (position 5), there is no 3 to the right, so this order cannot occur.
• 1,3,2,1: In B, 1 appears at positions 4 and 6; there is no 3 after position 4 that can still keep the order 1→3, so this sequence cannot occur.
• 2,3,1,2,1 (length 5): Not a subsequence of A (after 1 at position 6, there is no trailing 1 to complete length 5); hence impossible, and anyway longer than the DP length 4.

Conclusion: The longest common subsequence of the two sequences is 2,3,2,1 (length 4).

Correct Option: 3) This is a specification only for thread behavior and not its implementation

Key Points

Pthreads (POSIX Threads) is a standardized API for creating and managing threads in Unix-like systems. It defines the interface and expected behavior (e.g., how functions like pthread_create or pthread_join should operate) but does not dictate the underlying implementation details, which are left to the operating system or library (e.g., kernel-level vs. user-level threading).

Why Not the Others?

• Option 1: Incorrect due to the erroneous standard reference (it's IEEE 1003.1c-1995, not 1002.1c). While Pthreads is part of POSIX, the factual error invalidates this.
• Option 2: False. The standard covers a full API, including synchronization (mutexes, condition variables), attributes, and cancellation—not just creation.
• Option 4: False. Most listed OSes (Solaris, Linux, Mac OS X) implement Pthreads, and Tru64 UNIX also provides a POSIX Threads Library compliant with IEEE 1003.1-1996.

The correct answer is Data Flow Diagram (DFD)

Key Points

• Requirement Elicitation: The process of gathering and discovering the requirements of a system from users, stakeholders, and other sources.
• Interviews: ✅ Interviews are a widely used requirement elicitation technique where stakeholders are interviewed to gather requirements.
• The Use Case Approach: ✅ Use cases describe how a system interacts with users to achieve specific goals. This is an effective elicitation technique.
• Facilitated Application Specification Technique (FAST): ✅ FAST is a structured approach to requirement elicitation where stakeholders collaborate in workshops to define system requirements.
• Data Flow Diagram (DFD): ❌ A DFD is a modeling tool used to represent the flow of data within a system. It is not a requirement elicitation technique; rather, it is used during system analysis and design.

Additional Information

• Requirement elicitation techniques: Common techniques include interviews, surveys, brainstorming, focus groups, prototyping, and observation.
• Data Flow Diagrams: DFDs are used to model the flow of data and are part of the analysis phase, not elicitation.

Hence, the correct answer is: option 4) Data Flow Diagram (DFD)

The Correct Answer is Option 2: A, B and D Only

Key Points

Explanation of Cohesion Types:

• Functional Cohesion: ✅ This is the highest form of cohesion. It occurs when components of a module work together to achieve a single, well-defined purpose. It is better than Procedural Cohesion.
• Sequential Cohesion: ✅ This occurs when components are grouped because the output of one serves as input to another. This is also better than Procedural Cohesion.
• Temporal Cohesion: ❌ This occurs when components are grouped based on their execution time, like initialization tasks. It is not better than Procedural Cohesion.
• Communicational Cohesion: ✅ This occurs when components operate on the same data or contribute to the same output. It is better than Procedural Cohesion.
• Logical Cohesion: ❌ This occurs when components perform similar tasks based on control logic, such as a switch statement. It is not better than Procedural Cohesion.

Additional Information

• Procedural Cohesion: This occurs when components are grouped to perform a series of procedural steps, often without a clear focus on a single task. It is considered weaker than Functional, Sequential, and Communicational Cohesion.
• Higher cohesion is desirable in software design as it leads to better maintainability, readability, and modularity.

Hence, the correct answer is: Option 2: A, B and D Only

The correct answer is Option 3

Key Points

• Statement A: ✅ True. The number of tags decreases in XML since users can define their own tags based on their needs. This flexibility allows XML to be extensible and customizable.
• Statement B: ❌ False. XML is not used for presentation purposes. It is a data description and storage format. Presentation is typically handled by technologies like HTML or XSLT when XML data is displayed.
• Statement C: ✅ True. XML is case-sensitive. For example, and would be treated as two distinct elements.
• Statement D: ✅ True. XML is dynamic in nature because it allows users to define their own custom tags and adapt the structure as needed.

Additional Information

• XML Overview: XML (Extensible Markup Language) is a markup language used to store, transport, and describe data. It is platform-independent and widely used in data exchange between systems.
• Flexibility: XML allows users to create their own tags, making it highly adaptable for various use cases like web services, configuration files, and more.
• Case Sensitivity: XML enforces strict case sensitivity, which means elements, attributes, and tags must be consistently used with the correct casing.
• Non-Presentation: XML is designed for data representation and not for visual presentation. Presentation is handled by other technologies.

Hence, the correct answer is: Option 3) A, C, D Only

Statement: The Correct answer is Option 3.

Explanation:

A. Type 3 Grammar:

• Type 3 Grammar is also known as Regular Grammar. It generates regular languages which are accepted by finite automata.
• The rules of this grammar are of the form V → (VUΣ)*, where V is a non-terminal, U is a terminal, and Σ represents the alphabet.
• Therefore, it matches with II.

B. Type 2 Grammar:

• Type 2 Grammar is also known as Context-Free Grammar. It generates context-free languages which are accepted by pushdown automata.
• The rules of this grammar are of the form λνβ → λ(VUE)β, where (λ, β) ∈ (VU Σ).
• Therefore, it matches with I.

C. Type 1 Grammar:

• Type 1 Grammar is also known as Context-Sensitive Grammar. It generates context-sensitive languages which are accepted by linear-bounded automata.
• The rules of this grammar are of the form (VUE)* → (VUE)*.
• Therefore, it matches with III.

D. Type 0 Grammar:

• Type 0 Grammar is also known as Unrestricted Grammar. It generates recursively enumerable languages which are accepted by Turing machines.
• The rules of this grammar are of the form V → VΣΙΣ, where V represents non-terminals and ΣΙΣ represents terminals.
• Therefore, it matches with IV.

Final Matching:

• A → II
• B → I
• C → III
• D → IV

Correct Answer: Option 3

The correct answer is Option 2) 3/5

Key Points

• Total numbers in the set = 200 (all integers from 1 to 200 inclusive).
• We want numbers divisible by 2 or 5. Use inclusion–exclusion.
• Multiples of 2 up to 200 = ⌊200/2⌋ = 100.
• Multiples of 5 up to 200 = ⌊200/5⌋ = 40.
• Numbers counted twice (multiples of both 2 and 5 = multiples of 10) = ⌊200/10⌋ = 20.
• Favourable count = 100 + 40 − 20 = 120.

Probability = favourable / total = 120 / 200 = 12/20 = 3/5.

Quick Check (Complement Method)

• Numbers not divisible by 2 or 5 end with digits {1,3,7,9} → 4 out of every 10 numbers.
• Count = (4/10) × 200 = 80. So probability of “not divisible by 2 or 5” = 80/200 = 2/5.
• Therefore, probability of “divisible by 2 or 5” = 1 − 2/5 = 3/5 (same result).

Key Points

• Non-Return to Zero (NRZ): ✅ NRZ is a data encoding scheme where binary data is represented using two distinct voltage levels. It is a widely used encoding method.
• Manchester Encoding: ✅ This is another example of a data encoding scheme. In Manchester Encoding, the data is encoded using voltage transitions to represent binary 0s and 1s.
• Amplitude Modulation (AM): ❌ Amplitude Modulation is not a data encoding scheme but rather a modulation technique used for transmitting signals over a carrier wave.
• Hamming Code: ❌ Hamming Code is a method used for error detection and correction, not for encoding data for transmission.
• Bipolar AMI: ✅ Bipolar Alternate Mark Inversion (AMI) is a data encoding scheme where binary 0 is represented by no voltage, and binary 1 alternates between positive and negative voltages.

Correct Answer

From the above analysis, the correct options that represent data encoding schemes are:

• A. Non-Return to Zero (NRZ)
• B. Manchester Encoding
• E. Bipolar AMI

Hence, the correct answer is: Option 4) A, B, and E Only

The correct answer is Option 1 (A, B Only)

Key Points

• A. Agent system comprises of an agent and an environment on which it acts: ✅ This statement is correct. An agent system is defined as having two main components: an agent and the environment it interacts with. The agent perceives its environment and acts upon it to achieve its goals.
• B. The controller part of an agent receives percepts from its body and sends commands to the environment: ✅ This statement is correct. The controller, which is part of the agent, processes the percepts (inputs) received from its body (sensors) and sends appropriate actions (outputs) to the environment through actuators.
• C. Agents act in the world through actuators which are non-noisy and always reliable: ❌ This statement is incorrect. Actuators in real-world systems are often subject to noise and reliability issues. They may not always function perfectly due to hardware limitations or environmental factors.
• D. The actuators of an agent convert stimuli into percepts: ❌ This statement is incorrect. Actuators are responsible for performing actions in the environment, not converting stimuli into percepts. Sensors, not actuators, are responsible for converting stimuli into percepts.

Additional Information

• Environment: The environment is the external system with which the agent interacts.
• Percepts: These are the inputs or stimuli received by the agent from the environment through its sensors.
• Actuators: These are the components through which the agent performs actions in the environment based on decisions made by the controller.

Hence, the correct answer is: Option 1 (A, B Only)

The correct answer is: Option 1) (A), (C), (D)

Given: m and n are positive integers.

Concepts to use

• Positive integers are 1, 2, 3, … (so m ≥ 1, n ≥ 1).
• Composite number k > 1 is a number that can be written as a product of two integers strictly between 1 and k: there exist m, n with 1 < m < k, 1 < n < k and k = mn.

Statement (A): If n ≠ 1, then m < mn.

• Since n is a positive integer and n ≠ 1, we must have n ≥ 2.
• Multiplying m (which is positive) by n ≥ 2 strictly increases its value: mn ≥ 2m > m.
• Therefore, (A) is true.

Statement (B): If k is composite, then k = mn where 1 < m , n > k.

• This wording claims one of the factors is greater than k (“n > k”), which is impossible if mn = k with positive integers.
• Example: k = 12 is composite. Valid factorizations are 12 = 3×4, 2×6. In every case, each factor is between 1 and 12 (strictly); none is > 12.
• Therefore, (B) is false.

Statement (C): If mn = 1 then m = 1 and n = 1.

• With positive integers, the only way a product equals 1 is when each factor is 1.
• Therefore, (C) is true.

Statement (D): If k is composite, then k = mn where 1 < m < k and 1 < n < k.

• This is exactly the definition of a composite number.
• Example: k = 15 = 3×5 with 1 < 3,5 < 15.
• Therefore, (D) is true.

Conclusion: The true statements are (A), (C), and (D). Hence the correct option is Option 1.

Correct Answer: Option 3: E → A → B → C → D

The hierarchy of a layered file system in an operating system is organized as follows:

• E: Application Programs: These are the user-level programs that interact with the file system to perform operations like reading, writing, or modifying files. They are the topmost layer.
• A: Logical File System: This layer manages metadata, file names, and directories. It provides the interface for file operations and ensures logical organization.
• B: File Organization Module: This module handles the organization of files and directories within the storage medium. It manages the structure and placement of data on the disk.
• C: Basic File System: This layer is responsible for reading and writing blocks of data to and from the physical storage medium. It provides a basic interface for accessing data.
• D: I/O Control: This is the lowest layer, responsible for interfacing with hardware devices like disk controllers and handling device-specific operations.

Hence, the correct hierarchy is:

E → A → B → C → D

Key Points

• The layered file system structure ensures modularity, making it easier to debug and maintain.
• Each layer has a distinct responsibility and interacts with the layer above and below it.

Additional Information

• The Logical File System is responsible for maintaining consistency, such as ensuring file permissions and access control.
• The I/O Control layer interacts directly with hardware and is critical for physical data transfer.

Hence, the correct answer is: Option 3: E → A → B → C → D

Statement: The Correct answer is option 2: C → A → D → B

Explanation of each step:

Step C: Calculate fitness of each member of the population

• The first step in the Genetic Algorithm process is to evaluate the fitness of each member in the population. Fitness is a measure of how well a solution satisfies the objective function or problem requirements.
• This allows the algorithm to determine the quality of the solutions and decide which ones will move forward into the next generation.
• Fitness calculation is crucial as it guides the selection of parents for reproduction.

Step A: Select a pair of parents from the population

• Once the fitness of each member is calculated, the next step is to select parents for reproduction. Parents are selected based on their fitness scores, with fitter individuals having a higher probability of being chosen.
• Selection methods include roulette wheel selection, tournament selection, or rank-based selection.
• The goal is to ensure that better solutions contribute more to the next generation, while still maintaining diversity in the population.

Step D: Apply crossover with probability pc to form offsprings

• After selecting the parents, crossover is applied to combine their genetic material and produce offspring. This step mimics reproduction in biological systems.
• Crossover is performed with a certain probability (pc) and involves swapping segments of genetic material between parent chromosomes.
• It is used to explore the search space and create new solutions by combining the characteristics of the parents.

Step B: Apply mutation at each locus with probability pm

• Mutation is applied to the offspring with a certain probability (pm). It introduces random changes in the genetic material to maintain diversity in the population and avoid premature convergence.
• Mutation ensures that new areas of the search space are explored, which can lead to discovering better solutions.
• It typically involves flipping bits, swapping values, or making minor alterations in the solution representation.

Thus, the correct order of steps in the Genetic Algorithm process is: C → A → D → B.

The correct answer is Option 2) A, B and D Only

Key Points

• Controlled-access protocols: Controlled-access protocols are mechanisms used in networking to ensure that only one device transmits at a time on a shared communication medium. Such protocols prevent collisions and ensure orderly communication.
• Reservation: ✅ Reservation is a controlled-access protocol where a station reserves the right to use the medium in advance. This avoids collisions and ensures that the reserved station gets exclusive access during its turn.
• Polling: ✅ Polling is a controlled-access protocol where a primary station controls access to the medium. It polls secondary stations one at a time to check if they have data to send, ensuring orderly communication.
• TDMA: ❌ Time Division Multiple Access (TDMA) is not a controlled-access protocol. It is a channel access method that divides the channel into time slots, assigning each user a specific time slot. It is not dynamically controlled during transmission.
• Token Passing: ✅ Token Passing is a controlled-access protocol where a token circulates in the network. A station can transmit only when it holds the token, ensuring controlled access to the medium.
• CSMA/CA: ❌ Carrier Sense Multiple Access with Collision Avoidance (CSMA/CA) is not a controlled-access protocol. It is a contention-based protocol where devices compete for access to the medium, and collisions are avoided using backoff mechanisms.

Additional Information

• Controlled-access protocols: These protocols are efficient in preventing collisions but may introduce some delay due to the need for control mechanisms like polling or token passing.
• Contention-based protocols: Protocols like CSMA/CA are simpler to implement but may lead to collisions, especially in high-traffic networks.

Hence, the correct answer is: Option 2) A, B and D Only

Statement: The Correct answer is Option 1 : A→IV, B→III, C→I, D→II

Below is the detailed explanation of each option:

A. RAID Level 2 → IV. Memory style error correcting code (ECC)

RAID 2 is unique because it uses bit-level stripping and stores error-correction information (usually Hamming code) on multiple dedicated parity disks. This is exactly how ECC memory works in RAM, which is why it is called "Memory style error correcting code organization." It is rarely used today because modern disks handle their own error correction.

B. RAID Level 3 → III. Bit interleaved parity

In RAID 3, data is stripped at the bit level across data disks, and a single dedicated disk is used to store parity information. Because it accesses all disks for every single read/write to gather bits, it is known as "Bit interleaved parity."

C. RAID Level 5 → I. Block interleaved distribution parity

RAID 5 is the most common professional configuration. It strips data at the block level (not bit level) and, crucially, it does not use a dedicated parity disk. Instead, it distributes the parity across all disks in the array. This prevents the "bottleneck" of a single parity disk. Hence, "Block interleaved distribution parity."

D. RAID Level 6 → II. Also known as P+Q redundancy Scheme

RAID 6 is an extension of RAID 5 but provides higher fault tolerance. It uses two different parity functions (often called P and Q) for every block of data. This "double parity" allows the system to continue functioning even if two disks fail simultaneously. This is why it is specifically called the "P+Q redundancy scheme."

Matching Summary Table

The correct answer is: Option 3

Key Points

• Parsers are used to analyze the structure of a given input based on a set of grammatical rules.
• The question asks to arrange the given parsers in increasing order of their power of handling grammars.
• The power of a parser depends on the type of grammars it can handle, with more powerful parsers capable of handling a broader set of grammars.

Explanation

Let us examine each parser:

1. LL(0): LL(0) parsers are the least powerful. They can handle only a limited set of grammars (left-to-right parsing and no lookahead).
2. LR(0): LR(0) parsers are more powerful than LL(0) parsers, as they can handle a larger set of grammars. They perform bottom-up parsing.
3. SLR: SLR (Simple LR) parsers are an improvement over LR(0) parsers, as they use follow sets to resolve conflicts.
4. LALR(1): LALR(1) parsers (Look-Ahead LR) further extend SLR parsers, handling an even larger set of grammars.
5. LR(1): LR(1) parsers are the most powerful among the given parsers, as they use one token lookahead and can handle the largest set of grammars.

Final Order

Arranging the parsers in increasing order of their power:

LL(0) → LR(0) → SLR → LALR(1) → LR(1)

Correct Answer

The correct answer is: Option 3

The correct answer is Mapping

Key Points

• Mapping: ✅ Mapping refers to the process of transferring data from main memory to cache memory in a structured way. It ensures that specific blocks of memory are assigned to cache lines for faster access.
• Data exchange: ❌ Data exchange refers to the general transfer of data between two systems or components, not specifically between main memory and cache memory.
• Data transformation: ❌ Data transformation involves changing the format or structure of data, which is not relevant to this context.
• Matching: ❌ Matching refers to comparing data or finding similarities, which is not applicable to the memory transfer process.

Additional Information

• Cache Mapping Techniques: Common techniques include direct mapping, associative mapping, and set-associative mapping.
• Purpose: Mapping helps optimize data access speed by ensuring that frequently used data is stored in faster cache memory.
• Efficiency: Proper mapping reduces latency and improves the overall performance of the system.

Hence, the correct answer is: option 3) Mapping

The correct answer is: Option 1

Problem recap: Choose the correct statement about a group G (group operation written multiplicatively).

Why Option 1 is true – “If for all x, y ∈ G, (xy)² = x²y² then G is commutative.”

• Expand both sides using the group operation:

(xy)^2 = xyxy and x^2y^2 = xxyy.

• Given equality: xyxy = xxyy.
• Left–multiply by x^{-1} (possible in a group):

x^{-1}(xyxy) = x^{-1}(xxyy) ⇒ yxy = xyy.

• Right–multiply by y^{-1}:

(yxy)y^{-1} = (xyy)y^{-1} ⇒ yx = xy.

• This holds for all x,y ∈ G, hence G is abelian (commutative).

Why the other options are false

Option 2 – “If for all x ∈ G, x³ = 1, then G is commutative. 1 is the identity element of G.”

• There exist non-abelian groups in which every element has order dividing 3 (exponent 3). Example: the group of 3×3 upper-triangular matrices with 1s on the diagonal over the field ℤ/3ℤ (often written UT₃(3)). In this group, each element satisfies A^3 = I but the group is not abelian (take two elementary matrices; they do not commute).
• So “G is commutative” is false. (Also, writing the identity as “1” is just a notation; the statement as a whole is not correct.)

Option 3 – “If for all x ∈ G, x⁵ = 1, then G is commutative. 1 is the identity element of G.”

• Similarly false: there are non-abelian groups of exponent 5, e.g., the 3×3 upper-unitriangular matrices over ℤ/5ℤ (UT₃(5)). Every element satisfies A^5 = I, but the group is non-abelian.

Option 4 – “If G is commutative, the subgroup of G need not be commutative.”

• False. Any subgroup H ≤ G of an abelian group is abelian: for any a,b ∈ H, since ab = ba in G, the same equality holds in H.

Conclusion: Only Option 1 is correct; therefore the answer is Option 1.

The Correct answer is Option 2

Key Points

Gray code equivalent to decimal number 8 is:

• Gray code is a binary numeral system where two successive values differ in only one bit.
• The decimal number 8 in binary is represented as 1000. To convert it into Gray code:
• The most significant bit (MSB) of the Gray code is the same as the binary representation MSB. So, the MSB remains 1.
• For the subsequent bits, each bit of the Gray code is obtained by XORing the corresponding binary bit with the bit before it. Following this method for 8 (1000 in binary), we get:
• • MSB = 1
• Second bit = 1 XOR 0 = 1
• Third bit = 0 XOR 0 = 0
• Fourth bit = 0 XOR 0 = 0
• Thus, the Gray code for 8 becomes 1100.

Option 1: 1000:

• This is the binary representation of the decimal number 8, not its Gray code equivalent.
• Gray code differs from binary representation in that two successive values differ by only one bit.

Option 2: 1100:

• This is the correct Gray code equivalent of the decimal number 8.
• Following the conversion steps described above, the decimal number 8 (1000 in binary) converts to 1100 in Gray code.

Option 3: 1010:

• This is not the correct Gray code for 8.
• It does not follow the rule of successive bits differing by only one bit, which is a requirement for Gray code.

Option 4: 1110:

• This is also incorrect.
• While it starts with the correct MSB (1), the subsequent bits do not match the XOR operation required for Gray code conversion.

The correct answer is: Option 4

Key Points

Goal of the question

• You are given a DFA (deterministic finite automaton) over Σ = {a, b, c}.
• You must choose which of the proposed NFAs (nondeterministic FAs) is a valid one for the same language—that is, it accepts exactly the strings accepted by the DFA.
• Remember: every DFA is already an NFA. So a candidate NFA is valid iff, after accounting for any ε-moves, it reproduces the DFA’s effect for each input symbol from each state.

How to check that an NFA is equivalent to a given DFA

1. Read the DFA diagram and write its transition function δ_DFA(q, σ) for every state q and symbol σ ∈ {a, b, c} (each pair has exactly one target because it is a DFA).
2. For a candidate NFA, compute the set of states reachable in one step on symbol σ from q, allowing an optional ε-closure before and after reading σ:

Reach_NFA(q, σ) = ε-closure( δ_NFA( ε-closure(q), σ ) )

The NFA is valid iff this set is exactly { δ_DFA(q, σ) } for all pairs (q, σ). 3. ε-arcs are allowed, but they must not introduce any extra consuming transitions on a, b, or c that the DFA does not have.

Why Option 4 is valid

• Option 4 preserves all the symbol-labelled moves of the DFA (the a, b, c arrows agree with the DFA diagram).
• It adds only ε-moves from accepting states to a common “sink-accept” node (q4 in the option), which does not change which strings are accepted:
• ε-moves do not consume input symbols.
• Introducing an ε-path after reaching an accepting configuration keeps the string accepted but does not accept any string that was previously rejected.
• Therefore, after taking ε-closures, the set of a/b/c successors from every state is identical to the DFA’s single successor. Hence the language is unchanged.

Why the other options are not valid

• Option 1: introduces a symbol-labelled edge that the DFA does not have (one of the a/b/c arrows goes to a different node than in the DFA). This changes δ(q, σ) and hence changes the language.
• Option 2: is missing a required symbol-labelled transition present in the DFA (one DFA arrow is not reproduced), so some strings accepted by the DFA become rejected by this NFA.
• Option 3: reverses/misplaces at least one labelled transition compared with the DFA, again altering δ(q, σ) and hence the language.

Takeaway

• To build a valid NFA from a DFA, keep all the DFA’s labelled transitions exactly as they are; you may add ε-moves (e.g., to merge accepting states), but they must not create new ways to consume a symbol that were not allowed by the DFA.
• Among the provided figures, only Option 4 respects these rules, so it is the correct choice.

The correct answer is 4) A, C and D Only

Key Points

• A. I/O request → Ready Queue? ❌ When a running process issues an I/O request, it becomes blocked for that I/O and moves to the Waiting/Blocked queue, not the Ready queue.
• B. Create subprocesses & wait ✅ A running process can fork/spawn subprocesses and then call a wait (e.g., wait()) to block until children terminate. This is a valid transition (Running → Waiting).
• C. Time slice expires → Waiting Queue? ❌ On time quantum expiry (preemption), the process is put back into the Ready queue, not the Waiting queue (since it isn’t waiting for any event/I/O).
• D. Interrupt arrival → Waiting Queue? ❌ An interrupt may preempt the running process, after which it normally goes to the Ready queue. It moves to the Waiting queue only if it explicitly blocks for an event/I/O.

Hence, the events that cannot occur as stated are A, C, and D.

The correct answer is Option 3) 30,000 bits

Key Ideas

• Bandwidth–delay product (BDP) is the amount of data that can be “in flight” on the link:

BDP = Bandwidth × Round-Trip Time (RTT)

• Bandwidth is given as 1 Mbps = 1,000,000 bits/second.
• “1 bit takes 30 ms to make a round trip” means the RTT = 30 ms = 0.03 s.

Step-by-step Calculation

1. Convert units: 30 ms → 0.03 s.
2. Apply the formula:

BDP = 1,000,000 (bits/s) × 0.03 (s) = 30,000 bits

Why this matters

• BDP tells you the pipeline capacity: to keep a 1 Mbps link fully busy, up to 30,000 bits can be on the wire before the first acknowledgement returns.
• In stop-and-wait, if the frame size is much smaller than the BDP, the link stays idle while waiting for ACKs, reducing utilization.

Why other options are incorrect

• 15,000 bits / 20,000 bits / 60,000 bits: These come from using the wrong time (half-RTT, some other value) or wrong bandwidth unit. The given RTT is 30 ms round trip, and the bandwidth is 1,000,000 bits/s, so only 30,000 bits fits the formula exactly.

The correct answer is Option 2) 2

Given code (formatted)

int x = 128, y = 110; do { if (x > y) x = x - y; else y = y - x; } while (x != y); printf("%d", x);

Key Points

• The loop implements the subtractive Euclidean algorithm for the greatest common divisor (GCD).
• At each step, the larger of x and y is reduced by the smaller. This preserves gcd(x, y).
• The loop stops when x == y; at that point both variables equal gcd(original x, original y).
• do { ... } while (x != y); ensures the body executes at least once.

Step-by-step dry run

End of loop

• Now x == y == 2, which equals gcd(128, 110).
• printf("%d", x); prints 2.

Important notes

• Because x and y stay positive and strictly decrease when unequal, the loop must terminate.
• Using repeated subtraction is equivalent to the usual Euclidean algorithm with modulo, just slower.

The Correct Answer is Option 3: A-II, B-III, C-IV, D-I

Explanation:

Option A: If the Indian team wins, then it is raining (Converse)

• The converse of a conditional statement reverses the hypothesis and the conclusion.
• Here, the original conditional statement is "If it is raining, then the Indian team wins."
• The converse would be "If the Indian team wins, then it is raining."
• Thus, Option A matches with II (Converse).

Option B: If the Indian team does not win, then it is not raining (Contrapositive)

• The contrapositive of a conditional statement negates both the hypothesis and the conclusion and swaps them.
• For the original statement "If it is raining, then the Indian team wins," the contrapositive is "If the Indian team does not win, then it is not raining."
• Thus, Option B matches with III (Contrapositive).

Option C: If it is raining, then the Indian team wins (Conditional)

• The conditional statement is the original form of the statement, where "If P, then Q" is retained.
• Here, "If it is raining, then the Indian team wins" is the original conditional statement.
• Thus, Option C matches with IV (Conditional).

Option D: If it is not raining, then the Indian team does not win (Inverse)

• The inverse of a conditional statement negates both the hypothesis and the conclusion.
• For the original statement "If it is raining, then the Indian team wins," the inverse is "If it is not raining, then the Indian team does not win."
• Thus, Option D matches with I (Inverse).

The Correct answer is Option 1

Explanation of each option:

A → III (Worst Individual):

• The "Worst Individual" criterion ensures that the entire population meets a minimum standard of fitness.
• By eliminating poorly performing individuals, this criterion guarantees a gradual improvement in the quality of solutions.
• Thus, "Worst Individual" is mapped to "Guarantees that the entire population to be of a minimum standard."

B → IV (Best Individual):

• The "Best Individual" criterion ensures that the algorithm converges faster by maintaining at least one best solution in the population.
• This guarantees that the search does not lose the best-performing solution during the evolutionary process.
• Thus, "Best Individual" is mapped to "Faster search convergence, guaranteeing at least one best solution."

C → II (Sum of Fitness):

• The "Sum of Fitness" criterion ensures that the total fitness of the population is within a specific range.
• This guarantees that virtually all individuals in the population will have fitness values that are competitive within a defined range.
• Thus, "Sum of Fitness" is mapped to "Guarantees that virtually all individuals in the population will be within a particular fitness range."

D → I (Median Fitness):

• The "Median Fitness" criterion ensures that at least half of the individuals in the population will have fitness values better than or equal to a specific convergence value.
• This criterion focuses on improving the overall quality of the population by ensuring that the majority of individuals perform reasonably well.
• Thus, "Median Fitness" is mapped to "At least half of the individuals will be better than or equal to the convergence value."

The correct answer is Option 3: Requires a dedicated path

Key Points

• Packet Switching: Packet switching is a method of data transmission where data is broken into smaller packets for efficient transfer.
• ✅ Data is broken into packets: In packet switching, the data is divided into smaller packets before transmission.
• ✅ Each packet may take a different route: Packets are transmitted independently, potentially taking different routes to the destination.
• ✅ Supports dynamic routing: Packet switching can dynamically adjust routes based on network conditions.
• ❌ Requires a dedicated path: This is not a characteristic of packet switching. Dedicated paths are required in circuit switching (e.g., traditional telephone systems), not packet switching.

Additional Information

• Efficiency: Packet switching is more efficient than circuit switching, as it allows multiple users to share the same network resources.
• Use Cases: Packet switching is used in modern networks, including the internet, where dynamic routing and shared resources are essential.

Hence, the correct answer is: Option 3: Requires a dedicated path

The correct answer is Sutherland-Cohen

Key Points

• Sutherland-Cohen: ✅ The Sutherland-Cohen algorithm is one of the most widely used techniques for line clipping in computer graphics. It is specifically designed to clip lines against a rectangular clipping window.
• Stack-based Seed: ❌ This is not a technique used for clipping. It is more relevant to seed fill algorithms for regions or polygons.
• Scan Line Seed: ❌ This refers to methods for filling polygons or areas rather than clipping.
• Inverse Scaling: ❌ This is related to scaling transformations in computer graphics and not directly applicable to clipping.

Additional Information

• Purpose of Clipping: Clipping is used in computer graphics to limit the rendering of objects to a defined region, typically the viewport or clipping window.
• Sutherland-Cohen Algorithm: It divides the clipping process into outcodes for the endpoints of the line and uses logical operations to determine the visibility of the line segment.
• Efficiency: The Sutherland-Cohen algorithm is efficient because it minimizes the number of calculations by rejecting or accepting lines outside or inside the clipping area early in the process.

Hence, the correct answer is: option 3) Sutherland-Cohen

The correct answer is option 4

Key Points

• Software does not wear out: ✅ Unlike hardware, software does not degrade physically over time. However, it can become outdated due to technological advancements.
• Software is flexible: ✅ Software can be modified to meet specific requirements, making it highly adaptable and versatile.
• Software is not manufactured: ✅ Software is developed, not manufactured, which means it is created through design and coding rather than physical production processes.
• Software is always correct: ❌ This is not true. Software can contain bugs or errors due to mistakes in design, coding, or testing.

Additional Information

• Software Quality: The correctness of software depends on thorough testing and the absence of bugs. Even with rigorous testing, it is possible for some errors to remain undetected.
• Reliability: While software can be highly reliable, it is not guaranteed to be always correct, as it depends on the quality of development and maintenance processes.

Hence, the correct answer is: option 4) Software is always correct

The correct answer is Option 3) A → IV, B → III, C → II, D → I

Match the operations to their standard fuzzy-set formulas

Why these matches are correct (easy explanations)

• Intersection (A → IV): In fuzzy logic, the “AND” of two memberships is the smaller of the two at each x. Hence min( μ̃_A, μ̃_B ).
• Bounded Sum (B → III): Sum the memberships but cap at 1 because membership cannot exceed 1. That is min(1, μ̃_A + μ̃_B).
• Bounded Difference (C → II): Subtract B from A but never go below 0 since membership cannot be negative. So max(0, μ̃_A − μ̃_B).
• Algebraic Sum (D → I): Also called the probabilistic OR; it ensures no double counting by subtracting the product: μ̃_A + μ̃_B − μ̃_A·μ̃_B.

Quick mnemonic

• min → Intersection (take the lesser overlap).
• min(1, sum) → Bounded Sum (sum but bounded by 1).
• max(0, difference) → Bounded Difference (difference but not below 0).
• sum − product → Algebraic Sum (probabilistic OR formula).

The correct answer is: Option 2

Key Points

• Step A: ✅ The hypervisor is first installed on the physical server. A hypervisor is software that allows the creation and management of virtual machines. It acts as the interface between the physical hardware and virtual machines.
• Step B: ✅ Virtual machines (VMs) are then created on the hypervisor. A virtual machine is an emulation of a computer system that runs on the physical server.
• Step C: ✅ Resources such as CPU, memory, storage, and network bandwidth are allocated to each virtual machine. These resources are divided and shared among the VMs as per requirements.
• Step D: ✅ Finally, the virtual machines run isolated workloads. Each VM operates independently, ensuring that workloads are isolated from one another.

Additional Information

• Hypervisor: There are two types of hypervisors:
• Type 1 (Bare-metal): Runs directly on the physical hardware.
• Type 2 (Hosted): Runs on a host operating system.
• Isolation: Virtual machines are isolated from one another, ensuring that issues in one VM do not affect others.
• Scalability: Virtualization allows for easy scalability by creating or removing VMs as needed.

Hence, the correct order of the process is: Option 2: A, B, C, D

The correct answer is Option 3) C, D, A, E, B

Key Points

Key Points (C operator precedence – higher → lower)

• Shift: <<, >> (left-to-right)
• Relational: <, <=, >, >= (left-to-right)
• Logical AND: && (left-to-right)
• Conditional: ?: (right-to-left)
• Assignment: =, +=, -=, … (right-to-left)

Mapping the given operators

• C. >> → Shift group (highest among the five)
• D. >= → Relational group
• A. && → Logical AND group
• E. ?: → Conditional operator
• B. += → Assignment group (lowest among the five)

Therefore, from higher to lower precedence: >> > >= > && > ?: > += which corresponds to C → D → A → E → B.

Quick sanity check

• In an expression like x >> 1 >= y && cond ? u : v += 3, the shift happens before the comparison, the comparison before &&, then the conditional ?:, and finally the assignment—consistent with the order above.