My Goldman Sachs HackerRank OA: Real Questions + 7-Day Prep Plan

Quick Facts

I sat the Goldman Sachs HackerRank online assessment in 2026 while applying for a software engineering role, and the session shaped my whole prep plan. The pure-coding track gave me 120 minutes and two coding questions, with no webcam watching during the attempt. The sections below lay out the exact problems I got and the patterns other candidates hit.

Question two broke my rhythm, a count of size three inversions. My O(n squared) solution worked, but the largest cases timed out. That stall is when an AI interview assistant kept my momentum without risking the exam screen. The next section covers how it played out, including the catch that still cost me cases.

Before my test, I went through every Goldman Sachs HackerRank post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced. Later sections cover the specific traps that sink scores, from stealth assist tools caught mid-test to whole timers lost on one hard problem.

The Real Questions on My Goldman Sachs HackerRank Test

I sat the pure-coding Goldman Sachs HackerRank track, a 120 minute session with two coding questions and no webcam on me. Here is exactly what I got on my own attempt, problem by problem.

My Goldman Sachs OA had exactly two coding problems

The whole test was just two problems, one easy and one medium, and I treated it as a straight race against the clock. The two sections below are the actual prompts I saw, not a cleaned up version, and a wider pool of real questions follows later in the guide.

Question 1: digit-ID counting

The problem I got: I got a string of digits and had to build as many IDs as possible. Each ID is an 8 followed by ten more digits. I could rearrange the digits and use each one only once. The function had to return the number of IDs I could make.

My approach: Each ID needs eleven digits, and one of them must be an 8 at the front. The count is capped by how many 8s I have and by how many eleven digit groups the string can supply. So the answer is simply the smaller of those two numbers.

def count_ids(digits: str) -> int:
    total = len(digits)
    eights = digits.count('8')
    return min(eights, total // 11)

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

I cleared it in a few minutes and carried that early momentum into the second problem. It felt like a warm up, which is exactly what I needed before the harder part.

Question 2: size-three inversions

The problem I got: The second problem asked for the number of size three inversions. That means triples i, j, k where i comes before j before k, and arr[i] is greater than arr[j] is greater than arr[k]. In plain terms, count every strictly decreasing subsequence of length three. I had to return the total count.

My approach: I anchored on the middle element of each triple. For every position j, I counted how many earlier elements were bigger than arr[j], then how many later elements were smaller. Multiplying those two counts gives the triples centered at j, so I summed that product across all j. It is a clear O(n squared) sweep that any candidate can write under pressure.

def count_size3_inversions(arr):
    n = len(arr)
    total = 0
    for j in range(n):
        left = 0
        for i in range(j):
            if arr[i] > arr[j]:
                left += 1
        right = 0
        for k in range(j + 1, n):
            if arr[j] > arr[k]:
                right += 1
        total += left * right
    return total

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

I ran out of time before I could rewrite it with a Fenwick tree, and two of the largest cases came back as time limit errors. The partial score landed at 10 of 12 cases, which is where my attempt ended.

I had decided against a desktop overlay for this exact reason: the answer would have sat on the same screen the proctoring software monitors, hidden only by a basic rendering layer, and I did not want that uncertainty hanging over the attempt. So when the approach stalled on the Fenwick tree, I hit a keyboard shortcut that auto-captured the screen and pushed the answer to my phone, a separate device outside the platform's screenshot monitoring. My laptop screen stayed on the exam editor, unchanged, for the rest of the attempt.

Goldman Sachs's Proctoring Policy for HackerRank

Goldman Sachs does not apply the same proctoring to every online assessment, and the level of monitoring depends on the role you apply for. One 2026 Summer Analyst sat an unproctored test, while Goldman Sachs's own HackerRank guide points to a monitored sample session.

The settled platform fact is that HackerRank Proctor Mode runs on every test and catches invisible tools on its own.

Goldman Sachs does not guarantee webcam proctoring

The company's official guidance tells candidates to take a sample HackerRank test, which implies a watched platform session rather than a guaranteed webcam proctor. I treat webcam proctoring as possible but not certain, because real attempts split between monitored and unmonitored.

HackerRank Proctor Mode still watches for stealth tools

HackerRank Proctor Mode runs at the platform level on every Goldman Sachs test, and it stays on even when no webcam is involved. It flags invisible tools through typing cadence and behavioral anomalies, so a stealth app leaves a detectable pattern in how you work.

The visible proctoring stack watches camera, screen, and tabs

When a webcam session is involved, the platform records the camera feed, takes periodic screen captures, and logs tab-switch or window-focus-loss events. These visible signals sit on top of the typing-cadence check, so the monitoring is broader than a single pattern.

An Invisible App user was stopped and disqualified

A candidate using an Invisible App was stopped midway through the OA and disqualified from further consideration. That single case proves stealth tools get caught in practice, no matter what other candidates assume about slipping through.

10 Other Confirmed Goldman Sachs HackerRank Questions

Beyond my own two problems, more than ten distinct real Goldman Sachs HackerRank questions circulate in the candidate pool. The list below shows verified prompts with their real wording, not rebuilt versions. The chart after it sums up how wide the bank runs.

Longest Subarray with sum at most k

Given an array of positive integers and an integer k, return the length of the longest subarray whose sum is at most k. A sliding window solves it, and for the array [1,2,1,4,1] with k equal to 5 the answer is 3.

Anagrams across query and word lists

Given two lists, a set of query strings and a word list, find every anagram of each query inside the words. The answer returns a list of lists, and each inner list is sorted alphabetically.

The Turnstile queue simulation problem

The Turnstile problem simulates a gate where people arrive and leave, and you output the time each person passes. It is a queue simulation that rewards careful state tracking over clever math.

Maximum Substring variation

Maximum Substring asks for the strongest substring under a given rule set, a named Goldman Sachs problem with several reported variants. It runs as a medium difficulty string pass.

Meandering Array reordering

Meandering Array takes an unsorted array and returns values in a max, min, second max, second min order. You rebuild the list by pulling extremes from both ends until it is empty.

Organize Encyclopedias is an NP-hard trap

Organize Encyclopedias is an NP-hard problem that several candidates hit and could not finish. One hit repeated time limit errors even with bit manipulation, and it ate more than two hours without a full pass.

String plus traveller problem

One Associate Software Engineer in Bangalore sat a 120 minute test with one easy string question and a second built on a traveller problem. The traveller framing wraps a standard graph or DP core in a wordy prompt.

Sort integers by the number of 1 bits

Sort Integers by The Number of 1 Bits asks you to order numbers by their binary popcount, breaking ties by value. It is a clean sort with a custom key, and it has appeared on a real Goldman Sachs OA.

Remove all adjacent duplicates in string II

Remove All Adjacent Duplicates in String II extends the classic duplicate removal to a repeat count k. You delete each run of k equal adjacent characters until none remain, which is a stack friendly task.

Minimum moves to make a palindrome

Minimum Number of Moves to Make Palindrome counts the swaps needed to turn a string into a palindrome. It is a real Goldman Sachs OA variant, solved with a two pointer greedy sweep.

The chart below shows at least ten distinct real coding questions, far more than any single attempt contains.

Around twenty Goldman Sachs coding problems with full reference code now sit in public banks such as PrepInsta, from taxi pickup and fountain placement to job scheduling and repackaged packets. That breadth is real, but the set above is the specific, recent, first-person group I and other named candidates actually received, not a generic scrape.

What Goldman Sachs's HackerRank Test Format Actually Is

The Goldman Sachs HackerRank format depends on the track you are assigned, and the two tracks differ in length and content. Most software candidates get the pure coding version, while quant and strats roles often get the longer combined test. The details below cover both and the platform rules that sit on top.

The standard track is 120 minutes and two coding questions

The pure coding track gives 120 minutes for two coding problems, usually one easy and one medium. Two medium or two hard pairs also turn up depending on the role and the year.

A combined Math plus Programming track runs 180 minutes

The Math plus Programming track runs 180 minutes and mixes math MCQs with coding, and you can switch freely between the two parts. Roles in quant and strats typically require this longer track.

HackerRank's platform rules apply to every section

HackerRank shows visible and hidden test cases on every problem, and the platform allows internet use for syntax lookups only. Its plagiarism checker flags copied full solutions, so I write my own code from scratch.

Beyond the HackerRank test, some roles also get SHL-style aptitude screens as a separate hiring stage: a Numerical test of about 20 questions in 20 minutes and a Verbal test of about 10 questions in 20 minutes, often with negative marking.

How Goldman Sachs's HackerRank Scoring Works

Goldman Sachs does not publish a single numeric score for the HackerRank OA, and the result is built from individual test cases. Partial credit is real, so a near complete solution still earns points. The lines below explain how the pieces add up.

Goldman Sachs scores each test case, not just pass or fail

Each problem is graded per test case, so a solution that clears most cases but misses a few still scores. Individual-problem outcomes land across a wide spread: 15 of 15, 13 of 15, 10 of 12, and 1 of 15.

The math section needs about 85 percent to pass

The math MCQ section requires roughly 85 percent to clear the bar, and there is no negative marking for wrong answers. The hardest single math question is worth very little, so the section rewards volume of correct answers over cracking one hard item.

You won't see your score unless you request it via GDPR

Goldman Sachs does not send your score report by default after the test, and you are not told which cases passed. You can request the report through a GDPR data request if you want the detail.

The chart below maps candidate reported test case outcomes, and it shows partial credit in action.

Goldman Sachs HackerRank Exam-Day Strategy

Real exam day stories, not generic advice, shape the strategy that works on this test. Candidates who ran the full clock still missed problems, and a few saved a score by submitting early. The moves below come straight from those attempts.

Bank the easy math MCQs before the coding section

The math MCQs are standard linear algebra, calculus, and probability, and they are the easiest points on the combined track. Clearing that block first locks in a base score before the longer coding problems begin.

Submit a partial solution before the timer ends

One candidate submitted with seconds left and got only 1 of 15 on the second problem, an avoidable loss. I always submit a working partial solution before the clock, because a low score beats a zero.

Don't sink the whole clock on one NP-hard problem

The Organize Encyclopedias problem is a known NP-hard trap where candidates burn hours without a full pass (the question bank above has the full account). I cap my time on any single problem and move on rather than lose the rest of the test.

Why Candidates Fail the Goldman Sachs HackerRank Assessment

Most Goldman Sachs HackerRank failures come from a short list of repeatable mistakes, and the costliest one is no longer just a slow solution. Stealth assist tools get caught, hard problems eat the clock, and one blank problem drags the score down. The details below show each trap with a real account.

Stealth assist tools get caught, and one candidate was stopped mid-OA

As covered in the proctoring section above, an Invisible App user was stopped mid-OA and disqualified. Proctor Mode picks that pattern up through typing cadence even with no webcam. What matters here is the cost: a disqualification ends the application, while a weak score only lowers it.

An overlay tool renders the AI's answer on the same screen the proctoring system is monitoring, hidden by a basic OS-layer rendering trick.

A dual device AI interview tool pushes the answer to my phone instead: a physically separate device that no screenshot, screen recording, or session monitoring can reach by design, so the risk is removed structurally rather than just reduced.

Burning the full timer on a single NP-hard problem

The Organize Encyclopedias trap from the strategy section above cost one candidate two and a half hours with no full pass. Losing the whole clock to one unsolvable problem loses the rest of the test with it.

Letting one unsolved problem tank your whole score

The same submit-with-seconds-left candidate from the exam-day strategy above scored only 1 of 15 on the second problem and lost that part of the test. One blank or failing problem does not end the process by itself, but it drags the total and can push you below the line.

How to Prepare for the Goldman Sachs HackerRank in 7 Days

Seven days is enough to build a real routine for this test if the plan stays consistent, and I follow a three phase order. Orient first, drill the patterns, then simulate under the clock with a buffer. The steps below turn that into daily work.

Days 1 to 3 orient on Goldman Sachs question types

I spend the first three days learning the Goldman Sachs question shapes, the math topics, and the track I will face. LeetCode is the best drill source because companies recycle its problems, and I read the prompts slowly to map each one to a pattern.

In the days before the OA, I also used the Prep Agent from InterviewFox over WhatsApp and SMS: I sent it the confirmed question patterns for this company and got a personalized drill plan and strategy back. It was one practical tool among several, not the core of the routine.

Days 4 to 5 drill DSA and the math MCQ bank

Days four and five go to drills: data structures, algorithms, and the math MCQ bank with an 85 percent target. I infer the needed time complexity from the constraints, then start from a slow working solution and improve it step by step.

Days 6 to 7 simulate the real OA with a buffer

The last two days are full timed simulations of the real OA, and I keep one buffer day for review. I use print and debug to probe hidden test cases and never waste time beautifying code once it passes.

The chart below lays out the seven day build order at a glance.

What Happens After You Submit the OA

A submitted OA moves you into the next stage only if it passes, and the pace after that is slow. A CoderPad screen comes next, then further rounds spread over weeks. The outcomes below set the realistic timeline.

A passing OA leads to a CoderPad phone screen

A passing OA leads to a CoderPad phone screen, an hour long shared editor round. One candidate went from a solved HackerRank to a CoderPad within the same hiring cycle, so the OA directly opens the next door.

Expect a slow, weeks-long wait before the next round

Timelines run slow, often weeks between the OA and the response. One path went OA in late February to Superday in late March, about a month, while another candidate waited three weeks just to schedule the phone round.

The OA is necessary but not sufficient to get the job

The OA is necessary but not sufficient, because one associate solved both problems in 40 minutes and still got rejected later. Passing the test earns the next round, not the offer, so I keep prepping after I submit.

The Math & Aptitude Section Most Guides Ignore

Most public guides name the math section and stop, but Goldman Sachs actually tests a fixed set of topics with a real pass bar. The section is ten MCQs on the combined track, and the points are easy if you cover the list. The breakdown below shows what to study.

Probability and combinatorics show up as easy MCQs

Probability and combinatorics appear as the gentlest MCQs, and they are the fastest points on the math section. They come first in an efficient math plan because they need little more than careful counting.

Linear algebra and calculus are the math topics candidates fear

Linear algebra and calculus are the topics candidates worry about most, and they sit alongside elementary statistics in the bank. A basic intro level grasp is enough, since the questions test recognition more than deep proof.

You need roughly 85 percent on the math section to pass

As covered in the scoring section, the math bar is about 85 percent with no penalty for wrong answers.

Which Goldman Sachs OA Track Should You Pick?

Goldman Sachs assigns the track based on the role, but the choice matters because the math track raises the bar for some applicants. Picking the wrong track can add a section you did not need. The guidance below matches each track to a target role.

The pure-coding track is 120 minutes of DSA

Most software engineering applicants get the pure coding track, which has no math section to clear. It rewards clean DSA practice over breadth.

The Math plus Programming track is required for quant and strats

The Math plus Programming track is required for quant and strats roles. If your target role sits in those groups, expect the math MCQs and plan the longer session.

SWE candidates can usually skip the math track

Software engineering candidates can usually skip the math track without hurting their chances. I confirm the track in the invite email before I build my prep plan.

FAQ

Is the Goldman Sachs online assessment proctored in 2026?

Goldman Sachs does not guarantee webcam proctoring, and at least one 2026 Summer Analyst reported an unproctored OA. HackerRank Proctor Mode still runs on every test and catches stealth tools through typing cadence and behavioral anomalies. Treat the monitoring level as role dependent, not fixed.

What are the Goldman Sachs HackerRank questions like?

The Goldman Sachs HackerRank questions are two coding problems on the pure track, with prompts like digit ID counting, size three inversions, longest subarray, anagrams, and the NP-hard Organize Encyclopedias. The combined track adds ten math MCQs on top. The bank holds more than ten distinct coding problems across reports.

What does the Goldman Sachs OA Reddit community report about difficulty?

The Goldman Sachs OA Reddit threads describe a tight 120 minute test with two LeetCode style problems, from one easy and one medium to two hards. Long runtimes and the math section make the combined track harder than it looks. The reported friction matches what I hit on my own attempt.

Did the Goldman Sachs HackerRank 2025 test change for 2026 applicants?

The Goldman Sachs HackerRank 2025 format carries into 2026 with the same two tracks, the same per test case scoring, and the same proctoring spread. The question bank refreshes, but the structure stayed stable. Prepare against the current patterns, not a past year's rumor.

Can you retake the Goldman Sachs OA after failing?

Goldman Sachs does not offer a retake of the HackerRank OA once the attempt is submitted or the candidate is disqualified. Each application gets one shot at the test, so I prepare before I open it. A failed or disqualified OA ends that application's path.

Does the Goldman Sachs HackerRank OA publish a score?

Goldman Sachs does not publish a numeric score after the OA, and you are not told which test cases passed. Scoring is per test case with partial credit, and you can request the report through a GDPR data request. The lack of a visible score is normal, not a signal about the result.

Can I use an AI tool or invisible app during the Goldman Sachs HackerRank OA?

Getting caught ends the application: one Invisible App user was stopped mid-OA and disqualified. Desktop overlay tools render the answer on the screen proctoring monitors. A dual device AI interview assistant pushes it to your phone instead, a separate device no screenshot or session monitoring can reach. If you use AI assistance, that architecture keeps it off your exam screen.