Stack Questions at Goldman Sachs: What to Expect

Stack questions appear in nearly 9% of Goldman Sachs’ technical interview problem set. For a firm that builds high-frequency trading systems, risk management platforms, and massive transaction processing engines, the stack’s role is fundamental. Its Last-In-First-Out (LIFO) property is perfect for parsing expressions, managing function calls, tracking state in algorithms, and undoing operations—core tasks in financial software where order, precedence, and reversal are critical. Mastering stack patterns isn't just about solving an interview problem; it demonstrates you can reason about the ordered, layered logic that underpins their systems.

What to Expect — Types of Problems

Goldman Sachs stack problems typically test your ability to manage nested or hierarchical relationships and track state. Expect these categories:

1. Expression Evaluation: Parsing and calculating arithmetic expressions, often with parentheses and multiple operators. This directly relates to financial formula engines.
2. Validation & Parsing: Checking for balanced parentheses, tags, or other symbols. This tests attention to detail with structured data.
3. Monotonic Stack Problems: A specialized pattern for problems like "next greater element" or stock span, which is highly relevant for analyzing time-series data (e.g., stock prices).
4. Simulation with Stack: Using a stack to simulate a process, like simplifying a file path or tracking browser history.

The problems often combine the stack with other concepts, like hash maps for lookups or strings for parsing.

How to Prepare — Study Tips with One Code Example

Focus on understanding the core patterns, not just memorizing solutions. For each problem, draw the stack’s state step-by-step. A key pattern is using a stack to track openers (like (, [, {) and ensure they match correctly with closers.

Here is a classic validation problem and its solution in three languages:

def isValid(s: str) -> bool:
    stack = []
    mapping = {')': '(', '}': '{', ']': '['}

    for char in s:
        if char in mapping:  # It's a closing bracket
            top_element = stack.pop() if stack else '#'
            if mapping[char] != top_element:
                return False
        else:  # It's an opening bracket
            stack.append(char)
    return not stack  # Stack must be empty at the end

Recommended Practice Order

Build competency progressively:

1. Fundamentals: Start with basic push/pop logic (e.g., valid parentheses, stack implementation using an array).
2. Expression & Parsing: Move to expression evaluation (postfix/infix) and parsing problems.
3. Monotonic Stack: Tackle "next greater element" and "daily temperatures" to learn this optimization pattern.
4. Hybrid Problems: Finally, solve problems that combine stacks with other structures, like the "min stack" problem or simulating a browser history.

Consistently trace the stack's state on paper for the first few problems of each type to build intuition.

Practice Stack at Goldman Sachs