UGC NET CS Practice Set 10

Explanation: DDA increments x or y by 1 (whichever has the larger range) and calculates the other coordinate by adding the slope (or its reciprocal), which is a floating-point operation. The result is rounded to the nearest integer for pixel plotting. Bresenham's algorithm avoids this by using only integer arithmetic.

Explanation: Liang-Barsky uses the parametric form of the line: P(t) = P1 + t(P2 − P1), where 0 ≤ t ≤ 1. It computes t values for intersections with each clip boundary and determines the visible segment by finding the maximum entering t and minimum leaving t. It is more efficient than Cohen-Sutherland for most cases.

Explanation: Flat shading uses one normal per polygon face, giving a faceted appearance. Gouraud shading computes illumination at each vertex and interpolates the resulting colors across the polygon using bilinear interpolation during scan conversion. This produces a smoother appearance but can miss specular highlights.

Explanation: A Bezier curve of degree n defined by n+1 control points always passes through the first (P₀) and last (Pₙ) control points. The intermediate control points influence the shape but the curve generally does not pass through them. The curve lies within the convex hull of the control points.

Explanation: An abstract class contains at least one pure virtual function (in C++) or abstract method (in Java). It cannot be instantiated directly but can have concrete (implemented) methods. Subclasses must implement the abstract methods to be instantiable.

Explanation: Type coercion is automatic (implicit) type conversion performed by the compiler or interpreter (e.g., int to float in mixed expressions). Explicit type conversion (casting) is done by the programmer. Coercion can sometimes cause unexpected behavior or precision loss.

Explanation: (λx. x) takes an argument x and returns x unchanged — the identity function. It is the simplest lambda abstraction. The constant function would be (λx. λy. x), and the successor function in Church numerals is (λn. λf. λx. f (n f x)).

Explanation: Each function call pushes a new activation record (stack frame) onto the call stack, containing local variables, parameters, return address, and saved registers. The stack shrinks when the function returns and its frame is popped. Deep recursion can cause stack overflow.

Explanation: In call by value-result (copy-in/copy-out), the actual parameter's value is copied to the formal parameter at call time (like call by value), and the final value of the formal is copied back to the actual at return time. It can differ from call by reference when aliasing is involved.

Explanation: In perspective projection with the center of projection at the origin and the projection plane at z = d, a 3D point (x, y, z) projects to (x·d/z, y·d/z). The division by z creates the foreshortening effect — distant objects appear smaller.

Explanation: A weak entity depends on a strong (owner) entity for its identification. It has a partial key (discriminator) that, together with the primary key of the owner entity, forms its composite key. In ER diagrams, weak entities are shown with double rectangles.

Explanation: A two-process deadlock requires a circular wait: P1 holds resource R1 and requests R2 (held by P2), while P2 holds R2 and requests R1 (held by P1). Neither can proceed. All four Coffman conditions must hold.

Explanation: Peterson's algorithm provides mutual exclusion for two processes using shared variables (flag[0], flag[1], turn). It satisfies mutual exclusion, progress, and bounded waiting. For n processes, extensions like the filter lock or bakery algorithm are needed.

Explanation: The multilevel feedback queue has multiple queues with different priorities and possibly different scheduling algorithms. Processes can move between queues based on their CPU burst behavior: CPU-intensive processes are demoted to lower-priority queues. This adapts to process characteristics automatically.

Explanation: In segmented paging, the address has three parts: segment number (indexes the segment table to find the page table for that segment), page number (indexes that page table to find the physical frame), and offset within the page. This combines the logical view of segmentation with the physical efficiency of paging.

Explanation: An inode stores all metadata about a file: size, owner, group, permissions, timestamps (created, modified, accessed), link count, and pointers to the actual data blocks (direct, single/double/triple indirect pointers). The file name is stored in the directory entry, not the inode.

Explanation: A semaphore initialized to 1 acts as a binary semaphore (or mutex), allowing only one process/thread into the critical section. wait() decrements to 0 (lock), signal() increments back to 1 (unlock). A counting semaphore initialized to n allows up to n concurrent accesses.

Explanation: The Optimal (OPT/MIN/Belady's) algorithm replaces the page that will not be used for the longest time in the future. It produces the minimum possible number of page faults but requires future knowledge, making it impractical. It serves as a benchmark for comparing other algorithms.

Explanation: TDD follows the Red-Green-Refactor cycle: (1) Red — write a test that fails, (2) Green — write the minimum code to make the test pass, (3) Refactor — improve the code while keeping tests green. This ensures all code is covered by tests.

Explanation: Risk management involves: (1) Risk identification — listing potential risks, (2) Risk analysis — assessing probability and impact, (3) Risk prioritization — ranking by severity, (4) Risk mitigation — developing strategies (avoidance, transfer, reduction, acceptance), and (5) Risk monitoring — tracking throughout the project.

Explanation: Technical debt is the accumulated cost of shortcuts, quick fixes, and suboptimal design decisions. Like financial debt, it accrues 'interest' — future development becomes slower and more expensive. Refactoring 'pays down' the debt.

Explanation: SVM finds the hyperplane that maximizes the margin (distance) between the nearest data points of different classes (support vectors). For non-linearly separable data, the kernel trick maps data to a higher-dimensional space. SVMs have strong theoretical foundations (structural risk minimization).

Explanation: The vanishing gradient problem occurs when gradients become exponentially small as they are backpropagated through many layers with sigmoid or tanh activations (whose derivatives are < 1). This makes early layers learn very slowly. ReLU (f(x)=max(0,x)) mitigates this because its derivative is 1 for positive inputs.

Explanation: In STRIPS (Stanford Research Institute Problem Solver), an action is defined by: (1) Preconditions — conditions that must be true to apply the action, (2) Add list — facts that become true after the action, (3) Delete list — facts that become false. This enables forward and backward state-space search.

Explanation: Feature engineering involves creating new features from raw data (e.g., extracting day of week from a timestamp), selecting relevant features (removing noise), and transforming features (normalization, encoding). Good features are often more important than the choice of algorithm.

Explanation: Terminal nodes in a game tree are assigned utility values representing the payoff for the maximizing player (e.g., +1 for win, 0 for draw, −1 for loss in chess). The minimax algorithm propagates these values up: MAX nodes take the maximum of children, MIN nodes take the minimum.

Explanation: Uniform cost search (UCS) expands the node with the lowest cumulative path cost g(n) from the start node. It is optimal and complete for non-negative costs. It is equivalent to Dijkstra's algorithm and to A* with h(n)=0. BFS is a special case when all step costs are equal.

Explanation: The XOR swap works because XOR is self-inverse: (1) R1 ← R1⊕R2, (2) R2 ← R1⊕R2 = (R1⊕R2)⊕R2 = R1, (3) R1 ← R1⊕R2 = (R1⊕R2)⊕R1 = R2. No temporary variable needed. Note: option C (addition/subtraction) also works but can overflow.

Explanation: This is describing FIFO, which is subject to Belady's anomaly — a counterintuitive situation where increasing the number of page frames can increase the number of page faults. Stack algorithms (LRU, Optimal) are immune to this anomaly because their page sets are nested.

Explanation: In the readers-writers problem, multiple readers can read simultaneously (read operations don't conflict). However, a writer needs exclusive access — no other readers or writers may be active. Solutions must prevent starvation: the first readers-writers problem may starve writers, the second may starve readers.

Explanation: BCNF decomposition always produces a lossless join but may not preserve all functional dependencies. 3NF decomposition can always achieve both lossless join AND dependency preservation. BCNF is stronger (every FD has a superkey on the left). 4NF addresses multi-valued dependencies.

Explanation: COALESCE(expr1, expr2, ..., exprN) evaluates the expressions left to right and returns the first non-NULL value. It is equivalent to a searched CASE expression. Common use: COALESCE(phone, email, 'N/A') provides a fallback chain.

Explanation: A decomposition of R into R1 and R2 is lossless if and only if the common attributes (R1 ∩ R2) form a superkey for either R1 or R2. This is the necessary and sufficient condition. R1 ∪ R2 = R is necessary but not sufficient.