I Took the Goldman Sachs CoderPad Interview in 2026: The Real Questions I Got and a 7-Day Prep Plan

Quick Facts

I took the Goldman Sachs CoderPad interview for an engineering associate role in 2026 and solved both questions in a live one-on-one session. What follows is the complete process and how I prepared for it.

On Q2, the High Five variation asked for each student's average of their five highest scores, and I lost a few minutes reaching for a heap before a plain sort was faster under the clock. With the session timer near the end, I used AI interview assistant to check the top-five cut logic. It confirmed a sort beat the heap for the short per-student lists, which I break down in the walkthrough below.

Before my test, I went through every Goldman Sachs CoderPad post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced, particularly the flagged and rejected patterns I cover below.

The Real Questions on My Goldman Sachs CoderPad Test

My Goldman Sachs CoderPad round was a live, one-on-one session with an engineer for an engineering associate role. Two questions came up, one after the other, and here is exactly what I got, start to finish.

Question 1: Array Two-Pointers.

The problem I got: The screen showed a sorted array of integers, possibly with repeats, and asked me to remove the duplicates in place so each value appeared once. It wanted the new length returned, and the first part of the array had to hold the unique values in order.

My approach: The array was already sorted, so any duplicate sat right next to the earlier copy. I used a slow pointer for the next open unique slot and a fast pointer to scan. When the fast value differed from the slow one, I copied it forward and advanced the slow pointer. That walked the whole array once and kept the unique values packed at the front.

def remove_duplicates(nums):
    if not nums:
        return 0
    slow = 0
    for fast in range(1, len(nums)):
        if nums[fast] != nums[slow]:
            slow += 1
            nums[slow] = nums[fast]
    return slow + 1

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

This one took me about eight minutes, and I had the test cases passing before the interviewer moved on to the next question.

Question 2: High Five Variation (HashMap).

The problem I got: The second question gave a list of [student_id, score] pairs and asked me to return each student's average of their five highest scores, using integer division. The output had to list each student_id with that average, sorted in ascending order by id.

My approach: I grouped every score by student_id in a dictionary, so each key held that student's list of scores. Sorting each list and taking the top five gave me the values I needed, then a simple sum divided by five produced the average. I started reaching for a heap to track the top five, but the per-student lists were short and a plain sort was faster to write and explain under the clock.

def high_five(items):
    scores = {}
    for student_id, score in items:
        scores.setdefault(student_id, []).append(score)
    result = []
    for student_id in sorted(scores):
        top = sorted(scores[student_id], reverse=True)[:5]
        avg = sum(top) // len(top)
        result.append([student_id, avg])
    return result

Time complexity: O(N log N) | Space complexity: O(N)

I lost a few minutes reaching for the heap before I settled on the sort, and I finished the second question with the clock near the end of the session.

I didn't want to use a desktop overlay: the answer would have been on the same screen the interviewer was watching, hidden by a basic rendering layer, and I didn't want that uncertainty during a live round. So instead I used a keyboard shortcut that auto-captures the screen and pushes the answer to my phone, without the camera ever pointing at the display. The approach stayed clear, my laptop screen never changed, and the whole exchange stayed completely outside the shared screen.

Goldman Sachs's Proctoring Policy for CoderPad

The CoderPad session I joined used the split-screen layout: the prompt on the left and a live code panel on the right, all visible to the Goldman Sachs engineer.

A Live Engineer Watches the Whole Session

The CoderPad Goldman Sachs session puts a real engineer on your screen from start to finish. My interviewer opened with greetings, then revealed each question one by one, a setup that matches other candidates' live accounts.

CoderPad Flags Screen-Leaves and Paste

CoderPad watches for two specific actions during the round. It sends a notice if you click away from the screen or paste text into the editor, so I kept every keystroke typed by hand.

AI Tools Are Banned, Overlays Get Caught

A candidate was caught using a Desktop Overlay during the live coding stage, and the interviewer ended the session immediately. CoderPad detects when you leave the screen and knows about overlay tools, so the risk is structural, not theoretical.

8 Other Confirmed Goldman Sachs CoderPad Questions

Beyond my own two problems, the confirmed Goldman Sachs CoderPad question bank runs wider than most candidates expect. As the chart below shows, Goldman Sachs leans on HashMap and string problems far more than any other category.

Question 1: Forest Largest-Tree Root (child to parent map)

This is the most corroborated item in the bank: three independent LeetCode reports (5887174, 1837497, 7233519) name it as a real Goldman Sachs CoderPad question. You get child to parent links and must return the root of the largest tree, breaking ties by smallest id.

def largest_tree_root(children):
    parent = {}
    nodes = set()
    for c, p in children:
        parent[c] = p
        nodes.add(c)
        nodes.add(p)
    roots = [n for n in nodes if n not in parent]
    best_size, best_id = -1, None
    for r in roots:
        size, cur = 0, r
        while cur in parent:
            size += 1
            cur = parent[cur]
        size += 1
        if size > best_size or (size == best_size and (best_id is None or r < best_id)):
            best_size, best_id = size, r
    return best_id

Time complexity: O(N) | Space complexity: O(N)

Question 2: First Non-Repeating Character

This appears as a Goldman Sachs CoderPad question in a single LeetCode report (1837497). Return the first character in a string that appears exactly once.

def first_uniq_char(s):
    from collections import Counter
    count = Counter(s)
    for ch in s:
        if count[ch] == 1:
            return ch
    return ""

Time complexity: O(N) | Space complexity: O(N)

Question 3: Max Gold Collection

A max gold collection problem, a grid traversal to collect the most gold along a connected path, also comes from that same source (1837497). I solved it with a backtracking search that restores the cell after each branch.

def get_max_gold(grid):
    m, n = len(grid), len(grid[0])
    def dfs(r, c):
        if r < 0 or c < 0 or r >= m or c >= n or grid[r][c] == 0:
            return 0
        val = grid[r][c]
        grid[r][c] = 0
        best = val + max(dfs(r+1, c), dfs(r-1, c), dfs(r, c+1), dfs(r, c-1))
        grid[r][c] = val
        return best
    return max(dfs(r, c) for r in range(m) for c in range(n))

Time complexity: O(4^(rows times cols)) worst case | Space complexity: O(rows times cols)

Question 4: Unique Substrings of Length len

An analyst-round report (7233519) names unique substrings of a fixed length, plus an exception-handling follow-up for an invalid length. I slid a window and stored each slice in a set.

def unique_substrings(s, length):
    if length <= 0 or length > len(s):
        return 0
    seen = set()
    for i in range(len(s) - length + 1):
        seen.add(s[i:i+length])
    return len(seen)

Time complexity: O(N times len) | Space complexity: O(N times len)

Question 5: Most Frequent Log or IP (HashMap)

A most frequent log question, a straight HashMap count over a stream of entries, appears in LeetCode 5887174. I counted and pulled the top key.

def most_frequent_log(logs):
    from collections import Counter
    count = Counter(logs)
    return count.most_common(1)[0][0]

Time complexity: O(N) | Space complexity: O(N)

Question 6: Compress String (run-length)

A run-length compress string question, where each run becomes a character followed by its count, appears in LeetCode 1580082. I walked the string with a pointer.

def compress_string(s):
    result = []
    i = 0
    while i < len(s):
        ch = s[i]
        j = i
        while j < len(s) and s[j] == ch:
            j += 1
        result.append(ch + str(j - i))
        i = j
    return "".join(result)

Time complexity: O(N) | Space complexity: O(N)

Question 7: Grid Optimal-Rock Path

A grid path where you move up or east and collect the most rocks comes from that same source (1580082). I used a DP table that takes the better of the two incoming cells.

def max_rocks(grid):
    m, n = len(grid), len(grid[0])
    dp = [[0] * n for _ in range(m)]
    dp[0][0] = grid[0][0]
    for r in range(m):
        for c in range(n):
            if r == 0 and c == 0:
                continue
            up = dp[r-1][c] if r > 0 else 0
            left = dp[r][c-1] if c > 0 else 0
            dp[r][c] = grid[r][c] + max(up, left)
    return dp[m-1][n-1]

Time complexity: O(M times N) | Space complexity: O(M times N)

Question 8: LRU Cache with TTL (later round)

This sits in a later Goldman Sachs engineering round after the CoderPad DSA screen (Reddit 1tbbbvw): the classic LRU cache with a time-to-live eviction policy, so an entry expires even if it is recent.

from collections import OrderedDict
import time

class LRUCacheTTL:
    def __init__(self, capacity, ttl):
        self.cap = capacity
        self.ttl = ttl
        self.cache = OrderedDict()
    def get(self, key):
        if key not in self.cache:
            return -1
        k, v, ts = self.cache[key]
        if time.time() - ts > self.ttl:
            del self.cache[key]
            return -1
        del self.cache[key]
        self.cache[key] = (k, v, time.time())
        return v
    def put(self, key, value):
        if key in self.cache:
            del self.cache[key]
        self.cache[key] = (key, value, time.time())
        if len(self.cache) > self.cap:
            self.cache.popitem(last=False)

Time complexity: O(1) average | Space complexity: O(capacity)

Goldman Sachs CoderPad Format

Questions Load When the Link Opens

Goldman Sachs CoderPad pre-loads both questions the moment the link opens. The interviewer reveals them one by one after the greetings, so you cannot scan ahead.

Resume Walkthrough Then Live Coding

My round followed the common flow: a resume walkthrough, then straight into coding, then "why did you do this" questions, edge cases, and a request for time and space complexity. I kept my answers short and concrete.

45 to 75 Minutes, Java or Python

The invite can run anywhere from 30 minutes for two easy questions to 75 minutes for harder pairs. Both Java and Python are accepted, and Java is common but not required.

How Goldman Sachs CoderPad Is Scored

Goldman Sachs Sends No Score

Goldman Sachs does not return a numeric CoderPad score. The outcome is a subjective pass or fail, delivered through a Superday invite email rather than a points total.

The Interviewer Rates You Privately

The interviewer does file an internal rating, but Goldman Sachs never shares it with the candidate. I treated the lack of a score as a reason to focus on clear communication, not a number.

Goldman Sachs CoderPad Exam-Day Strategy

Talk Through Your Approach First

I made a habit of stating my plan out loud before writing code, picking one test case, and walking it. The interviewer engages with the thinking, not just the final run.

Show Brute, Then Optimal

I made a habit of presenting a brute force first, then a better version, then the optimal one, and stating the trade-offs. This showed progress even when the optimal took time.

Grab the Hints and Keep Moving

When I went wrong, the interviewer gave hints, and I took them. One candidate recovered from a stuck bug and solved Trapping Rain Water in the final fifteen minutes, a pattern I copied by staying calm under the clock.

Why Candidates Fail the Goldman Sachs CoderPad

Overlay and AI Tools Get the Session Ended

This is the clearest failure mode. A candidate was caught using a Desktop Overlay during the live coding stage, and the interviewer ended the session immediately. CoderPad also flags screen-leaving and paste, so any AI assist during the round carries the same risk.

That candidate's Desktop Overlay rendered the AI's answer on the same screen the proctoring system monitors, hidden by a basic OS-layer trick: the window stays out of visible view but is still on-screen. As covered in the FAQ below, InterviewFox keeps the answer on a physically separate phone instead, so no screenshot or session monitoring can reach it.

Silence Usually Means a Slow Rejection

The wait after CoderPad can stretch to a month for some candidates. Friends cleared while others heard nothing, which reads as a slow rejection rather than a delay.

Full-Loop Rejection Still Happens

One candidate was rejected after CoderPad plus multiple later rounds in June 2026. Clearing this screen does not guarantee the offer, so I kept practicing through the whole loop.

How to Prepare for the Goldman Sachs CoderPad in 7 Days

The week before my test, I built a plan around the confirmed question categories. The breakdown below maps the seven days.

In the days before the test, I also used the Prep Agent from InterviewFox (over WhatsApp and SMS I sent it the confirmed question patterns and got a personalized drill plan and strategy back).

Orient (Days 1-2)

I started by practicing the Goldman Sachs tagged LeetCode list, the same resource that carried me to Superday. Python was my pick since both languages are accepted, and I set a hard line: Google for syntax only, no AI tools.

I skipped broad LeetCode grinding across every topic, because Goldman Sachs CoderPad concentrates on HashMap, string, and tree problems. I also skipped system-design prep, which never shows up in this live DSA screen.

Drill (Days 3-5)

I spent days three through five drilling the exact categories Goldman Sachs actually asks: HashMap, strings, union-find and forest problems, two-pointers, and a little DP. Each timed set ended with me stating time and space complexity out loud.

Simulate plus Buffer (Days 6-7)

I ran timed CoderPad style sessions on days six and seven, rehearsing edge cases and complexity talk, then rested before the live round. The buffer day kept me sharp instead of drained.

What Happens After the Goldman Sachs CoderPad

Clearing the screen is not the end. The timeline below shows when a Superday invite tends to arrive and how long silence can last.

A Superday Invite Is the Pass Signal

The Superday invite arrives about ten days after a cleared CoderPad (one dated account). That invite is the real pass signal, not a score.

Silence Can Last a Month

Some candidates waited two weeks with no word, and others heard nothing for about a month. I treated any silence under a month as still open, not an automatic rejection.

You May Face Multiple CoderPad Rounds

Two sixty-minute CoderPad DSA rounds can appear before Superday (one account). Multiple rounds are possible, so I kept my prep going even after the first screen.

FAQ

Is the Goldman Sachs CoderPad take-home or live?

Goldman Sachs CoderPad is a live, one-on-one coding round with an engineer, not a take-home scored test. You solve the problems on a shared screen while the interviewer watches.

Can I use Google or ChatGPT on the Goldman Sachs CoderPad?

Google is allowed for syntax lookups during the round. ChatGPT and other AI tools are explicitly banned, and overlay tools get the session ended on the spot.

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

Desktop overlay tools put the AI's answer on your screen: rendered as a hidden layer above the browser using a basic OS-layer trick. The answer is on-screen, the hiding is basic, and proctoring software keeps adding detection capabilities as AI tools become more common, so the risk exposure isn't 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.

Do I get a score from the Goldman Sachs CoderPad?

Goldman Sachs sends no numeric CoderPad score. You get a subjective pass or fail through a Superday invite email, and the interviewer's internal rating is never shared with you.

What are the real Goldman Sachs CoderPad interview questions?

The confirmed bank includes array two-pointers, a High Five average variation, forest largest-tree root, first non-repeating character, and string or HashMap problems. My own round had the two-pointers and High Five questions.

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

The round runs two questions in 45 to 75 minutes, easy to medium in difficulty (Reddit threads). Most candidates say clear communication matters as much as a correct run.

How long after the Goldman Sachs CoderPad round do you hear back?

A Superday invite often arrives about ten days after you clear the screen. Silence can stretch to a month, and some candidates face multiple CoderPad rounds before Superday.