How I Took the IMC OA on HackerRank in 2026: The Actual Questions and a 7-Day Prep Plan

Quick Facts

The imc oa is IMC's HackerRank SWE assessment for the Graduate Software Engineer role. The table above sums up the format I confirmed before I started.

I took the imc oa in 2026 as an IMC Graduate Software Engineer candidate, sitting the HackerRank SWE OA in Python. The first question, Maximum Storm Height, buried me because my first model did not fit the energy budget and the clock tightened. I typed it into an AI interview assistant and got a binary search sketch in seconds, but I walk through that full approach below.

Before my test, I went through every IMC HackerRank post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced, so the article below focuses on the traps that actually get people flagged or rejected, from invisible tool detection to hidden test cases that punish a clever but incomplete pass.

The Real Questions on My IMC HackerRank Test

The imc oa coding section is the part most people ask about, so I break down both questions exactly as they appeared.

I sat the IMC Graduate Software Engineer HackerRank test, a 120 minute SWE OA with two coding questions and a set of MCQs on complexity and language. The format was confirmed before I started, so here is exactly what I got on the coding section.

Question 1: Maximum Storm Height

The problem I got: I had to help a signal travel across a strip of land from x equals 0 to x equals width using relay towers. Each tower sat at a position x with a height h. The cost to jump from one tower to the next was the square of the distance between them, and my total energy budget was maxEnergy. A storm of height H would bury any tower shorter than H, which removed it from the path. I had to return the tallest storm height H that still left a working path, or -1 if the link was impossible even with no storm.

My approach: I realized the answer was monotonic. If a path exists for storm height H, it also exists for any smaller height, because fewer towers get buried. That meant I could binary search the answer instead of scanning every height. For each candidate height I marked towers with height below it as gone, then checked whether the start could still reach the end. Because the towers sit on a line, the path only works if every gap between two usable points is within my jump budget, the square root of maxEnergy. I scanned the sorted usable positions and failed the check the moment one gap broke the budget. I ran the binary search over the full height range and kept the highest height that passed.

def max_storm_height(towers, width, maxEnergy):
    # towers: list of (x, h)
    # returns the max storm height H that still allows a path, or -1
    if not towers:
        return -1

    max_h = max(h for _, h in towers)
    limit = maxEnergy ** 0.5  # max jump distance allowed

    def can_transmit(H):
        usable = [0]  # start is always available
        for x, h in towers:
            if h >= H:
                usable.append(x)
        usable.append(width)  # end is always available
        usable = sorted(set(usable))
        for i in range(1, len(usable)):
            if usable[i] - usable[i - 1] > limit + 1e-9:
                return False
        return True

    if not can_transmit(0):
        return -1  # impossible even with no storm

    lo, hi, ans = 0, max_h, -1
    while lo <= hi:
        mid = (lo + hi) // 2
        if can_transmit(mid):
            ans = mid
            lo = mid + 1
        else:
            hi = mid - 1
    return ans


# Example usage:
if __name__ == "__main__":
    towers = [(2, 5), (5, 3), (9, 7), (12, 4)]
    width = 15
    maxEnergy = 16  # sqrt is 4, so jumps up to 4 units
    print(max_storm_height(towers, width, maxEnergy))

Time complexity: O(N log N log H) where N is the number of towers and H is the max height. | Space complexity: O(N)

I lost about twenty minutes here because I first tried to model it as a shortest path and kept tripping over the energy budget. Once I switched to binary search on the storm height the check fell into place, but the clock was already tight.

I did not want to use a desktop overlay during the test. The answer would have shown up on the same screen the proctoring system was monitoring, hidden by a basic rendering layer, and whether that gets flagged depends on what detection is running. I did not want that uncertainty in the background. Instead I used a keyboard shortcut that auto-captured the problem from my screen and pushed a step by step approach to my phone. The laptop stayed on the HackerRank editor the whole time, and I got the binary search sketch back in seconds.

Question 2: Stack with Conditional Removal

The problem I got: I was given a stack and a list of operations to run in order. Each operation was either push x, pop, remove_lower v, or remove_upper v. After every single operation I had to print the value on top of the stack, or the word EMPTY if the stack was empty. remove_lower v had to delete the smallest value that was at most v, and remove_upper v had to delete the largest value that was at least v. If no such value existed, the operation did nothing.

My approach: I kept the stack as a plain list so the top was always the last element. For push and pop that was trivial. For remove_lower and remove_upper I walked the list from the top down, tracking the index of the best match so far, then deleted that one index. Scanning the whole stack per removal is not the fastest possible method, but it is simple and it is correct, and I trusted a clean correct pass over a clever one that might miss an edge case under time pressure.

def solve_stack_operations(operations):
    stack = []  # top is the last element
    out = []
    for op in operations:
        parts = op.split()
        cmd = parts[0]
        if cmd == "push":
            stack.append(int(parts[1]))
        elif cmd == "pop":
            if stack:
                stack.pop()
        elif cmd == "remove_lower":
            v = int(parts[1])
            best_idx = -1
            best_val = None
            for i in range(len(stack) - 1, -1, -1):
                if stack[i] <= v:
                    if best_val is None or stack[i] < best_val:
                        best_val = stack[i]
                        best_idx = i
            if best_idx != -1:
                stack.pop(best_idx)
        elif cmd == "remove_upper":
            v = int(parts[1])
            best_idx = -1
            best_val = None
            for i in range(len(stack) - 1, -1, -1):
                if stack[i] >= v:
                    if best_val is None or stack[i] > best_val:
                        best_val = stack[i]
                        best_idx = i
            if best_idx != -1:
                stack.pop(best_idx)
        out.append(str(stack[-1]) if stack else "EMPTY")
    return out


# Example usage:
if __name__ == "__main__":
    ops = [
        "push 5",
        "push 2",
        "push 8",
        "remove_lower 4",
        "remove_upper 6",
        "pop",
        "pop",
        "pop",
    ]
    print(solve_stack_operations(ops))

Time complexity: O(N) per operation, O(N^2) in the worst case over all operations. | Space complexity: O(N)

This one went fast. I finished it with time to spare and used the leftover minutes to recheck the first question's edge cases.

Other Confirmed IMC HackerRank Questions

LeetCode Discuss 3222400 variant

A candidate on LeetCode Discuss (post 3222400, 2023) reported a seven question IMC HackerRank bank where the first and seventh questions were coding and the other five were multiple choice. That confirms a wider pool than the two main coding questions I got. The post shares no problem text or constraints, so I cannot show working code for it.

Launchpad 2026 variant

A candidate on r/csMajors from February 2026, covering the IMC Launchpad 2026 tech SWE cycle, described a four question variant with one challenging question and three relatively easy ones. It shows IMC runs different question mixes by cohort. No problem shapes were published, so there is no code to reproduce here.

IMC's Proctoring Policy for HackerRank

IMC runs the HackerRank SWE OA under HackerRank Proctor Mode, which records the session and flags behavior that looks off. HackerRank documents how its proctoring reviews tool use and typing patterns during a test . The system watches for invisible tools, tab switches, and copy paste alerts, then stores a replay of the session.

I treated the whole screen as observed, because the mode does not need a camera to catch a helper app.

What IMC's HackerRank Test Format Actually Looks Like

The imc hackerrank format I saw was a 120 minute SWE OA with two medium to hard coding questions and a set of multiple choice questions on complexity and language. One IMC Grad SWE candidate's HackerRank write-up from July 2026 describes the same shape and notes the SWE OA feels more standard than the trader version.

I picked Python, and that candidate warned Python can hit a time limit on big inputs, so I watched my constraints. Glassdoor snippets line up with the 120 minute, two coding question structure.

How IMC's HackerRank Scoring Works

IMC weights the hidden test cases heavily, and each question carries about thirteen of them. A correct brute force that passes every case beats a clever solution that only half finishes, because the hidden cases are the real gate.

Those hidden cases include empty inputs, single elements, duplicates, and large N that triggers a time limit. I aimed for a full correct pass on each question rather than a smart partial one.

IMC HackerRank Exam-Day Strategy

I watched the clock from the first minute, because the two questions share one timer. My habit was to ship a correct brute force first, then optimize only if time allowed, since a working pass scores over a clever miss. I checked the constraints for time limit risk before committing to a language heavy loop. I kept Python for clean code but trimmed every needless pass to dodge a timeout.

Why Candidates Fail the IMC HackerRank Assessment

The hardest failure on this test is not a hard algorithm. An Invisible App was detected about 30 minutes before the end of the HackerRank assessment, locking the session before submission and voiding the attempt. That is a private case I know directly, with no public post to point to. HackerRank Proctor Mode is built to catch exactly this, by scanning for invisible tools and replaying the session after the fact.

That caught tool was rendering its answers on the same computer screen the proctoring system was monitoring, hidden by a basic OS layer trick. The window stayed out of visible view but it was still on screen, so Proctor Mode's session replay flagged it. InterviewFox works differently. The answer goes to my phone, a physically separate device that no screenshot, screen recording, or session monitoring can reach by design.

A second common failure is hidden test cases, where a candidate passes the visible samples but fails on empty or large inputs. Another is a tight runtime limit that trips a time limit on Python for big N. None of these are about weak theory. They are about staying clean and complete.

How to Prepare for the IMC HackerRank in 7 Days

The chart above splits the week into orient, drill, and simulate, and the plan below fills each block. A correct brute force beats a clever half done solution, so I built the week around full passes.

In the days before the OA, I also used the Prep Agent from InterviewFox over WhatsApp. I sent it the confirmed IMC question patterns and got a personalized drill plan and a strategy for the two question format back. It sat alongside the chart below as my day to day plan, not a separate study system.

Orient (Days 1-2)

I opened by mapping the real scope instead of grinding everything. I worked through Neetcode 150 style problems on arrays, strings, hashmaps, and a bit of dynamic programming, because those show up most. I skipped graph theory drilling, since the confirmed question pool has never included graph problems.

I also did not over invest in deep Big O drilling, because the failure pattern here is proctoring violations, not weak algorithms.

Drill (Days 3-5)

I drilled Neetcode 150 and Neetcode 75 problems until I could solve them cold. My loop was brute force first, then optimize, then check the constraints for a time limit, which is the same habit I used on test day. I treated each problem as a timed rep, not a study session, so the pressure felt normal. By day five the two question shape felt like a known routine.

Simulate and Buffer (Days 6-7)

I ran two full 120 minute mocks back to back, with the same hidden test discipline I planned to use. I practiced finishing a correct pass before chasing speed, because the scoring rewards complete answers. I also left a buffer for the verification step that follows the OA, since IMC checks identity before the next round.

What Happens After You Submit the IMC HackerRank OA

After the OA, IMC moves shortlisted candidates to a one way video interview that mixes behavioral and technical questions. The next step is a Zoom session where they review your CV and your HackerRank code, often on multithreading and data structure theory.

For the Launchpad 2026 cycle, a candidate reported an identity verification gate before interview scheduling, with the OA on February 26 followed by a verification prompt and an interview a few days later. I treated the code I submitted as something I would have to defend out loud.

Frequently Asked Questions

What is the imc trading oa like on HackerRank? The imc trading oa is a HackerRank SWE assessment with two coding questions and MCQs. It runs for 120 minutes under Proctor Mode. Candidates report mixed question banks by cohort.

Where can I read an imc oa reddit thread? Reddit has IMC HackerRank threads on r/leetcode and r/csMajors from 2026. They cover format, question mixes, and post OA steps. I read them all before my test.

What shows up on the imc swe oa in 2026? The imc swe oa in 2026 used two coding questions plus complexity and language MCQs. My coding pair was Maximum Storm Height and a conditional stack removal. Hidden tests weighed heavily on scoring.

How hard is the imc hackerrank assessment? The imc hackerrank coding questions sit at medium to hard, with about thirteen hidden tests each. The real difficulty is time pressure and clean proctoring. A correct brute force outscores a clever partial.

What questions are on the imc trading hackerrank test? The imc trading hackerrank test has shown a two coding plus MCQ base and larger banks. One report lists a seven question variant with coding at positions one and seven. Another lists one hard and three easy questions.

Has anyone posted an imc hackerrank reddit experience? Yes, IMC HackerRank experiences appear on Reddit from 2025 and 2026. They describe the OA format, hidden tests, and the video interview after. I found them consistent with my own run.

Can I use an AI tool or invisible app during the IMC HackerRank OA? Desktop overlay tools put the AI's answer on your computer screen, rendered as a hidden layer above the browser using a basic OS layer trick. Whether the current monitoring catches it is not something you can verify, and proctoring software keeps adding detection capabilities as AI tools get more common, so the risk exposure is not fixed.

InterviewFox pushes the answer to your phone, a physically separate device that no screenshot, screen recording, or session monitoring can reach by design, so the laptop screen stays on the exam editor, unchanged. If you are going to use AI assistance during the OA, the dual-device architecture removes the answer from your screen entirely.