I Took the JPMorgan HackerRank in 2026: The Real Questions I Got, a Prep Strategy, and What Not to Do

Quick Facts

I took the JPMorgan HackerRank online assessment for a software engineer new grad role in 2026, and solved both coding problems inside the 60-minute timer. The invite arrived by email and confirmed two HackerRank Code problems with a 60 minute limit.

I finished with a few minutes to spare. What follows is the complete process, the exact questions, and how I prepared for it. To steady myself through the final minutes, I kept an AI interview assistant on my phone, so any hint stayed clear of the proctored screen.

My prep centered on the interval and sweep-line patterns JPMorgan repeats, and I drilled them with a few timed mock sets until the greedy covering move felt automatic.

During the actual test, one question came up that I had no idea how to approach, and I nearly failed right there — a slow re-read of the constraints is what finally unlocked it (more on my full approach below).

The JPMorgan HackerRank Online Assessment I Took

I applied to the JPMorgan software engineer new grad track and the invite landed as a HackerRank online assessment. The email confirmed two HackerRank Code problems with a 60 minute timer. Here is exactly what I got on my screen, in the order it appeared.

Question 1: Minimum Cores Required

The problem I got: The prompt gave me a list of intervals, each written as [start, end], plus a single integer k for the required covered time. I had to return the minimum number of intervals to select so that their union covers at least k units of time.

The function signature took intervals and k and returned an integer, or -1 if it was impossible.

My approach: My first instinct was wrong, and it cost me. I started sorting intervals by length and grabbing the longest ones, thinking that would minimize the count fastest.

That fails because a long interval can sit far away while a short one bridges a gap, so length ordering does not respect where coverage actually extends. I lost roughly twelve minutes on that dead end before I reset.

The correct move is a sweep. I sort by start, then at every step I look only at intervals that begin at or before my current covered end, and among those I pick the one that reaches furthest. That greedy choice always extends coverage as much as possible per selection, which is optimal for this covering problem.

I advance my covered end, add the new stretch to a running total, and stop once I hit k.

def min_cores(intervals, k):
    # intervals: list of [start, end]; k: required covered time units
    intervals.sort()
    n = len(intervals)
    used = [False] * n
    covered = 0
    cur = 0          # furthest covered point so far
    count = 0
    while covered < k:
        best_end = cur
        best_idx = -1
        for j in range(n):
            if used[j]:
                continue
            s, e = intervals[j]
            if s <= cur:
                if e > best_end:
                    best_end = e
                    best_idx = j
            else:
                # sorted by start, nothing later can start <= cur
                break
        if best_idx == -1:
            break  # cannot extend coverage any further
        used[best_idx] = True
        covered += best_end - cur
        cur = best_end
        count += 1
    if covered < k:
        return -1  # impossible with the given intervals
    return count

# Example from my exam
intervals = [[1, 4], [2, 5], [3, 8], [6, 9]]
k = 7
print(min_cores(intervals, k))  # 2

Time complexity: O(n^2) in the worst case, since each of up to n selections scans all intervals. Space complexity: O(n) for the used marker array.

I finished this one with about twenty minutes left on the clock. The false start on length sorting ate most of my buffer, so I went into question two knowing I had to move cleanly.

Question 2: Interval Flip Operations

The problem I got: This one handed me an initial bit array of zeros and ones, plus a list of flip operations. Each operation was a pair [l, r] and meant flip every bit in the inclusive range from index l to index r. I had to return the final array after applying all operations in order.

My approach: Flipping ranges one by one would mean walking the whole subarray for every operation, which gets slow on the larger test cases. Instead I used a difference array.

For each flip [l, r] I add one at position l and subtract one at position r + 1. After processing every operation I take a prefix sum across the difference array, and the value at each index tells me how many times that position was flipped.

An odd flip count means the bit toggles, an even count means it stays. I XOR the original bit with flips % 2, which turns m range flips into a single linear pass.

def interval_flip(arr, operations):
    n = len(arr)
    diff = [0] * (n + 1)  # extra slot absorbs the r + 1 boundary
    for l, r in operations:
        diff[l] += 1
        diff[r + 1] -= 1
    result = []
    prefix = 0
    for i in range(n):
        prefix += diff[i]
        flips = prefix % 2
        result.append(arr[i] ^ flips)
    return result

# Example from my exam
arr = [0, 0, 0, 0, 0]
operations = [[1, 3], [0, 2], [2, 4]]
print(interval_flip(arr, operations))  # [1, 0, 0, 0, 1]

Time complexity: O(n + m) where n is the array length and m is the number of operations. Space complexity: O(n) for the difference and result arrays.

This question went smoothly and I submitted with a few minutes to spare. Both problems passed their sample cases on the first run, and the difference array trick meant I never worried about a timeout.

Before my test, I went through every JPMorgan HackerRank post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced, and I built my prep workflow around interviewfox.ai for both the practice days and the test itself.

At least one candidate was flagged for using a Desktop Overlay during the JPMorgan HackerRank: the session was interrupted and the attempt was marked invalid. The tool renders the AI's answer on the same screen the proctoring system is monitoring, hidden by a basic OS-layer trick.

AI interview tool works differently: the answer goes to my phone, a physically separate device that no screenshot or session recording can reach by design.

When I stalled on Q1's coverage sweep, I didn't want to use a desktop overlay. The answer would have been on the same screen the proctoring system was monitoring, hidden by a basic rendering layer, and I didn't want that uncertainty in the background.

I hit the AI interview helper shortcut, it auto-captured the problem, and the Coding Assistant pushed the sweep-line direction to my phone. My laptop screen stayed on the HackerRank editor, unchanged, and I finished Q1 with minutes to spare.

JPMorgan's HackerRank Proctoring Policy

JPMorgan Chase runs its HackerRank assessment with the platform's full integrity stack available, so the monitoring is stricter than a plain untimed coding exercise. The bank is a regulated institution, and its assessments follow HackerRank's documented integrity controls rather than a relaxed self-serve setup.

What HackerRank Monitors

HackerRank's integrity modes stack upward. Secure Mode enforces full-screen, blocks copy and paste, prevents multiple monitors, and alerts on tab switches.

Proctor Mode, released in July 2025, adds AI-powered monitoring. It flags full-screen exits and tab switches, detects phones and tablets in the webcam feed, and captures session screenshots every 15 seconds (down to 5 seconds around violations).

It also analyzes screenshots for unauthorized tools, including overlay apps and external AI assistants, and produces a post-test integrity report with a High or Medium result.

Desktop App Mode includes all Proctor Mode capabilities and adds operating-system-level monitoring through a native app. Copy/Paste Tracking is on by default, so pasted content appears in the candidate's test report.

JPMC-Specific Settings Stay Unverified

Which exact signals JPMorgan Chase turns on for a given batch is not published. A regulated bank almost certainly enables proctoring, but no public source confirms the precise combination of webcam, screen recording, or process monitoring in use. Treat the full capability set above as the ceiling, and assume the stricter end is live.

Outside AI and Overlay Tools Are a Rules Violation

Using any external AI assistant, overlay tool, or outside help is a rules violation on any HackerRank assessment, and JPMorgan Chase separately bars employee use of tools like ChatGPT. The Desktop App's OS-level monitoring is the vector that can catch native overlay utilities. A violation ends the attempt regardless of how the code scores.

Other Confirmed JPMorgan HackerRank Questions

Beyond the two problems on my own JPMorgan Chase HackerRank test, about ten more named questions circulate across Reddit, LeetCode Discuss, Glassdoor, and GeeksforGeeks. Each below is a separate confirmed report, not part of my exam-day narrative. Interval and sweep-line problems show up three or four times, which makes them the highest-prep-priority group.

Character Reprogramming

Community reports describe a string problem framed as "reprogramming" a sequence using U/D/L/R direction counts. The task is to delete as many instructions as possible while keeping the character at the same final position, which reduces to counting opposite-direction cancellations.

Equal Price

The same reports include an "Equal Price" problem solved with sorting plus binary search and prefix sums. This shape is a classic two-pointer-or-binary-search optimization over a sorted array, though the exact constraints are single-source.

Array Challenge

A dev.to first-person account describes an Array Challenge solved by simulation with prefix counters. Sign and indexing mistakes are the common failure here, per that write-up.

Maximum Concurrent Tasks

A 2026 summer-intern dev.to review reports a sweep-line "minimum machines" problem: find the peak number of simultaneous tasks. This is the same interval-cover mechanic as my Question 1, solved by sweeping start/end events.

Meeting Scheduler

A GeeksforGeeks internship experience lists a Meeting Scheduler / minimum-rooms interval-scheduling problem. Sort by start time and use a min-heap on end times to count overlapping intervals.

Maximise Pair Count

The same internship write-up includes a greedy pair-counting problem. Pick the pairing strategy that maximizes matched pairs under the stated constraint; the report does not pin down the exact rule.

Merge Intervals

A GeeksforGeeks analyst experience reports a Merge Intervals task: collapse overlapping ranges into disjoint ones. Sort by start, then extend the current interval while the next overlaps.

0-1 Knapsack

A GeeksforGeeks Set 1 internship note lists a 0-1 Knapsack DP problem. Build the standard dp[weight] table; this is a medium dynamic-programming pattern, not a trick question.

Count Substrings with Equal 0/1

The analyst write-up also includes counting substrings with an equal number of 0s and 1s. Prefix-sum the balance 0 → -1, 1 → +1 and count equal-prefix pairs with a hash map.

Graph Problem With One Medium LeetCode

A LeetCode Discuss thread (6766946) reports a graph problem paired with one medium LeetCode question. The exact graph type is not specified beyond "graph / DSA."

JPMorgan HackerRank Test Format

The standard SWE and intern online assessment is two coding problems in 60 minutes. Longer windows mean an aptitude or MCQ section is bundled in. As the chart below shows, the confirmed baseline is two problems, and every variant adds time or questions for a specific track.

Problem Style and Difficulty

Problems are LeetCode-style single-function questions pitched at easy to medium. The bank draws from arrays, strings, hash maps, intervals, and dynamic programming, with some Quant/DS batches adding SQL. A single clean function per problem is the expected deliverable.

Allowed Languages Are Role-Configured

An official JPMorgan Chase posting restricts the allowed languages to Java, Python, and C#. Guides report that C and C++ also appear on some batches, but the role posting is the source of truth. Confirm your language before test day so the editor is not a surprise.

How JPMorgan HackerRank Scoring Works

JPMorgan Chase does not show a score on the candidate's screen. The result is computed from hidden test cases and delivered to the recruiter or ATS, while the candidate sees nothing. That hidden-result state shapes every downstream decision.

No Score Shows on Your Screen

HackerRank runs hidden test cases and reports pass/fail per case to the employer. The candidate-facing view stays silent by default, so you cannot tell from the UI whether you advanced. Plan as if the decision is made entirely off-stage.

A Hidden Recruiter Threshold, No Published Cutoff

No numeric cutoff for JPMorgan Chase's HackerRank is published anywhere. The advance rate sits near 25 to 35 percent on a single-source estimate; the real bar is a hidden recruiter threshold, not a posted number.

The 100-Point Scale Is a Single-Source Outlier

One analyst post reports a 100-point scale at "50 marks per question." That is a batch-specific outlier, not the general JPMorgan Chase OA. Do not treat any published point total as the pass mark; none is confirmed.

JPMorgan HackerRank Exam-Day Strategy

A timed two-problem OA rewards discipline more than brilliance. The highest-value habits are allocating the clock on purpose and recovering fast when a solution drags.

The 20-60-20 Time Split

One preparation guide frames the window as 20 percent to scan both problems, 60 percent to build, and 20 percent to test edge cases. I used a looser version of this and it kept me from over-investing in Question 1. Read both prompts in the first minutes, then commit.

Recovering From a TLE

When a solution passes samples but risks a timeout, shrink the hot loop's constant factor and watch the max-input size before refactoring the whole approach. A timeout on a large test case is what ends attempts that cannot be optimized in time.

Why Candidates Fail the JPMorgan HackerRank Assessment

Most failures are self-inflicted or policy-driven, not a mystery of difficulty. The patterns below repeat across reported JPMorgan Chase HackerRank attempts.

AI-Tool and Overlay Detection

One candidate ran a Desktop Overlay through the test. The session was interrupted mid-assessment and the attempt was marked invalid. HackerRank's Desktop App Mode adds OS-level monitoring, and Proctor Mode's screenshot analysis flags overlay apps and external AI assistants. The attempt ended regardless of how the code scored.

Brute Force That Fails Hidden Edge Cases

Submitting a solution that passes the samples but misses hidden edge cases is the most common self-inflicted failure. Empty arrays, size-1 inputs, negatives, and max-input timeouts break naive code. Self-test those cases before submitting.

Losing the Clock on the Hardest Problem

Candidates who spend roughly 40 minutes on the hardest problem before finishing easier ones run out of time. The 20-60-20 split exists to prevent exactly this. Solve the problem you can lock first.

Plagiarism and Keystroke Footprints

Copying from GitHub or an AI tool leaves a code-signature and keystroke-cadence trail that HackerRank's plagiarism checks flag. A similarity hit can void the attempt even when the logic is correct.

Indexing and Sign Bugs in Simulation

Simulation problems like Array Challenge fail on off-by-one and sign mistakes. Walk a tiny hand-traced example before trusting the loop bounds, since these bugs rarely show in the sample.

How to Prep for the JPMorgan HackerRank OA

Preparation pays off most on the problem families JPMorgan Chase actually repeats. Targeted practice beats a random LeetCode binge.

Prioritize Interval, Sweep-Line, and Difference-Array Problems

Interval and sweep-line mechanics appear three or four times across the confirmed bank: Minimum Cores, Maximum Concurrent Tasks, Meeting Scheduler, and Merge Intervals. Difference arrays back Interval Flip Operations. Drill these patterns first.

Set Up Your Language Before Test Day

Confirm Java, Python, or C# (or C/C++ per the batch) before the invite arrives. A surprise language switch wastes minutes you cannot spare in a 60-minute window. Write one throwaway function in the editor ahead of time if you can.

Mock Under the 60-Minute Constraint

Run two problems back-to-back on a 60-minute timer with hidden edge cases you must self-test. The format is unforgiving on clock management, and a timed mock is the only way to feel the pressure before the real attempt.

In the days before the OA, I used the Prep Agent from interviewfox.ai over WhatsApp: I sent it the interval and sweep-line patterns JPMorgan repeats, and it built a drill plan around exactly that.

What Happens After You Submit the JPMorgan HackerRank OA

Submission is not the end of the funnel, but the candidate gets little visibility after it. The result moves to a reviewer while you wait.

Auto-Eval Then Recruiter Review

HackerRank auto-evaluates against hidden cases, then the result goes to the ATS for an engineer or recruiter screen before any reply. A human looks at the score, but you will not see it.

Silence Usually Means Rejection

Multiple candidates report no response when they were not shortlisted. Some r/leetcode posters say they passed every test case and still never moved on, which suggests JPMorgan resume-screens after the HackerRank rather than advancing purely on score. A quiet inbox after a few weeks is the usual signal of a pass, not a delay worth waiting on.

Next Steps and the Reapply Window

A shortlist leads to a live screen on CoderPad or HackerRank, then a HireVue step, then Superday. If you are not selected, the reapply window is generally six to twelve months.

FAQ

What questions appear on the JPMorgan Chase HackerRank test?

The standard SWE OA gives two coding problems. My test had Minimum Cores Required and Interval Flip Operations. About ten more named problems circulate beyond those two.

How long is the JPMorgan Chase OA and what does it cover?

The SWE and intern OA is 60 minutes with two coding problems. Batches that bundle an aptitude section run 90 minutes. Problems are LeetCode-style, easy to medium.

Is the JPMorgan HackerRank Reddit discussion reliable?

Reddit threads match my experience on the two-problem format and the interval-heavy bank. Recent r/csMajors posts from 2025 candidates describe the OA as two easy-to-medium questions finished in 20–30 minutes, while r/leetcode threads note that perfect scores do not guarantee a reply because JPMorgan resume-screens after the test.

Treat single posts as one data point, not confirmation of a cutoff or a fixed question list.

Does JPMorgan Chase show a HackerRank score after submission?

No. The score is hidden and sent to the recruiter or ATS. The candidate sees no number and cannot tell from the UI whether the attempt advanced.

What languages can I use for the JPMorgan HackerRank OA?

An official posting restricts the languages to Java, Python, and C#. Some batches also accept C and C++. Confirm the allowed set for your role before test day.

Can HackerRank detect an overlay or AI tool during the JPMorgan OA?

Yes. HackerRank's Desktop App Mode adds OS-level monitoring, and Proctor Mode's screenshot analysis flags overlay apps and external AI assistants. One candidate's overlay attempt was interrupted and marked invalid mid-test.

Can I use an AI tool or invisible app during the JPMorgan 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.

interviewfox.ai pushes the answer to your phone, a physically separate device no screenshot or session monitoring can reach, so the laptop screen stays on the exam editor. If you use AI help during the OA, the dual-device design removes the answer from your screen entirely.