Google vs Goldman Sachs: Interview Question Comparison

When preparing for technical interviews at top-tier companies, understanding the nature and focus of their questions is crucial for efficient study. Google and Goldman Sachs, while both demanding strong algorithmic skills, present distinct interview landscapes. Google's process is a marathon of highly standardized, classic algorithm problems, while Goldman Sachs focuses on a narrower set of applied, finance-adjacent coding challenges. This comparison breaks down the key differences in volume, difficulty, and content to help you strategize your preparation.

Question Volume and Difficulty

The sheer scale of the question banks is the most immediate difference. On platforms like CodeJeet, Google's catalog is vast, with over 2,200 documented questions (E588/M1153/H476). This reflects their rigorous, multi-round process where you might face different problem types across interviews. The difficulty distribution is heavy on Medium and Hard problems, indicating that passing requires not just correctness but optimal, well-reasoned solutions under time pressure.

In stark contrast, Goldman Sachs has a much smaller, more concentrated set of around 270 questions (E51/M171/H48). The volume is less daunting, but note the distribution: Medium problems dominate. This suggests their technical screen is less about solving esoteric "Hard" puzzles and more about consistently demonstrating proficiency on common patterns with clean, bug-free code. The lower volume means questions may repeat more frequently, so practicing the known set is highly effective.

Topic Overlap

Both companies heavily test four core areas: Array, String, Hash Table, and Dynamic Programming. This is the critical overlap your foundation should be built on. However, the context and application often differ.

At Google, a Dynamic Programming question might be a classic like "Longest Increasing Subsequence" or an abstract optimization problem. At Goldman Sachs, the same DP principle is often applied to more concrete scenarios, like calculating optimal trade profits or scheduling transactions. String and Array problems at Goldman may involve parsing financial data formats or simulating ledger operations.

# Example: A "Maximum Subarray" variant (Kadane's Algorithm)
# Google: Likely the standard problem.
def maxSubArray(nums):
    current_max = global_max = nums[0]
    for num in nums[1:]:
        current_max = max(num, current_max + num)
        global_max = max(global_max, current_max)
    return global_max

# Goldman Sachs: Framed as max profit over time.
def maxProfit(prices):
    if not prices:
        return 0
    min_price = prices[0]
    max_profit = 0
    for price in prices:
        min_price = min(min_price, price)
        max_profit = max(max_profit, price - min_price)
    return max_profit

Which to Prepare for First

Start with Goldman Sachs. The smaller, more focused question bank allows you to build core competency efficiently. Mastering their Medium-dominant set in the key overlapping topics (Array, String, Hash Table, DP) will give you a strong, transferable foundation. You can achieve coverage and confidence faster.

Then, transition to Google. Use the broader foundation to tackle their larger volume. Here, you must deepen your understanding, practice speed on Hard problems, and get comfortable with more abstract algorithmic thinking. Preparing for Google second is logical because its process is more comprehensive; the skills you build will easily encompass those needed for Goldman Sachs, but the reverse is not necessarily true.

In short, prepare for the focused exam (Goldman) before the comprehensive one (Google). The shared technical core makes this an efficient strategy.

For detailed question lists and patterns, visit the company pages: Google and Goldman Sachs.