Sasken Assessment - MCQ Practice Bank

✅ Answer: b) Undefined behavior. Double free corrupts the heap's memory management structures and can cause crashes or security vulnerabilities.

✅ Answer: c) int (*fp)(int); Parentheses around *fp are required; without them (int *fp(int)) it's a function returning int*, not a pointer to function.

✅ Answer: c) 1 2 3. static initializes count only once; it retains its incremented value across loop iterations.

✅ Answer: b) A pointer pointing to freed/deallocated memory. After free() or when a local variable goes out of scope, any pointer still referencing that memory becomes dangling.

✅ Answer: c) do-while. do-while checks the condition after executing the loop body, so the body always runs at least one time.

✅ Answer: b) Swaps a and b. Classic XOR swap trick — swaps values without a temporary variable, using properties of the XOR bitwise operator.

✅ Answer: b) Size of the largest member. A union allocates memory shared by all members; its size equals the largest member's size, aligned as needed.

✅ Answer: c) Undefined behavior/crash. String literals are stored in read-only memory; attempting to modify them causes undefined behavior (often a segfault).

✅ Answer: b) Hints to the compiler. register is only a suggestion; the compiler may ignore it, especially with modern optimizers. & cannot be used on register variables.

✅ Answer: b) 100331. Innermost printf(100) prints "100" (3 chars) and returns 3; next prints "3" and returns 1; outer prints "1" — total output "100" + "3" + "1" = "100331".

✅ Answer: b) calloc(10, sizeof(int)). Unlike malloc, calloc initializes all allocated bytes to zero, which malloc does not guarantee.

✅ Answer: c) Limited to the loop block. C99 allows declaration inside for(int i=0;...); the variable's scope is restricted to the loop.

✅ Answer: b) Pointer to an array of 5 ints. Parentheses bind * to arr first, meaning arr is a pointer, and it points to an array of 5 integers.

✅ Answer: b) Each call uses stack memory. Every recursive call pushes a new stack frame; deep recursion can cause stack overflow.

✅ Answer: b) 10 20. *p++ dereferences first (10), then increments pointer (postfix). Next *p accesses the now-incremented pointer → 20.

✅ Answer: b) stdlib.h. malloc, calloc, realloc, and free are declared in stdlib.h.

✅ Answer: b) Allocated memory that is never freed and becomes unreachable. If the last reference to allocated memory is lost without calling free(), that memory is leaked for the program's lifetime.

✅ Answer: b) Bit-field of 4 bits. Bit-fields restrict a member to a specific number of bits, used to pack data tightly (age can hold 0-15 in 4 bits).

✅ Answer: b) Evaluates all expressions left to right; result is last value. The comma operator evaluates each operand in sequence and yields the value of the rightmost operand.

✅ Answer: b) Array decays to a pointer. In C, arrays cannot be passed by value; the function receives a pointer to the first element, so sizeof inside the function gives pointer size, not array size.

✅ Answer: b) Runtime polymorphism. Virtual functions enable a base class pointer/reference to call the derived class's overridden method, resolved at runtime via the vtable.

✅ Answer: b) Only base destructor runs. Without a virtual destructor, deleting via a base pointer causes undefined behavior/resource leaks since the derived part isn't cleaned up.

✅ Answer: b) virtual void f() = 0; The = 0 syntax makes it pure virtual, forcing derived classes to implement it and making the base class abstract (non-instantiable).

✅ Answer: b) Losing derived-class data when assigned by value. Assigning Derived d; Base b = d; copies only the Base portion, "slicing off" derived members — a common polymorphism pitfall.

✅ Answer: b) Ambiguity from multiple inheritance. If classes B and C both inherit from A, and D inherits from both B and C, D gets two copies of A's members unless virtual inheritance is used.

✅ Answer: b) Complex operator+(Complex); Standard syntax for a member operator overload returns the appropriate type and uses the operator+ keyword form.

✅ Answer: b) unique_ptr = single ownership, shared_ptr = reference-counted shared ownership. unique_ptr cannot be copied (only moved); shared_ptr maintains a reference count and deletes the object when the count reaches zero.

✅ Answer: a) A B ~B ~A. Construction order goes base-to-derived (A then B); destruction is reverse — derived-to-base (~B then ~A).

✅ Answer: b) Grants access to private/protected members. A friend function/class isn't a member but can access the class's private and protected data — breaks strict encapsulation for specific cases.

✅ Answer: c) unordered_map. unordered_map uses a hash table (O(1) average); map uses a red-black tree (O(log n)) — a common point of confusion.

✅ Answer: b) Overriding = runtime, same signature; Overloading = compile-time, different params. Overriding requires an identical signature in derived class with virtual in base; overloading involves different parameter lists in the same scope.

✅ Answer: b) A pointer to the object invoking the member function. this is implicitly passed to non-static member functions and points to the calling object's memory address.

✅ Answer: b) Derived. Since show() is virtual, the call is resolved at runtime based on the actual object type (Derived), not the pointer type — dynamic dispatch.

✅ Answer: b) Initializing members before constructor body executes. const and reference members MUST be initialized in the init list since they can't be assigned in the constructor body.

✅ Answer: b) Enable compile-time generic programming. Templates let you write type-independent code; the compiler generates specific versions for each type used (unlike macros, they're type-safe).

✅ Answer: b) std::terminate() is called. An uncaught exception propagates up the call stack; if it reaches the top uncaught, std::terminate() aborts the program.

✅ Answer: b) new/delete call constructors/destructors. new allocates memory AND invokes the constructor; malloc only allocates raw memory with no object initialization.

✅ Answer: b) Base class version is used. If not overridden, calling through a base pointer/reference invokes the inherited base implementation.

✅ Answer: b) Shared across all objects (single copy). A static member belongs to the class, not any instance — all objects share the same copy, and it must be defined outside the class too.

✅ Answer: b) Creating a new object as a copy of an existing object. Triggered when an object is passed/returned by value, or explicitly copy-initialized — e.g. A a2 = a1;.

✅ Answer: b) 20. A reference is an alias for the same memory location; modifying ref directly modifies x.

✅ Answer: c) set. std::set is implemented as a self-balancing BST (red-black tree), keeping elements sorted by key automatically.

✅ Answer: b) The diamond problem. Declaring inheritance as virtual ensures only one shared instance of the common base class exists in the derived object.

✅ Answer: b) Function cannot modify member variables. A const member function promises not to alter the object's state, and can be called on const object instances.

✅ Answer: a) A::print. Since print() is NOT virtual, the call is resolved at compile time based on pointer type (A), not object type — static binding.

✅ Answer: b) Avoiding naming conflicts. Namespaces logically group code and prevent identifier clashes, especially when combining multiple libraries.

✅ Answer: b) Transferring resources from temporary objects efficiently. std::move and move constructors "steal" resources (like heap pointers) from rvalues instead of deep-copying, improving performance.

✅ Answer: c) protected. protected members are accessible within the class itself and any derived class, but not from outside the class hierarchy.

✅ Answer: b) 1. C++ mandates that every object have a unique address, so even an empty class occupies a minimum of 1 byte.

✅ Answer: b) Prevents implicit type conversions. Without explicit, a single-argument constructor can be used for implicit conversions (e.g. passing an int where the class type is expected), which explicit blocks.

✅ Answer: b) O(log n). Each comparison halves the search space, giving logarithmic time complexity.

✅ Answer: c) O(n²). Worst case occurs with poor pivot selection (e.g. already sorted array with first/last element as pivot), causing unbalanced partitions.

✅ Answer: b) Floyd's cycle detection. Two pointers move at different speeds (1x and 2x); if they meet, a cycle exists — also called the "tortoise and hare" algorithm.

✅ Answer: c) O(n). Merge sort requires additional array space proportional to n for the merging process, unlike in-place sorts like quicksort/heapsort.

✅ Answer: b) Root. A min-heap maintains the heap property where every parent is ≤ its children, so the smallest element is always at the root.

✅ Answer: c) O(1). With a good hash function and low load factor, insertion/lookup in a hash table is O(1) on average, though O(n) worst case with many collisions.

✅ Answer: b) Inorder. Inorder traversal (left-root-right) visits nodes of a BST in ascending sorted order, due to BST ordering property.

✅ Answer: b) Stack. Undo requires reversing the most recent action first — LIFO (Last In First Out) behavior, exactly what a stack provides.

✅ Answer: b) O(E log V). With a min-heap, each edge relaxation takes O(log V), giving O(E log V) for E edges — more efficient than the O(V²) naive implementation.

✅ Answer: c) Merge Sort. Merge Sort guarantees O(n log n) in all cases and preserves the relative order of equal elements (stability); Quick/Heap sort aren't stable by default.

✅ Answer: b) Efficiently processing contiguous subarrays/substrings. Instead of recomputing from scratch, the window "slides" by adjusting boundaries, reducing time complexity from O(n²) or O(n·k) to O(n) for many problems.

✅ Answer: b) Maximum subarray sum. Kadane's algorithm finds the maximum sum contiguous subarray in O(n) time using dynamic programming principles.

✅ Answer: b) O(log n). A balanced BST (like AVL) maintains height proportional to log n, ensuring O(log n) search/insert/delete operations.

✅ Answer: b) Stack (call stack). Each function call pushes a stack frame (local vars, return address); returning pops it — recursion depth is limited by stack size.

✅ Answer: b) Time complexity of divide-and-conquer recurrences. Master theorem provides a direct formula to solve recurrences of the form T(n) = aT(n/b) + f(n), common in algorithms like merge sort.

✅ Answer: b) O(n). Though a single heapify is O(log n), building the entire heap bottom-up is O(n) total due to amortized analysis of heapify calls at different heights.

✅ Answer: b) Allows traversal in both directions. Each node has both next and prev pointers, enabling backward traversal — at the cost of extra memory per node.

✅ Answer: b) Hash map to store complements. Storing seen values in a hash map allows O(1) lookup for the complement (target - current), achieving O(n) overall instead of O(n²).

✅ Answer: b) Directed Acyclic Graphs (DAG) only. Topological sort orders vertices such that for every directed edge u→v, u comes before v — only meaningful/possible for DAGs (no cycles).

✅ Answer: c) Nearly O(1) amortized. With both optimizations, operations run in inverse Ackermann time α(n), which is effectively constant for all practical input sizes.

✅ Answer: b) 2i+1. For 0-indexed array-based heaps, left child = 2i+1, right child = 2i+2, parent = (i-1)/2.

✅ Answer: b) O(m). Trie search follows the path character by character, independent of the number of stored words — depends only on word length m.

✅ Answer: b) Finding the deepest common ancestor node. In a BST, LCA can be found in O(h) by comparing node values against the root and moving left/right accordingly, using BST ordering.

✅ Answer: b) Page faults increasing with more frames (FIFO). Counter-intuitively, in FIFO page replacement, adding more frames can sometimes increase page faults — this doesn't happen with LRU/Optimal.

✅ Answer: b) O(1) amortized. Though occasional resizing takes O(n), doubling strategy means the average cost per insertion over many operations is O(1).

✅ Answer: b) Backtracking. N-Queens explores placements recursively, "backing off" (undoing choices) whenever a placement leads to a conflict — classic backtracking.

✅ Answer: b) O(n log n). By the Master Theorem (case 2), a=2, b=2, f(n)=O(n) matches n^(log_b a) = n, giving T(n) = O(n log n).

✅ Answer: b) BFS = queue, level-by-level; DFS = stack/recursion, depth-first. BFS explores all neighbors before going deeper (good for shortest path in unweighted graphs); DFS explores as deep as possible before backtracking.

✅ Answer: b) Same subproblems solved multiple times. DP exploits this by caching (memoizing) results of subproblems so they're computed once, drastically reducing time complexity (e.g. Fibonacci).

✅ Answer: b) O(log n). Removing the root requires replacing it with the last element and "sifting down" to restore heap property — takes O(log n) for a heap of height log n.

✅ Answer: b) Efficient reuse of freed space. In a linear queue, dequeued space at the front can't be reused; a circular queue wraps around, utilizing all allocated slots.

✅ Answer: b) O(V) in the worst case. The explicit stack can hold up to all vertices in the worst case (e.g. a skewed graph structure), giving O(V) space.

✅ Answer: b) Make locally optimal choice at each step. Greedy algorithms don't reconsider previous choices; they work correctly only for problems exhibiting the "greedy choice property" (e.g. activity selection, Huffman coding).

✅ Answer: b) O(n). With an early-exit flag checking if any swaps occurred, an already-sorted array requires just one pass, giving O(n) best case.

✅ Answer: b) Sorts using O(1) extra space. In-place algorithms (e.g. quicksort, heapsort) rearrange elements within the original array without significant additional memory (unlike merge sort).

✅ Answer: b) Efficient range queries and updates. Segment trees allow both range queries and point/range updates in O(log n), much faster than O(n) naive approaches for repeated queries.

✅ Answer: c) O(n). If all elements collide into one bucket (implemented as a list), insertion/search degrades to O(n) linear time in the worst case.

✅ Answer: b) Level order specifically requires a queue. A queue's FIFO nature ensures nodes are processed in the order they were discovered (level by level); a stack (LIFO) would give a different (DFS-like) order.

✅ Answer: b) Maximum value achievable using first i items with weight capacity w. This is the standard DP table definition; each cell is built from including/excluding the current item, based on prior subproblem results.

✅ Answer: b) BST: O(log n), Hash table: O(1) average. Hash tables offer faster average lookup but no ordering; BSTs are slightly slower but maintain sorted order, enabling range queries.

✅ Answer: b) Threads share address space; processes have separate memory. Multiple threads within a process share code, data, and heap segments but have their own stack and registers — enabling lightweight concurrency.

✅ Answer: c) Priority Scheduling (without aging). Low-priority processes may never execute if higher-priority processes keep arriving; "aging" (gradually increasing priority) fixes this.

✅ Answer: b) Mutual exclusion, hold and wait, no preemption, circular wait. ALL four conditions must hold simultaneously for deadlock to occur; breaking even one prevents deadlock.

✅ Answer: b) Mutex has ownership restriction; semaphore doesn't (and can count > 1). A mutex is a locking mechanism owned by the locking thread; a counting semaphore can manage multiple resource instances and be signaled by any thread.

✅ Answer: b) Excessive page faults causing more time paging than executing. Occurs when processes don't have enough frames, leading to constant page swapping and severely degraded performance.

✅ Answer: c) Optimal (Belady's algorithm). It replaces the page that won't be used for the longest time in the future — requires future knowledge, so it's used only as a theoretical benchmark.

✅ Answer: b) Internal = wasted space within a block; External = scattered free space between blocks. Internal fragmentation occurs in fixed-size allocation (e.g. paging); external fragmentation occurs in variable-size allocation (e.g. segmentation), needing compaction.

✅ Answer: b) Outcome depends on timing/order of concurrent access to shared data. Without proper synchronization, concurrent read-modify-write operations on shared data can produce inconsistent/incorrect results.

✅ Answer: b) Deadlock avoidance via safe state checking. Before granting a resource request, it simulates allocation to ensure the system remains in a "safe state" where all processes can still complete.

✅ Answer: b) Paging = fixed-size blocks; Segmentation = variable-size logical units. Paging eliminates external fragmentation but has internal fragmentation; segmentation matches logical program structure but can suffer external fragmentation.

✅ Answer: b) Semaphores (empty/full) plus a mutex. empty and full semaphores track available slots/items, while a mutex ensures mutual exclusion during buffer access — classic synchronization pattern.

✅ Answer: b) Caches virtual-to-physical address translations. Without TLB, every memory access requires a page table lookup (extra memory access); TLB hit avoids this, significantly speeding up address translation.

✅ Answer: b) Terminated process whose exit status hasn't been read by parent. The process has finished execution but remains in the process table until the parent calls wait() to read its exit status.

✅ Answer: b) A process whose parent terminated first, gets adopted by init. When a parent dies before its child, the orphaned child is re-parented to the init process (PID 1), which reaps it upon completion.

✅ Answer: b) SSTF. SSTF selects the request nearest to the current head position, minimizing immediate seek time (but can cause starvation for far requests).

✅ Answer: b) Head moves in one direction until the end, then reverses. Like an elevator, it services all requests in one direction, reaches the end, then reverses — providing more uniform wait times than SSTF.

✅ Answer: b) Saving/restoring process state. The CPU must save the current process's context and load the next process's context — this switching itself consumes CPU time without doing useful work.

✅ Answer: b) Preemptive can interrupt; non-preemptive runs to completion. Preemptive scheduling (e.g. Round Robin) allows the OS to forcibly switch processes; non-preemptive (e.g. FCFS) waits for the process to yield or finish.

✅ Answer: b) Classic synchronization problems. Both are canonical problems used to study and demonstrate solutions (semaphores, monitors) for concurrent resource-sharing issues like deadlock and starvation.

✅ Answer: b) Loading pages only when referenced. Reduces memory usage and startup time by deferring page loads until a page fault occurs, following the principle of lazy loading.

✅ Answer: b) Multiprogramming maximizes CPU use; Multitasking gives illusion of concurrent execution. Multiprogramming focuses on keeping CPU busy by having jobs ready; multitasking emphasizes responsive time-sharing among users/tasks.

✅ Answer: b) Lower-priority process blocks a higher-priority one via a shared resource. Solved using priority inheritance protocols, where the lower-priority process temporarily inherits higher priority to finish quickly and release the resource.

✅ Answer: b) fork(). fork() creates a near-identical copy (child) of the calling process; it returns 0 in the child and the child's PID in the parent.

✅ Answer: b) Replaces the current process's memory image with a new program. Commonly used together — fork() creates a child, then exec() loads a new program into that child's memory space (e.g. shell launching commands).

✅ Answer: b) Pipes = unstructured byte stream (related processes); message queues = structured discrete messages. Pipes are simpler and typically limited to parent-child/related processes; message queues offer more structure and flexibility for IPC.

✅ Answer: b) Deterministic, guaranteed response time within strict deadlines. RTOS prioritizes predictability and meeting hard/soft deadlines over overall throughput, critical for embedded/automotive systems.

✅ Answer: b) CPU switches from user mode to kernel mode. System calls are the interface for user programs to request OS services (file I/O, process control); this requires elevated (kernel) privileges.

✅ Answer: b) Buffering I/O so fast devices don't wait for slow ones. SPOOL (Simultaneous Peripheral Operations On-Line) queues jobs (like print requests) on disk, letting the CPU continue without waiting for the slow device.

✅ Answer: b) Starvation = indefinite wait (system still progresses); Deadlock = no progress at all. In starvation, other processes continue executing while one is perpetually postponed; in deadlock, ALL involved processes are permanently blocked.

✅ Answer: b) Loads the OS kernel into memory and transfers control. The bootloader (e.g. GRUB) reads the kernel image from disk into RAM and jumps to its entry point, initiating OS startup.

✅ Answer: b) Best Fit. Best Fit picks the smallest block that can satisfy the request, but this often creates many small unusable leftover fragments over time.

✅ Answer: b) Quickly breaks large blocks, causing fragmentation despite its intent. Ironically, by always choosing the largest block, Worst Fit tends to leave usable leftover fragments initially, but performs poorly overall compared to First/Best Fit in practice.

✅ Answer: b) Code segment accessing shared resources needing mutual exclusion. Only one process/thread should execute in its critical section at a time regarding a specific shared resource, enforced via locks/semaphores/monitors.

✅ Answer: b) A high-level synchronization construct with built-in mutual exclusion. Monitors bundle shared data, procedures, and synchronization logic (condition variables for wait/signal) into a single, easier-to-use abstraction than raw semaphores.

✅ Answer: b) Lower overhead and easier data sharing than multiple processes. Threads share the process's address space, so creating/switching threads is cheaper than processes, and communication doesn't need IPC mechanisms.

✅ Answer: b) Moving an entire process between main memory and disk. Used to handle situations where physical memory is insufficient; a process is temporarily moved out to swap space and brought back in later.

✅ Answer: b) Tendency to access nearby/repeated memory locations, exploited by caching. Temporal locality (reusing recent data) and spatial locality (nearby addresses) are why caches significantly speed up average memory access time.

✅ Answer: b) Excessive context-switching overhead. Too small a quantum causes the OS to spend a disproportionate amount of time switching contexts rather than doing actual process work.

✅ Answer: b) Kernel threads are OS-managed; user threads are library-managed. Kernel threads can be scheduled on multiple cores and don't block the whole process on a syscall, but have higher creation/switching overhead than user threads.

✅ Answer: b) Signal CPU about an event needing immediate attention. Interrupts allow asynchronous handling of events (like I/O completion) without the CPU having to continuously poll devices — the CPU saves state, handles the interrupt, then resumes.