202 questions from 18 interviews · updated from reports 2012-2025
About
Nvidia designs graphics processors, system-on-chip hardware, and related software used in gaming, data centers, artificial intelligence, visualization, and automotive systems. In India, it commonly hires Software Engineers, System Software Engineers, and System Software Engineer Interns for low-level systems, drivers, CUDA, and platform software.
The roles that come up most are Software Engineer, System Software Engineer Intern and System Software Engineer. This covers 18 candidate interviews reported from 2012 to 2025. The largest group sat it at internship level (7 of 16 that recorded a level). Among the 13 that recorded either route, arrivals split between campus drives (7, 54%) and off-campus applications (6, 46%). Most questions fall under CS fundamentals and DSA.
Ans. Synchronise CUDA threads within a block using __syncthreads(), which acts as a barrier until all threads in that block reach it. It also makes shared memory writes visible to those threads. Threads in different blocks cannot normally synchronise inside one kernel, so use separate kernel launches or supported cooperative groups for grid-wide synchronisation.
Ans. Virtual functions support runtime polymorphism, inheritance lets a class reuse or extend another class, constructors initialise objects, and static variables belong to a class or scope rather than each object. The key detail is lifetime and binding: constructors run on creation, virtual calls resolve by actual object type, and static storage is shared.
Ans. Take any 10 coins and flip every coin in that group. If the 10 chosen coins originally contain k heads, then they contain 10 minus k tails. After flipping, that group has 10 minus k heads. The remaining 90 coins also have 10 minus k heads, so the two groups match.
Ans. Sort the array and greedily match each small value with the smallest possible larger value. Use two pointers: one scans values to be beaten, the other scans candidate larger values. When nums[j] is greater than nums[i], count one match and move both; otherwise move only j. This maximises matches in O(n log n) time.
Ans. Computer memory stores data and instructions as bits, grouped into bytes, each with an address the CPU can read from or write to. The key idea is the memory hierarchy: registers and cache are fastest and smallest, RAM is larger and slower, and storage is much larger but far slower and persistent.
Ans. Garbage collection in Java is automatic memory management that finds objects no longer reachable by the program and reclaims their heap memory. The key point is reachability from roots such as stack variables, static fields and active threads. It reduces manual memory errors, but collection timing is not deterministic and may briefly pause execution.
Ans. Implement memcpy by treating the source and destination as byte pointers, copying exactly n bytes from source to destination in order, then returning the original destination pointer. It needs no extra data structure beyond pointer variables. Time complexity is linear in n and space is constant. Overlapping memory is not supported; use memmove for that.
Ans. Use POSIX threads: declare a pthread_t, write a thread function returning void pointer, call pthread_create with the thread id, attributes, function, and argument, then call pthread_join to wait for it. The main data structure is pthread_t. Creating the thread is O(1), excluding operating system scheduling cost.
Ans. A new object in C++ is created by defining a variable of its class type or by using new for dynamic allocation. In both cases, suitable memory is obtained and the constructor is called to initialise the object. Objects created with new must later be destroyed with delete to avoid memory leaks.
Ans. Use probability as favourable outcomes divided by total possible outcomes, after making outcomes equally likely. Count choices carefully, using combinations when order does not matter and permutations when it does. For “at least one” cases, often use 1 minus the probability of none. For independent events multiply probabilities, and for alternatives add mutually exclusive probabilities.
Ans. In CUDA, memory is manipulated by allocating device memory with cudaMalloc, copying data between host and device with cudaMemcpy, using it inside kernels through pointers, and releasing it with cudaFree. The key detail is choosing the right memory space, such as global, shared, constant, or local, because access speed and visibility differ.
Ans. Boost.Asio works by running an io_context event loop that waits for operating system I/O events and dispatches completion handlers. Internally it uses reactor or proactor mechanisms such as epoll, kqueue, IOCP, or select, depending on the platform. Handlers run only on threads calling run, with strands used to serialise related callbacks.
Ans. Virtual destructors are destructors declared virtual in a base class so deletion through a base-class pointer calls the derived destructor first, then the base destructor. They matter for polymorphic classes: if a class has virtual functions, its destructor should usually be virtual to avoid undefined behaviour and resource leaks.
Ans. A C program’s memory is typically divided into text, data, BSS, heap and stack segments. Text holds executable code, data holds initialised globals and statics, BSS holds zero-initialised globals and statics, the heap holds dynamically allocated memory, and the stack holds function calls, local variables and return addresses. Heap and stack lifetimes differ most.
Ans. Deadlock prevention means designing resource allocation so at least one Coffman condition cannot hold. Common techniques are making resources shareable where possible, forcing processes to request all resources at once, allowing preemption of held resources, or imposing a strict global order for acquiring locks. Lock ordering is often the most practical method.
Ans. Yes, GRUB can be modified by editing its configuration and regenerating the boot menu. On most Linux systems, change settings in /etc/default/grub or scripts under /etc/grub.d, then run update-grub or grub-mkconfig. Directly editing grub.cfg is discouraged because it is generated and may be overwritten.
Ans. Use backtracking to build permutations by choosing each unused character in turn, recursing until the current string has the original length, then print it. Keep a character array, a boolean used array, and a temporary result buffer. The time complexity is O(n × n!) and the recursion depth is O(n).
Ans. Implement Tic-Tac-Toe with a 3 by 3 board array and a move function that validates empty cells, places the player mark, and checks for a winner. The key optimisation is storing row, column, and diagonal counters per player, so each move updates counts and detects a win in O(1) time.
Ans. Linux boots by firmware initialising hardware, loading a bootloader, which loads the kernel and initramfs, then the kernel starts user space via init or systemd. The kernel decompresses, detects hardware, mounts a temporary root filesystem, loads needed drivers, mounts the real root filesystem, and starts PID 1, which launches services, login prompts, and the graphical environment.
Ans. D-Bus is a message bus system that lets processes communicate, mainly on Linux desktops and system services. Applications connect to a session or system bus, expose objects with interfaces and methods, and exchange method calls, replies, errors and signals. It is commonly used for service discovery, notifications, hardware events and controlling background daemons.
Ans. Logical processors are the CPU execution units visible to the operating system for scheduling work, while hyperthreading is Intel’s simultaneous multithreading technique that makes one physical core appear as two logical processors. The key point is that hyperthreads share core resources, so they improve utilisation and throughput but do not double performance.
Ans. Volatile memory is storage that loses its contents when power is removed, such as RAM. A volatile variable is a programming declaration saying the value may change unexpectedly, so it must be read from memory rather than assumed cached. In Java it also gives visibility between threads, but does not make compound operations atomic.
Ans. Implement it like memmove: treat the inputs as byte pointers, and if the destination starts before the source, copy forwards; if it starts inside or after the source range, copy backwards from the end. This prevents overwritten source bytes being read later. It uses no extra data structure and runs in O(n) time.
Ans. Please provide the specific operating systems theory question you want answered. The prompt only states the topic and difficulty, so there is not enough information to give a technically correct interview-style response. I can then answer directly in 40 to 60 words.
Ans. Identify whether order matters. If order matters, use permutations; if not, use combinations. Count choices step by step, multiplying independent choices and adding separate cases. Adjust for restrictions such as repetition, fixed positions, or identical items. For “at least” or “not” cases, often count the total and subtract the unwanted cases.
Ans. Callback functions are functions passed as arguments to another function, to be called later when an operation finishes or an event occurs. They are commonly used in event handling, asynchronous programming, timers, array methods, and APIs. The key point is that they let code decide what should happen after control has moved elsewhere.
Ans. If a parent process is killed in Linux, its child processes are not killed automatically. They become orphan processes and are reparented to init, usually PID 1, or to a configured subreaper such as systemd. The new parent later collects their exit status, preventing them from remaining as zombies.
Ans. A CPU is built for low latency and complex control flow, while a GPU is built for high throughput on many parallel operations. CPUs have fewer powerful cores, large caches and strong branch handling. GPUs have many simpler cores and excel when the same operation runs over large data sets, such as graphics or matrix work.
Ans. Use binary search to find the point where the sorted order restarts. Keep two pointers, left and right, and compare the middle value with the right value. If middle is greater, the minimum is to the right; otherwise it is at middle or to the left. This uses no extra data structure and runs in O(log n).
Ans. A=2, B=1, C=7, D=8, so 2178 × 4 = 8712. Work column by column with carries: 4D gives A, and 4A plus the last carry gives D. Testing possible end digits gives A=2 and D=8. Then the middle columns force C=7 and B=1.
Ans. Inheritance is an object-oriented mechanism where one type reuses and extends the data and behaviour of another. C has no built-in inheritance, but it can be simulated by embedding a “base” struct inside a “derived” struct, often as the first member, and using function pointers to model overridable methods.
Ans. Virtual functions are usually implemented using a vtable and a vptr. Each polymorphic class has a table of function pointers, and each object stores a hidden pointer to the table for its dynamic type. A virtual call uses the vptr to find the right table entry, adding one indirection at runtime.
Ans. Open the directory, read each directory entry, collect the names, sort them lexicographically, and print them in order. Use the operating system directory APIs, skipping hidden files only if matching normal ls default behaviour. A dynamic array or list stores names before sorting. Time complexity is O(n log n), dominated by sorting.
Ans. Linux booting starts when firmware such as BIOS or UEFI initialises hardware and loads a bootloader, usually GRUB, which loads the Linux kernel and initramfs into memory. The kernel detects hardware, mounts the root filesystem, and starts the first user-space process, typically systemd, which then starts services and brings the system to a usable state.
Ans. Use modified binary search. At each step, compare the middle element with the left and right ends to find which half is sorted, then decide whether the target lies in that sorted half or the other half. No extra data structure is needed. Time complexity is O(log n), assuming distinct elements.
Ans. Use graph traversal from room 0 and check whether every room is reached. Treat rooms as nodes and keys as directed edges, then run DFS or BFS using a stack or queue plus a visited set or boolean array. After traversal, all rooms are visitable if visited count equals number of rooms. Time is O(n + k).
Ans. A message is split into packets, wrapped with protocol headers, sent through network devices, then reassembled by the receiving computer. Typically the sender resolves the destination address, opens a connection such as TCP, sends packets through routers using IP, and the receiver checks order and errors before passing the data to the application.
Ans. Use an animation loop that repeatedly clears the screen, updates the ball’s position using its velocity, checks wall collisions, reverses the relevant velocity component, and redraws the ball. Store the ball as an object with x, y, radius, vx, and vy. Each frame is O(1) for one ball, or O(n) for n balls.
Ans. A macro is expanded by the preprocessor as text before compilation, while a function is compiled code called at runtime. The key difference is that functions provide type checking, scope rules, and predictable argument evaluation, whereas macros can avoid call overhead but may cause bugs from repeated evaluation and lack of type safety.
Ans. Use a reverse inorder traversal, visiting right subtree, node, then left subtree, and count visited nodes until the kth node is reached. This works because inorder gives sorted order, so reverse inorder gives descending order. Use recursion or an explicit stack. Time is O(h + k), space is O(h).
Ans. The minimum time is 17 minutes. Send 1 and 2 across first, taking 2 minutes. 1 returns, total 3. Send 5 and 10 across, taking 10 minutes, total 13. 2 returns, total 15. Finally 1 and 2 cross again, taking 2 minutes, total 17. This saves time by moving the two slowest together.
Ans. Structure padding is the unused bytes a compiler inserts between or after struct members to satisfy alignment requirements. It makes access faster or required by the target CPU, so sizeof a struct may exceed the sum of its fields. offsetof, from stddef.h or cstddef, gives a member’s byte offset from the start of the structure.
Ans. CUDA is NVIDIA’s parallel computing platform and programming model for running general purpose code on GPUs. To add two arrays, store inputs and output as contiguous arrays, copy them to device memory, launch a kernel with one thread per index computing C[i] = A[i] + B[i], then copy back. Time complexity is O(n).
Ans. Use a CUDA reduction kernel where each block loads a chunk of the input array into shared memory, then repeatedly halves the active threads to sum pairs until one partial sum remains per block. Store block results in an output array and launch again or finish on the CPU. Work is O(n), with O(log blockSize) steps per block.
Ans. Virtual functions enable runtime polymorphism: a call through a base class pointer or reference invokes the derived class override. For example, define Shape with virtual draw, then Circle and Square override draw, and store Shape pointers in a vector. Calling draw selects the real object’s method via the vtable. Each call is O(1).
Ans. Use a byte swap on the fixed-width integer: move each byte to its mirrored position using masks and shifts, or use the platform intrinsic such as bswap. For a 32-bit value, byte 0 becomes byte 3 and byte 1 becomes byte 2. This is constant time because the number of operations is fixed.
Ans. Start by clarifying requirements, traffic, data size, latency, availability, security, and cost, then propose a simple cloud architecture using managed services where possible. The most important detail is explaining trade-offs: compute choice, storage model, scaling strategy, failure handling, observability, and how the design changes as load or reliability requirements increase.
Ans. Sockets and pipes are mechanisms for inter-process communication, letting separate processes exchange data. Pipes are usually local, simple byte streams, often between related processes, while sockets can work locally or across networks and support client server communication. Other IPC includes shared memory, message queues, signals, semaphores, and memory mapped files.
Ans. Storage classes describe an object’s lifetime, visibility and linkage, and broadly map to stack, data segment, thread storage or heap. Automatic local variables are usually on the stack. Static and global objects are in static storage, such as data or BSS. thread_local objects have per-thread storage. Dynamically allocated objects live on the heap.
Ans. Information moves from secondary storage to main memory, then through the cache hierarchy into CPU registers. The operating system and storage controller read disk or SSD blocks into RAM, often using DMA. When the CPU needs a value, load instructions fetch it from memory, usually via L3, L2 and L1 cache, into a register.
Ans. A perceptron is the simplest neural model: it takes weighted inputs, adds a bias, and applies an activation to produce an output. A neural network is a collection of many such units arranged in layers. The key difference is capacity: a single perceptron can only learn linear decision boundaries, while multilayer networks can learn non-linear patterns.
Ans. Cache is small, fast memory that stores recently or nearby used data so the CPU can avoid slower main memory access. Loop ordering affects cache performance by changing memory access patterns. Accessing contiguous data, such as rows in a row-major array, improves spatial locality and reduces cache misses; strided access often performs worse.
Ans. Interrupts are signals that make the CPU pause its current work and run operating system code to handle an event. They can come from hardware, such as a timer or keyboard, or from software, such as a system call. The CPU saves state, jumps to an interrupt handler, then resumes execution.
Ans. Unsupervised learning can be implemented by training deep networks on unlabelled data to learn useful representations, often using autoencoders, variational autoencoders, contrastive learning, or deep clustering. The key detail is the loss function: it must create a learning signal from the data itself, such as reconstruction error or similarity between augmented samples.
Ans. An autonomous vehicle would typically use a real-time operating system, such as QNX, VxWorks or an AUTOSAR-based platform, for safety-critical control. The key reason is deterministic timing: braking, steering and sensor-fusion tasks must run within guaranteed deadlines, with isolation, fault tolerance and safety certification support.
Ans. Break the problem into facts, unknowns and constraints. Translate words into numbers, equations, tables or diagrams where useful. Look for patterns, edge cases and contradictions. For quantitative puzzles, estimate first, then calculate carefully. For logic questions, test each option systematically and eliminate impossible answers before choosing the most consistent one.
Ans. Use one stack plus a variable currentMin. When pushing a value smaller than currentMin, store an encoded value such as 2*x - currentMin and update currentMin to x. When popping an encoded value, restore the previous minimum as 2*currentMin - encoded. Push, pop, top and getMin are all O(1).
Ans. Reduce cache misses by using blocked, or tiled, matrix multiplication so small submatrices fit in cache and are reused before being evicted. Choose block sizes based on cache capacity and line size, store data contiguously, and often transpose the second matrix so inner-loop access is sequential rather than strided.
Ans. Use a thread control block per thread, holding thread id, state, registers, program counter, stack base, stack limit and current stack pointer, plus ready and blocked queues for scheduling. Maximum stack memory is the sum of reserved stack sizes for all live threads, or the maximum observed base minus lowest stack pointer per thread if measuring actual use.
Ans. A strong answer shows flexibility without sounding unfocused. Choose an example where you assessed a change calmly, asked clear questions, and compared it with your skills, goals, and the organisation’s needs. Emphasise openness, professionalism, and decision-making. Interviewers listen for adaptability, self-awareness, and whether you would handle surprises constructively.
No question matches those filters. Reset filters.
Showing 60 of 202 questions. Ranked by how often the same question came back across interviews.
A spoken interview built from these questions, scored when you finish; the feedback is yours.
Start practisingWhen you are ready, record The One: a single interview hiring teams watch, so you stop repeating first rounds.
Candidate interviews most often cover CS fundamentals (63%) and DSA (24%).
Candidate interviews show an average of 3.4 rounds per experience, with a typical sequence of Online test → Technical. Individual interview paths can vary.
Among questions with a recorded difficulty, the mix is easy 28%, medium 62%, hard 10%.
