HackTheRounds Interview Experiences

NVIDIA HackerRank OA Interview Experience (2026) - Sum of Subarray Minimums & Zero-Sum Construction, Passed

NVIDIA 2026 HackerRank OA walkthrough: 90 minutes on two problems covering monotonic stack contribution counting (Sum of Subarray Minimums) and a constructive u

By Anonymous · 2026-04-02

Background

NVIDIA had been my top pick the whole cycle because the compute-platform work they publish is clearly where the industry is heading, and the 2026 posting for a backend-leaning SWE role on the CUDA tooling side finally lined up with my resume. I had about three years of C++ and Python infrastructure work at a mid-sized analytics shop, no AI research pedigree, and no referral. I applied cold through the careers portal in mid-March. The OA link arrived six days later with a five-day window. Writing this up after the recruiter confirmed I cleared into the phone screen, so I'll cover only the OA section here.

Timeline

Cold application: mid-March
Recruiter auto-response + OA link: 6 days later
OA attempted: 2 days after getting the link
Passed OA notice: 4 business days after submission
Phone screen scheduled: next day
Total so far: ~3 weeks

OA Format (90 min, HackerRank)

Two coding problems, 90 minutes total, language of your choice. I picked Python for speed. The HackerRank environment is the bog-standard one with a run panel, custom stdin, and two fixed hidden test sets. The proctoring is honor-system for this stage, no webcam. The one thing to know is that HackerRank shows you how many hidden tests pass after you submit, which is useful because it lets you check partial credit before the clock runs out.

Both problems in my draw were on the easier end of NVIDIA's historical pool. People in my Discord group reported a harder variant with strings and a second variant with number theory, so the question bank seems to rotate four or five problem pairs.

This question is coming soon to HackTheRounds.

Problem 1: Sum of Subarray Minimums

Problem: Given an integer array, for every contiguous subarray take the minimum value, then sum all those minimums. Return the sum modulo 10^9 + 7 . Constraints allow n up to roughly 10^5 , so the obvious enumerate-all-subarrays approach is too slow.

The intended algorithm is contribution counting with a monotonic stack. Rather than iterating over subarrays, I iterate over elements and ask how many subarrays have arr[i] as their minimum. That count is the distance to the previous smaller element on the left multiplied by the distance to the next smaller element on the right. Sum arr[i] count across all positions, apply the modulo at each step, and you're done in linear time.

The subtle part is the tie-breaking. When duplicate values exist you need strict on one side and non-strict on the other so you don't double-count the subarrays that span repeated minima. I settled on strict-less on the left and less-or-equal on the right, sanity-checked against a small array with duplicates, and it matched.

This question is coming soon to HackTheRounds.

Problem 2: Unique Integers That Sum to Zero

Problem: Given a positive integer n , return any array of n unique integers (positive, negative, or zero) whose sum is zero.

Straightforward constructive problem. Emit the pairs (i, -i) for i running from 1 to n / 2 , and if n is odd append a single 0 . The result is trivially unique, trivially sums to zero, and runs in O(n) . I spent five minutes on this one, mostly re-reading the prompt to make sure I wasn't missing a hidden constraint on range or positivity. I wasn't.

The only trap here is over-engineering. A few candidates on the forum reported trying to derive a clever closed-form construction and breaking the single-element or empty-input edge case. Keep it boring.

This question is coming soon to HackTheRounds.

Result

Passed with both problems at full score. Recruiter emailed four business days later confirming the phone screen. The phone screen is scheduled for next week, a 45-minute coding round plus a brief team-fit chat. I will edit this post or write a follow-up once that round is done.

Tips

Monotonic stack is the single highest-ROI pattern for NVIDIA OA prep. The 2026 pool heavily favors problems where "for each element, find the previous/next smaller/larger" is the underlying mechanic. Sum of subarray minimums, largest rectangle in histogram, and 132-pattern all fall out of the same template. Drill that template cold.
Plan your tie-break convention before you code. For any monotonic-stack contribution problem with possible duplicates, decide which side is strict and which is non-strict up front, write it in a comment, and verify on a small duplicate-heavy input. Getting this wrong costs partial test credit that is hard to recover from.
Apply modulo inside the running sum, not just at the end. C++ and Java candidates who only mod at the final step hit silent overflow on large inputs. Python candidates don't, but it's still a habit worth baking in for consistency across languages.
Use HackerRank's run-against-sample before final submit. The platform gives you free sample runs. There is no reason to submit blind when the engine will tell you in ten seconds whether you pass the given examples.
Leave twenty minutes of slack for re-verification. NVIDIA's pool favors simple constructive problems as the second question, so both should be done in about an hour. Use the remaining half hour to chase edge cases: `n = 1`, empty arrays, all-equal arrays, single-element subarrays. The hidden test count usually includes at least one of these.
Do not optimize problem 2 past the obvious solution. If the prompt says "any array that satisfies X," the grader accepts any valid construction. Don't waste minutes on a clever version that saves two lines and introduces a sign bug.