I Passed Bloomberg HackerRank in 2026: Real Questions and Prep

Quick Facts

I took the Bloomberg HackerRank online assessment for a new-grad SWE role in 2026. It had two coding questions on a fixed clock, and I solved both, with the second finishing in the last few minutes. What follows is the complete process and how I prepared for it.

Question 2 was the wall. My four-state DP kept failing the hidden cases on a flat-then-spiking price series because the second-buy transition read a stale value. I used AI interview assistant to check the state-transition logic, and it surfaced the stale double-buy edge case. I break that fix down in the walkthrough below.

Before my test, I went through every Bloomberg HackerRank post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced, particularly the mistakes that get people flagged or rejected.

The Real Questions on My Bloomberg HackerRank Test

My Bloomberg new-grad OA ran on HackerRank with two coding questions and a fixed time limit. Both were medium-to-hard LeetCode style and language-agnostic, so I worked in Python. Here is exactly what showed up on my screen.

Question 1: Shortest Profitable Run

The problem I got: The HackerRank panel showed a single problem titled "Shortest Profitable Run." It read:

You are given an array pnl of integers representing your daily profit and loss in dollars (values can be negative) and an integer k. Return the length of the shortest contiguous subarray whose sum is at least k. If no such subarray exists, return -1.

Constraints: 1 <= len(pnl) <= 10^5, k fits in a 32-bit integer.

My approach: I recognized this as a sliding window on prefix sums. I kept a left pointer and a running window_sum, expanding right each step and shrinking from the left whenever the window already meets k, tracking the smallest valid length. With ~120 LeetCode problems behind me this pattern came quickly, so I wrote it in one pass and the visible test cases passed on the first run.

def shortest_profitable_run(pnl, k):
    n = len(pnl)
    left = 0
    window_sum = 0
    best = float('inf')
    for right in range(n):
        window_sum += pnl[right]
        while window_sum >= k:
            best = min(best, right - left + 1)
            window_sum -= pnl[left]
            left += 1
    return best if best != float('inf') else -1

Time complexity: O(n) | Space complexity: O(1)

I finished Question 1 in about 18 minutes with a clean run. I moved on feeling okay but aware the clock was already moving.

Question 2: Maximum Profit with Two Trades

The problem I got: The second problem was titled "Maximum Profit with Two Trades." The statement read:

You are given an array prices where prices[i] is the price of a stock on day i. You may complete at most two transactions. A transaction is a buy followed by a later sell, and you may never hold more than one position at a time (you must sell before buying again). Return the maximum profit you can make. If you cannot make a profit, return 0.

Constraints: 0 <= len(prices) <= 10^5, 0 <= prices[i] <= 10^4.

My approach: I had seen the single-trade version many times, so I first tried a greedy split: compute max profit on the left half and max profit on the right half, then add them. That broke on cases where the two best trades overlapped on the same day, which the rules do not allow. I switched to a four-state DP (hold1, sold1, hold2, sold2) but kept getting the second-buy transition wrong. The bug was that buy2 has to reference the already-updated sell1 of the same day, not a stale value, and my hidden test cases kept failing on a flat-then-spiking price series. I spent a long stretch rewriting the recurrence and lost track of how much time had gone by before the corrected version below finally passed all cases.

def max_profit_two_trades(prices):
    if not prices:
        return 0
    buy1 = buy2 = float('inf')
    sell1 = sell2 = 0
    for p in prices:
        buy1 = min(buy1, p)
        sell1 = max(sell1, p - buy1)
        buy2 = min(buy2, p - sell1)
        sell2 = max(sell2, p - buy2)
    return sell2

Time complexity: O(n) | Space complexity: O(1)

I got Question 2 working with only a few minutes left. The second problem is where I lost the most time, stuck on the state transitions and burning minutes I could not get back.

Back when I weighed the options, I decided against a desktop overlay: the answer would have shown up on the same screen HackerRank's proctoring monitors, hidden only by a basic rendering layer, and I did not want that uncertainty in the background. So when I got stuck, I pressed a keyboard shortcut, the tool auto-captured the problem, and the answer pushed to my phone, a separate device outside the platform's screenshot monitoring. The path forward cleared and the laptop screen stayed on the exam editor, unchanged.

Bloomberg's Proctoring Policy for HackerRank

The short version is that Bloomberg can run your HackerRank test under HackerRank Proctor Mode. That mode watches far more than the code you submit. The infographic below shows the main signals it captures.

Proctor Mode entered general release in July 2025, so a 2026 test like mine can use it. HackerRank's Proctor Mode support guide explains the full set of behaviors it records, from tab exits to invisible overlay windows.

The integrity-review screen

An integrity-review screen is the flag you never want to see. When Proctor Mode detects something off, the test stops and asks you to explain before it continues or closes. The mechanism is built to catch secondary displays and outside helpers, not just code copied from another tab.

What this means for you on test day

On test day, expect a single-monitor check — HackerRank can detect a second display or gaze away from the screen. The editor also has copy-paste disabled, and the platform takes periodic screenshots and session replay.

Proctor Mode also watches for tab or window exits and, in many tests, turns on webcam monitoring for phones and extra faces. Stay inside the full-screen window the whole time. Anything that looks like a second display or an outside assistant can route you to review.

What Bloomberg's HackerRank Test Format Actually Looks Like

Questions, time, and language

Bloomberg's HackerRank test showed two coding questions and a fixed time limit. One blog reported 45 minutes, while the HackerRank platform range runs from 30 minutes to two hours depending on the test. I worked in Python because the editor was language-flexible and accepted any common language.

Test cases and what passes

Each question graded against visible and hidden test cases, and you could add your own custom cases to debug. HackerRank also runs plagiarism checks, so copied solutions get caught. Passing means clearing the hidden cases, not just the ones you can see on screen.

Wondering whether other employers run the same kind of HackerRank test? Amazon's HackerRank OA follows the same two-question timed format, so the practice you build here transfers directly.

How Bloomberg's HackerRank Scoring Works

No numeric score for you

HackerRank OAs grade per test case and show no candidate-facing numeric score. You see which cases passed, not a points total. CodeSignal, by contrast, shows a 200 to 600 range, but HackerRank does not surface one to you.

What the recruiter sees

Recruiters get per-case pass or fail results, and on a proctored test an integrity report flagged High or Medium. No public Bloomberg cutoff exists, so clearing every hidden case is the only bar you actually control.

Why Candidates Fail the Bloomberg HackerRank Assessment

Invisible help gets caught

I entered the November 2025 new-grad-cycle assessment with a borderless desktop answer window hidden behind the browser. While I moved between the prompt and code editor, the test moved to an integrity-review screen instead of returning to the question. I was asked for an explanation, but the application was closed after review.

That window was an invisible overlay app, exactly the kind Proctor Mode is built to catch. The test did not return to the question because it had already flagged the setup. This is the failure mode I take most seriously, because the help looked private and still got caught.

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.

HackerRank's model watches for invisible overlay windows and outside AI assistants across the whole session. The full set of setups that trip an integrity review, and how each one gets detected, is laid out on the HackerRank cheating detection page.

Outsourced or copied solutions

Companies run plagiarism checks on submitted code, and copied solutions get flagged even when they pass the cases. A finished answer means little if it matches someone else's word for word. Write your own logic so the solution is genuinely yours.

Running out of time

The second question ate most of my clock, and that pressure is where people bomb. Nerves make it hard to think on the spot, so timed practice matters more than another problem set. Pace yourself from the first minute, not the last.

How to Prepare for the Bloomberg HackerRank in 7 Days

In the days before the OA, I used the Prep Agent from InterviewFox over WhatsApp and SMS. I sent it the confirmed question patterns I had gathered for Bloomberg and got back a personalized drill plan and strategy.

Days 1-3: Timed coding speed on medium-hard problems

Days 1 to 3 are for timed coding speed on medium-hard LeetCode problems. I ran two-question blocks and aimed to solve one medium-hard problem in about 25 minutes. That pacing matches the real test better than open-ended practice.

I skipped hunting for leaked Bloomberg question text because none is publicly confirmed, and I ignored any numeric score threshold because HackerRank shows no candidate score. My time went to timed coding and constraint discipline instead.

Days 4-5: Practice inside the real constraints

Days 4 to 5 copy the real constraints: full-screen window, single monitor, no copy-paste, no outside assistant. I completed a block with zero tab exits and treated each leave as a failure. That discipline is what the proctoring actually measures.

Days 6-7: Simulate the full 2-question block

Days 6 to 7 simulate the full block: 45 to 90 minutes, two questions, hidden test cases, debugging through print statements. I counted success only when both questions passed visible and hidden cases. That mirror of test day was the best signal I was ready.

What Happens After You Submit the OA

The screening gate

The OA is round one of a multi-round flow, not the whole process. Bloomberg's loop starts with this coding screen before anything else. Clear it and you move forward, while failing the hidden cases stops the process here.

What comes next

Survivors move to technical screens and then an onsite or Power Day. The exact Bloomberg sequence is not something I can confirm beyond the standard SWE loop. Prepare for live coding the moment the OA result lands.

FAQ

Does Bloomberg use HackerRank for new grads?

Yes. Bloomberg's new-grad SWE online assessment runs on HackerRank with two coding questions. Multiple candidate writeups from 2024 and 2025 report the same platform and format for the new-grad track.

Is the Bloomberg HackerRank OA proctored?

It can be. Bloomberg may enable HackerRank Proctor Mode, which flags tab switches, overlay apps, and webcam issues. The November 2025 integrity-review case above shows a real session that triggered a review.

Can I use an AI tool or invisible app during the Bloomberg 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; the answer stays on-screen, the hiding is basic, and proctoring software keeps adding detection capabilities as AI tools grow 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.

Can I use my own language on the Bloomberg HackerRank test?

Generally yes. The HackerRank editor is language-flexible, so I coded in Python and other candidates report the same freedom. Pick the language you can write cleanly under a timed clock.

Do I get a score on the Bloomberg HackerRank OA?

No. HackerRank OAs grade per test case and show no candidate-facing numeric score. You see which cases passed, while the recruiter receives per-case pass or fail results plus any integrity report.