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
| Detail | This test |
|---|---|
| Platform | HackerRank |
| Test | Recreated NVIDIA Ignite OA |
| Questions | 3 coding problems: Address on Same Page, Generate Bit Mask, Maximum Score |
| Timer shown | 1 hour 28 minutes remaining in the first photo |
| Language shown | C |
| Assistant used | SkillCopilotAI — I provided the questions and received solutions with explanations |
| Result | I 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.

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);
}
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.

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.

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.

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:
| hi | lo | Expected output |
|---|---|---|
| 0 | 0 | 0x1 |
| 31 | 31 | 0x80000000 |
| 31 | 0 | 0xffffffff |
| 2 | 0 | 0x7 |
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.

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.

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 scorePython’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?
| Focus | What I’d practise | How I’d check my understanding |
|---|---|---|
| Bit operations and page offsets | Right shifts, masks, powers of two, and aligned page boundaries | Explain why 4095 and 4096 belong to different 4 KB pages |
| Integer boundaries and output | Bit positions 0 and 31, unsigned types, and hexadecimal strings | Produce 0x1, 0x80000000, and 0xffffffff without shifting a 32-bit value by 32 |
| Heaps and greedy selection | Selecting the maximum, replacing it, and restoring heap order | Trace every operation on a small array and match the running score |
| Complexity and numeric range | Heap construction, repeated updates, integer ceiling division, and score width | Explain 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.
Continue preparing
Editor selected
HackerRank OA Preparation Guide 2026: Question Types, Practice Plan, and Tips
Prepare for a HackerRank OA in 2026 with current question types, coding and SQL patterns, a focused 7-day practice plan, timing tactics, and test-day tips.
Editor selected
Google CodeSignal OA Questions: Reported Problems, Format and Original Practice
Prepare for a Google CodeSignal OA with clearly sourced practice themes, guidance on checking your test format, and three original exercises with tested Python solutions.
Editor selected
Optiver OA: Software vs Trading Assessment Format, Rules and Original Practice
Prepare for the Optiver OA by role: official rules on retakes, calculators and HackerRank languages, candidate-reported formats, and original practice with a tested Python order-book exercise.
Same content type
Best AI Interview Practice Tools 2026: How to Choose and Use Them Ethically
Compare AI interview practice tools in 2026 and learn how to use them ethically for coding, behavioral, system design, and technical interview preparation.
Prepare for your next interview
Practice interview questions, review your explanations, and explore SkillCopilotAI for interview preparation.
