
My 2025 Goldman Sachs Quant Strats OA had two questions in total, one medium and one easy, all done on CoderPad. It took about a month after I applied before I finally got the CoderPad invite — the wait felt really long, but fortunately I’ve passed now.
I am really grateful for the tool Linkjob.ai, and that's also why I'm sharing my entire OA interview experience here. Having an undetectable AI assistant during the interview is indeed very convenient.

This is a typical data structure design problem. The core challenge is how to efficiently handle both capacity limits (the Buffer) and time window queries (the Window).
My Solution Strategy
My goal was to solve the problem efficiently. I used a dual data structure approach.
Primary Structure: Circular Buffer Simulation I used a Deque or List to simulate the circular buffer. Its sole responsibility is the FIFO logic: when capacity is full, the oldest log object is evicted from the front.
Secondary Structure: Hash Map for Query Acceleration I used a HashMap where the key is the log's tag, and the value is a Deque of all logs with that tag. This queue is strictly sorted by timestamp in ascending order. Transmission Logic: When a new log L_new arrives, I immediately retrieve the queue corresponding to its Tag from the HashMap. Because the logs in the queue are time-ordered, I can use a Sliding Window idea:
Continuously pop old logs from the head of the queue that are outside the transmission window.
The remaining logs in the queue are those that meet both the time window and tag requirements. I directly sum their count.
This method ensures that the query for each new log is efficient, avoiding a brute-force search over the entire circular buffer.


This is a maximization problem involving mutual constraints, which immediately suggested Dynamic Programming (DP) to me.
My Solution Strategy
The core of the problem is to select a team S such that any member D_i in S must satisfy their constraints regarding the number of people in the team with skill less than them (>= L_i) and skill greater than them (<= H_i).
Preprocessing and Sorting This is the crucial first step. I sorted all developer data based on their skill level (i) in ascending order. After sorting, people to the left of a developer D_i have lower skill, and those to the right have higher skill, which greatly simplifies the constraint calculation.
Dynamic Programming (DP) I defined DP[i]: the maximum team size that can be formed when the i-th developer (after sorting) is the person with the highest skill in the team. Recurrence Relation: DP[i] = 1 + max(DP[j] | j < i and Valid(j, i)) Constraint Check (Valid(j, i)): This is the most complex part. It ensures that after D_i is added to D_j's optimal team, the four constraints (L_i, H_i, L_j, H_j) of both D_j and D_i are still satisfied. For example:
For D_j: The count of people with higher skill than them (D_i counts as one) must be <= H_j.
For D_i: The count of people with lower skill than them (which is DP[j] people from D_j's team) must be >= L_i.
The final answer is the maximum value among all DP[i]. This DP strategy guarantees finding the largest team that satisfies all mutual constraints.
I have to say, Linkjob AI is really easy to use. I used it during the interview after testing its undetectable feature with a friend beforehand. With just a click of the screenshot button, the AI provided detailed solution frameworks and complete code answers for the coding problems on my screen. I’ve successfully passed the test, with the HackerRank platform not detecting me at all.

Challenge One: Log Transmission System
Circular Buffer
Deque or List as a FIFO structure
Hash Map for fast lookups/grouping
Sliding Window logic
Time complexity optimization
Challenge Two: Developer Team Selection
Sorting for preprocessing
Dynamic Programming (DP)
Maximization/Optimization problem
Handling mutual constraints
Longest Increasing Subsequence (LIS) variation idea
Log Transmission Problem: This problem combines Data Structures (Circular Buffer/Queue) and Time Window logic (Sliding Window idea). The difficulty lies in effectively managing and querying logs within the circular buffer while iterating through the input array, specifically to quickly find all logs sharing the same tag and falling within the transmissionWindow.
Developer Team Selection Problem: This is a classic problem solvable by Dynamic Programming or by combining sorting with a Greedy approach. The difficulty involves understanding the mutually restrictive conditions and finding a sorting or iteration order that ensures the addition of each developer satisfies the conditions of all existing team members. Since the objective is the largest possible team size, DP or more complex search algorithms are required.
This round involves a phone call with the interviewer via Zoom and solving coding challenges. CoderPad is an editor similar to Google Docs, but with the ability to run code. I recommend that if you haven't used CoderPad before, you should Google it beforehand and try out the CoderPad Sandbox. After completing the two problems, you can add some test cases.
I broke down my study sessions into small, manageable goals.
I always reviewed my mistakes and tried to understand why I got a problem wrong.
Here are some of the most helpful platforms and materials I used:
Resource | Description |
|---|---|
LeetCode | Focus on the 'Top Interview Questions' section and practice problems tagged with Goldman Sachs. |
HackerRank | Offers a variety of coding challenges and contests. |
GeeksforGeeks | A wealth of information on algorithms, data structures, and interview questions. |
Probability / Math: Bayes' Theorem is your best friend. Be ready to manually derive integrals, implement Monte Carlo simulations, and handle matrices, etc.
Programming: No different from a typical tech interview, but the requirements are generally slightly lower.
Background related: If you come from a Quant Finance background, you might be asked to derive Black-Scholes... it won't be that extreme, but the probability of being asked about it is not zero. At a minimum, you must understand the option Greeks and how they change. Physics backgrounds will face related questions. Tech backgrounds will be asked about design and architecture.
Resume Depth: Same as above.
Behavior: Same as above.
Managing my time during practice and the actual interview made a big difference. Here are some techniques that worked for me:
Understand the problem thoroughly. I read the problem statement more than once and asked questions if anything was unclear.
Plan my approach before I started coding. I outlined my steps and shared my thought process.
Allocate time for each part: understanding, planning, coding, and testing.
Practice with timed coding sessions. I used online platforms to simulate the pressure of a real interview.
I join online communities where I can ask questions and share ideas. Forums like Reddit’s r/cscareerquestions and LeetCode Discuss help me learn from others. I also join Discord servers focused on coding interviews. These spaces let me get feedback, and stay motivated.
Here are some places I visit:
LeetCode Discuss
Reddit r/cscareerquestions
Discord coding interview groups
GeeksforGeeks Q&A forums
Blind Discuss
When I tackled each question in my goldman sachs coderpad interview, I made sure to focus on the logic, not just the code. I always start by talking through my plan before typing anything. This helps me organize my thoughts and lets the interviewer see how I think. Here’s how I usually approach coding questions:
I break down the problem into smaller steps.
I talk about the data structures I want to use and why.
I stay open to feedback and adjust my solution if the interviewer suggests a new constraint.
If you want a step-by-step plan, here’s what works for me:
Discuss the logic behind your solution first.
Be ready for questions about your approach or the data structures you pick.
Change your solution if the interviewer gives you new information or constraints.
Tip: The interviewer wants to hear your thought process, not just see a working code. Don’t be afraid to pause and explain your reasoning.
Here are a few I try to avoid:
Acting overconfident, especially in the hiring manager round.
Thinking technical skills alone will get me through.
Forgetting to review my resume, which makes it hard to talk about my past experiences.
I also make sure not to rush through the problem. If I skip explaining my logic, I risk missing out on points for communication.
From my experience, interviewers at goldman sachs coderpad look for more than just correct answers. They want to see:
Strong technical skills, especially in coding and cloud technologies.
Clear problem-solving abilities, shown by how I explain my approach.
Good communication skills, so they can follow my reasoning and understand my choices.
After that, there were still technical interviews and a super day. The technical stage had three rounds: the first was about my paper and career direction, the second was a coding round, and the third was a deep dive into my resume along with a few more problems.
One thing I want to strongly advise is: don’t exaggerate anything on your resume. In the resume deep-dive rounds, they will ask detailed questions about everything you listed, and it can get really awkward if you can’t answer.
Navigating My Oracle Software Engineer Interview in 2025
Successfully Completing the BCG X CodeSignal Assessment in 2025
My Journey to Success in the Palantir New Grad Interview