Top 15 Nvidia Coding Interview Problems: Patterns and What Each Teaches

You're interviewing at the company whose chips trained the model that wrote half the internet. You'd expect them to ask brutal algorithm questions. They don't, actually. Candidate reports from Glassdoor and Blind consistently describe Nvidia's DSA rounds as "doable" for anyone who prepared the right patterns. The problems skew medium difficulty, C++ knowledge helps, and interviewers weight your reasoning as heavily as your answer.

This guide covers the 15 problems that appear most frequently in Nvidia's DSA rounds, the pattern each tests, and what the interviewer is actually looking for when they ask it.

What Nvidia's Coding Rounds Actually Look Like

Two technical stages: an online assessment with two coding problems and roughly 60 minutes, then one or two onsite rounds where you solve problems while explaining your thinking live. If you're the type who codes in silence and hopes the output speaks for itself, start unlearning that now.

About 63% of Nvidia's tracked problems are medium difficulty. Easy problems show up in early screens; hards appear for senior roles or as follow-ups. Most candidates face one to three mediums per round.

Nvidia builds hardware that runs the world's most compute-intensive workloads. Certain topics come up more than others: matrix operations, caching, graph traversal, and bit manipulation. You'll see exactly why each problem below fits the company's engineering DNA.

For a fuller picture of how the rounds are structured, see the Nvidia software engineer interview guide.

The 15 Nvidia Coding Interview Problems, Ranked by Pattern Coverage

1. Two Sum (LeetCode #1) | Easy | Hash Map

The classic. You get an array and a target, find two indices whose values sum to the target.

What it actually tests is whether you reach for a hash map without being prompted. The brute-force O(n²) loop is obvious. Interviewers want to see you propose the O(n) complement lookup immediately, explain why it works, and handle the edge case where the same element can't be used twice.

Pattern: Complement lookup with a hash map. This pattern is the foundation of dozens of harder problems. Yes, they're still asking it. No, you can't skip it.

2. Add Two Numbers (LeetCode #2) | Medium | Linked List Arithmetic

Two non-empty linked lists represent two non-negative integers stored in reverse order. Return the sum as a linked list.

The problem is really about carry propagation and pointer discipline. Candidates trip on three things: forgetting to handle different-length lists, dropping the carry after the last digit, and not returning a dummy head. All three are tested here.

Pattern: Linked list traversal with running state. Shows up in hardware simulation contexts where data streams have variable length.

3. Maximum Subarray (LeetCode #53) | Medium | Kadane's Algorithm

Find the contiguous subarray with the largest sum.

Kadane's algorithm is a one-pass O(n) solution that Nvidia interviewers expect you to derive, not just recite. The key insight is that you extend the current window unless the running sum goes negative, in which case you restart. Initialize to nums[0], not zero, to handle all-negative arrays correctly. That last part is where candidates quietly self-destruct.

Pattern: Dynamic programming reduced to a single variable. A gateway problem for understanding how DP can eliminate the table entirely.

4. Rotate Image (LeetCode #48) | Medium | Matrix Manipulation

Rotate an n×n matrix 90 degrees clockwise, in place.

This is one of the most Nvidia-flavored problems on the list. GPU compute is built on matrix operations, and the ability to think about 2D memory layouts matters. The trick is transpose first, then reverse each row, which avoids the four-pointer swap approach that falls apart under interview pressure. If you've ever wondered why a chip company would ask you to rotate a matrix, it's because 2D memory layouts are their entire world.

Pattern: Two-pass matrix transformation. Tests spatial reasoning and in-place operation awareness.

5. Search in Rotated Sorted Array (LeetCode #33) | Medium | Binary Search

A sorted array was rotated at an unknown pivot. Find a target value in O(log n).

Every binary search variant reduces to the same discipline: define what invariant your condition maintains, then never deviate from it. The challenge here is figuring out which half is sorted before deciding which half to search. One conditional does the work.

Pattern: Modified binary search on a half-sorted structure. See the binary search invariant guide for the full framework.

6. Generate Parentheses (LeetCode #22) | Medium | Backtracking

Given n pairs of parentheses, generate all valid combinations.

The backtracking insight is that you have exactly two constraints: open count can't exceed n, and close count can't exceed open count. Build the recursion tree with those two guards and invalid branches prune themselves. The result is the Catalan number of valid strings, which you don't need to memorize but is fun to mention.

Pattern: Constrained enumeration via backtracking. Teaches you how to prune before you generate rather than generating and filtering.

7. Minimum Path Sum (LeetCode #64) | Medium | 2D Dynamic Programming

Find the path from top-left to bottom-right of a grid that minimizes the sum of values along the path.

The state transition is straightforward once you identify that each cell depends only on the cell above and the cell to the left. You can solve this with a full dp table or, with a small optimization, a single row of rolling values. Nvidia interviewers like seeing candidates notice the space reduction. It signals you actually think about memory.

Pattern: Grid DP with a bottom-up fill. Foundation for harder path-finding problems.

8. Flatten Binary Tree to Linked List (LeetCode #114) | Medium | Tree DFS

Transform a binary tree into a linked list in place, using the right pointers, in preorder order.

The key observation is that the rightmost node of the left subtree connects to the right subtree. Once you see that, the recursive or iterative solution writes itself. Most wrong answers come from candidates who mutate pointers before saving the references they need. Save first. Mutate after. Every time.

Pattern: Tree rewiring via DFS with pointer preservation. Tests careful ordering of operations.

9. String to Integer (atoi) (LeetCode #8) | Medium | String Parsing

Implement the C standard library's atoi function.

Nvidia ships a lot of systems-level C++. This problem tests whether you handle leading whitespace, optional sign, non-digit termination, and integer overflow, in that order.

The overflow check is the part most candidates miss. In C++, you check before the multiply: if the running value exceeds INT_MAX / 10, you've already overflowed. This is the same reasoning you need when writing hardware drivers. Miss it in the interview and the interviewer makes a note.

Pattern: Character-by-character parsing with overflow guards.

10. LRU Cache (LeetCode #146) | Medium | Hash Map + Doubly Linked List

Design a data structure that supports O(1) get and O(1) put with least-recently-used eviction.

This is the most Nvidia-specific problem on the list. GPU memory hierarchies are fundamentally cache systems. L1, L2, and global device memory all have eviction policies. An interviewer at a company that ships hardware cache controllers is not asking this by accident. They know the answer. They want to hear you work through it.

The solution fuses a hash map (for O(1) lookup) with a doubly linked list (for O(1) eviction order). See the full LRU cache implementation walkthrough for the sentinel-node approach that eliminates null checks.

Pattern: Composed data structures. Tests whether you know when to combine two simpler structures instead of inventing a complex one.

11. Binary Tree Right Side View (LeetCode #199) | Medium | BFS Level Order

Return the last node visible at each depth of a binary tree.

BFS where the only output you care about is the last element of each level. Track queue size before the inner loop, record the final node. Three lines once you know the pattern. Candidates who reach for DFS here spend the rest of the problem fighting their own state management instead of solving it.

Pattern: Level-order traversal with a level boundary. Common in GPU rendering pipelines where you process objects in depth order.

12. Number of Islands (LeetCode #200) | Medium | Graph BFS/DFS

Count connected components in a binary grid.

Every unvisited land cell is the seed of a DFS or BFS that marks the entire island. The classic pitfall is forgetting to mark cells in-place before the recursion returns, which causes exponential revisiting. One missing mark turns O(mn) into something you do not want to calculate in front of an interviewer.

Pattern: Flood fill via DFS or BFS. Foundational for any connectivity or clustering problem.

13. Daily Temperatures (LeetCode #739) | Medium | Monotonic Stack

Given daily temperatures, return how many days until a warmer temperature.

The monotonic stack turns an O(n²) nested scan into a single O(n) pass. You maintain a stack of indices with decreasing temperatures. When a new temperature is warmer than the top, you pop and record the difference. The insight is that you never need to look backward more than once.

See what is a monotonic stack for the full pattern with worked examples.

Pattern: Monotonic stack for next-greater-element queries.

14. Merge k Sorted Lists (LeetCode #23) | Hard | Min-Heap

Merge k sorted linked lists and return one sorted list.

The min-heap approach is the one interviewers expect. Push the head of each list into a min-heap keyed by value. Pop the minimum, append to output, push the next node from the same list. Time complexity is O(n log k). The naive k-pass merge is O(nk). Say O(nk) in your answer and watch the expression change.

Pattern: Heap-based k-way merge. Tests whether you reach for a priority queue when merging ordered streams.

15. Trapping Rain Water (LeetCode #42) | Hard | Two Pointers

Given an elevation map, compute how much water it can trap.

The two-pointer approach eliminates the auxiliary arrays and runs in O(n) time and O(1) space. The key: when leftMax < rightMax, the water above the left pointer is fully determined by leftMax, so you can compute and advance without knowing the exact right wall. This kind of reasoning, deferring a decision because one constraint is already binding, is exactly what hardware engineers deal with constantly.

Pattern: Two-pointer convergence with asymmetric bound reasoning.

Patterns to Prioritize in Prep

Pattern	Problems Covered	Frequency
Hash Map	Two Sum, LRU Cache, Number of Islands	Very high
Binary Search	Search in Rotated Array	High
Dynamic Programming	Maximum Subarray, Minimum Path Sum	High
Graph BFS/DFS	Number of Islands, Binary Tree Right Side View	High
Monotonic Stack	Daily Temperatures	Medium
Heap	Merge k Sorted Lists	Medium
Backtracking	Generate Parentheses	Medium
Linked List	Add Two Numbers, LRU Cache, Flatten Binary Tree	Medium

The Prep Strategy That Actually Works

Solve these by pattern instead of by problem. Solve Two Sum before Subarray Sum. Solve Number of Islands before word ladder variants. Do LRU Cache only after you've internalized why doubly linked lists beat arrays for ordered eviction.

Practice narrating your reasoning while you code, not after. Nvidia interviewers score explanation as heavily as correctness. The candidate who writes a perfect solution in silence is harder to evaluate than the candidate who talks through a slightly slower approach. Your terminal isn't the interviewer. The person watching you is.

SpaceComplexity simulates this out loud, giving you a rubric-based score on communication, problem solving, and code quality after each mock interview. That's the format Nvidia's onsite rounds actually use.