NVIDIA Ignite OA on HackerRank: The Questions I Got and How I Passed the Recreated Test

I used SkillCopilotAI to solve three coding questions in a recreated NVIDIA Ignite OA on HackerRank. Here are the solutions and passing test results.

JackJackTest Contributor
Nov 18, 2026NVIDIASoftware Engineering Pre-Intern
AI-generated editorial illustration of memory pages, bit masks and a max-heap for a recreated coding test

I used SkillCopilotAI to complete a recreated NVIDIA Ignite OA on HackerRank. I provided the assistant with three coding questions—Address on Same Page, Generate Bit Mask, and Maximum Score—and used its solutions to pass the test.

The first photo shows 1 hour 28 minutes remaining. I went through the questions in the order shown in the sidebar, with the assistant’s responses alongside the problem statements. The two bit problems called for short implementations; the last one needed a heap to keep track of changing values.

Quick Facts

DetailThis test
PlatformHackerRank
TestRecreated NVIDIA Ignite OA
Questions3 coding problems: Address on Same Page, Generate Bit Mask, Maximum Score
Timer shown1 hour 28 minutes remaining in the first photo
Language shownC
Assistant usedSkillCopilotAI — I provided the questions and received solutions with explanations
ResultI passed the recreated test; the photos show passing checks for the visible test cases

NVIDIA Ignite OA Format, Timing and Languages

For my recreated NVIDIA Ignite HackerRank test, I worked through three coding questions. The photos document that exercise; they don’t establish the question mix for another applicant’s assessment. Before preparing for an actual test, I’d check the invitation for the number of sections, any multiple-choice component, and whether I could move between questions.

How much time would I plan for?

The first photo shows 1 hour 28 minutes remaining. That tells me what the timer displayed at that point, not the original time limit or my total solving time. I would check two separate deadlines in an invitation: the last time I could start the assessment and the time allowed once I began. I wouldn’t assume a reported 48-hour start window or 90-minute test applied to my own invitation.

Which language would I use?

My photographed responses use C. The Python example later in this article is an alternative explanation of the heap algorithm. For an NVIDIA SWE HackerRank assessment, I’d confirm the allowed languages in the instructions and editor before choosing one. I would also practise the required function signature, integer types, and return format in that language.

NVIDIA HackerRank Questions I Worked Through

These are the three questions from my recreated test, followed by the assistant responses and results. I’m using them to explain the techniques I practised, rather than treating them as a guaranteed question list for another assessment.

Question 1: Address on Same Page

The first prompt gave me two 32-bit memory addresses and asked whether they were on the same aligned 4 KB page. The sample used 4095 and 4094, with an expected result of 1.

Address on Same Page problem with 32-bit address constraints and a sample returning 1
The first problem: compare the page numbers of two 32-bit addresses on aligned 4 KB pages. Open the photo at full size to read the code.

SkillCopilotAI’s answer shifted both addresses right by 12 and compared the results. The explanation gave me a way to follow the code: 4096 is 2 to the power of 12, so removing those lowest bits leaves the page number.

This is the solution shown in the response:

int same_page(long addr1, long addr2) {
    return (addr1 >> 12) == (addr2 >> 12);
}
Same-page assistant response with right-shift solution and green test-case checks
The assistant returned a right-shift solution; the results panel shows green checks for the visible test cases. Open the photo at full size to read the code.

For the nonnegative values in the prompt, shifting right by 12 gives the page number. Both sample addresses become zero, so the comparison returns 1. I would also check 4095 against 4096: they are adjacent addresses, but they fall on different pages and should return 0.

Code note: This signature follows the photographed exercise. long must be wide enough for the stated 32-bit unsigned address range; its width varies by platform.

The page boundary was the detail I wanted to retain: addresses can be only one byte apart and still need a result of 0. The solution takes O(1) time and O(1) extra space.

Two ways I can view answers: phone only or both screens

SkillCopilotAI gives me two display options for the shared session. I can hide the desktop answer window and read the code and explanation on my phone, leaving the question and editor visible on my computer. Or I can keep the desktop answer window open and view the responses on both my computer and phone at the same time.

The photo below shows the question, C editor, and passing test result on my laptop, with the solution and explanation open on my phone.

Laptop displaying the same-page coding task and passing result beside a phone displaying the SkillCopilotAI answer
My laptop and phone in the same photo: HackerRank displays “All available test cases passed” for the same-page problem, while SkillCopilotAI displays the C solution and explanation on my phone. Open the photo at full size to read the code.

The mobile response shows this version of the function:

int same_page(long addr1, long addr2) {
    return ((unsigned long)addr1 >> 12)
        == ((unsigned long)addr2 >> 12);
}

It uses unsigned casts before removing the 12-bit page offset. I would still check that the input types and parsing can represent the full address range: casting inside the function does not fix an address that could not be represented when it was read.

For this practice session, the dual-device view gave me another place to read the code and explanation. It does not establish permission to use a phone or outside assistance in a formal assessment; I would follow that assessment’s instructions.

Question 2: Generate Bit Mask

The next question asked me to set every bit from lo through hi, including both ends, and return the mask as a lowercase hexadecimal string. For hi = 2 and lo = 0, the expected output was 0x7.

Generate Bit Mask problem with bit-position constraints and sample output 0x7
The second problem: return a lowercase hexadecimal mask covering every bit from lo through hi. Open the photo at full size to read the code.

For the second question, getting 0x7 from the sample wasn’t enough for me to understand the solution. The allowed range went all the way to bit 31, so I looked at how the assistant handled that boundary.

For this question, SkillCopilotAI returned two masks. One kept the bits through hi; the other cleared the bits below lo. Their intersection left the requested range set. Neither shift needed to reach 32.

Bit-mask assistant response with shift-based solution and passing visible test cases
The assistant used two bounded shifts to build the mask. The visible test cases show passing checks, with 0x7 displayed for the sample. Open the photo at full size to read the code.

I’ve written the same approach below with an explicit 32-bit type:

#include <stdint.h>
#include <inttypes.h>
#include <stdio.h>

char* set_mask(int hi, int lo) {
    static char out[11];
    uint32_t upper = UINT32_MAX >> (31 - hi);
    uint32_t lower = UINT32_MAX << lo;
    uint32_t mask = upper & lower;
    snprintf(out, sizeof out, "0x%" PRIx32, mask);
    return out;
}

With 0 <= lo <= hi <= 31, both shifts stay within 0–31.

Code note: uint32_t makes the width explicit. The static output buffer is overwritten on each call; a judge requiring an allocated string needs different return storage.

These are the boundary outputs I would check alongside the sample:

hiloExpected output
000x1
31310x80000000
3100xffffffff
200x7

I also checked the output requirement against the explanation: lowercase letters, an 0x prefix, and no unnecessary leading zeros. The numeric mask and the returned string both mattered here. A shift by 32 on a 32-bit type would have undefined behavior; the bounded shifts avoid that issue.

Question 3: Maximum Score

The final problem changed the pattern. I had an array of positive integers and had to perform exactly k operations. Each time, I selected a value, added it to the score, and replaced it with its value divided by three, rounded up.

Maximum Score problem with positive-integer constraints and repeated ceiling division by three
The third problem: maximize the score across exactly k operations, replacing each selected value with its ceiling after division by three. Open the photo at full size to read the code.

SkillCopilotAI’s final response included a C max-heap implementation with a sift_down function. I followed how it restored the order after replacing the largest value. Sorting once would not maintain that order, while scanning the entire array for every operation would take O(nk) time.

Maximum Score assistant response with a C max-heap solution and passing visible test cases
The assistant provided a C max-heap implementation. The compiler reports Success, and the visible test cases show green checks. Open the photo at full size to read the code.

I followed the C implementation through one operation: take the largest value, add it to the score, replace it, and restore the heap. Each array position produces a nonincreasing sequence when selected repeatedly, so taking the largest available value selects the next largest contribution.

The photographed response is C. I’ve included a shorter Python equivalent here so I can show the selection and replacement steps without the heap helper code:

import heapq

def max_score(arr, k):
    heap = [-value for value in arr]
    heapq.heapify(heap)
    score = 0

    for _ in range(k):
        value = -heapq.heappop(heap)
        score += value
        replacement = (value + 2) // 3
        heapq.heappush(heap, -replacement)

    return score

Python’s heap returns the smallest item, so I store negative values to get the largest original value first. Building the heap takes O(n), followed by O(k log n) for the repeated operations. Extra space is O(n).

I would check two details before using the result. First, a positive value of 1 or 2 becomes 1 after ceiling division by three; I must keep that replacement in the heap. Second, the photographed prompt asks for a 64-bit score. In C or C++, the accumulator needs to satisfy that requirement even though each input element fits in 32 bits.

What helped me most about using SkillCopilotAI

SkillCopilotAI gave me an implementation and an explanation for each question I provided. I could connect the answer to a particular requirement: the page boundary, bit 31, or the replacement value in the heap. That made the responses useful beyond copying a function.

I still needed to read those explanations. Passing checks don’t tell me whether I can explain a shift or rebuild a heap myself. The photos also don’t measure response time or establish how the tool performs on other questions.

For another session like this, I’d use the SkillCopilotAI download page and work through a problem where assistance is allowed. I’d keep the response beside the test output, then rewrite the solution without looking at it.

How I’d Prepare for the NVIDIA Ignite OA

If I were deciding how to prepare for the NVIDIA Ignite OA from this session, I’d use the questions as a skills checklist. My next practice would focus on reproducing the reasoning without the assistant response beside me. The order below reflects these three exercises, not a prediction of how often a topic appears in NVIDIA’s assessments.

What exactly would I study for a software OA?

FocusWhat I’d practiseHow I’d check my understanding
Bit operations and page offsetsRight shifts, masks, powers of two, and aligned page boundariesExplain why 4095 and 4096 belong to different 4 KB pages
Integer boundaries and outputBit positions 0 and 31, unsigned types, and hexadecimal stringsProduce 0x1, 0x80000000, and 0xffffffff without shifting a 32-bit value by 32
Heaps and greedy selectionSelecting the maximum, replacing it, and restoring heap orderTrace every operation on a small array and match the running score
Complexity and numeric rangeHeap construction, repeated updates, integer ceiling division, and score widthExplain O(n + k log n) and why the score needs a 64-bit type in the photographed C task

I’d start with the bit problems and write the solutions from scratch. Then I’d work through a small Maximum Score example by hand, implement it, and compare the output with the manual calculation. I’d keep expected outputs beside each exercise so I could distinguish an algorithm error from a formatting error.

After that, I’d repeat the set under a practice timer matched to the assessment instructions I actually received. I’d also check whether the real assessment listed other sections before deciding what else to study. This session covered coding; it gives me no basis to rule out other topics in a different test. For a broader checklist, I’d use the HackerRank OA preparation guide.

Technical verification of the published code

Editorial check, November 18, 2026: The code printed in this article was checked separately from Jack’s photographed session. The checks covered all 528 valid lo/hi bit-mask ranges, 1,000 address pairs compared with integer page division, and 200 small maximum-score cases compared with exhaustive choices. All checks passed in the audit environment.

The C examples were compiled and run on the audit machine; this does not establish portability to every C implementation. These checks validate the published examples, not every line of the assistant response shown in the photos or a result from NVIDIA’s hiring process.

A few details about this test

Were these the official NVIDIA Ignite OA questions?

I worked through a recreated NVIDIA Ignite OA. I would use these questions to practise the techniques, not as a guaranteed preview of a future assessment. For the actual process, I’d check my own invitation and NVIDIA’s How We Hire page, including its rules on outside assistance.

What does “passed” mean here?

I passed the recreated coding test with SkillCopilotAI’s help. The photos show green checks for the visible test cases across the three questions; they don’t include a separate overall score report.

Which code is shown in the photos?

The photographed responses use C. The fixed-width mask code and Python heap example in this article explain the same approaches; they are not verbatim copies of every line in the photos.

Prepare for your next interview

Practice interview questions, review your explanations, and explore SkillCopilotAI for interview preparation.