Stack Questions at Grammarly: What to Expect

Stack questions appear in roughly 15% of Grammarly’s technical interviews (4 out of 26 total problems). This isn't by accident. Grammarly’s core product—a real-time writing assistant—relies heavily on parsing and analyzing text structure. Tasks like checking for balanced brackets in code snippets, validating nested markdown formatting, managing undo/redo operations, or evaluating expressions within grammar rules are fundamentally stack operations. Mastering stacks demonstrates you can think about state management and nested hierarchies, which is directly applicable to building features at Grammarly.

What to Expect — Types of Problems

Grammarly’s stack problems typically focus on practical applications rather than abstract textbook exercises. You can expect variations on these core themes:

• Syntax Validation: The classic "valid parentheses" problem is a direct analog for checking proper nesting in any structured text (HTML tags, markdown, or even grammatical constructs).
• Expression Evaluation: Problems involving parsing and computing expressions, often requiring you to manage operators and operands. This mirrors how a tool might evaluate a conditional formatting rule.
• State Management: Simulating features like an "undo" mechanism or tracking a user’s navigation path through a document. These problems test your ability to use a stack to manage historical state.
• Monotonic Stack: A more advanced pattern used for problems like finding the next greater element or calculating spans. This is relevant for analyzing sequences of text or data.

The problems are designed to assess not just if you can implement a stack, but if you can identify when a stack is the appropriate tool.

How to Prepare — Study Tips with One Code Example

Start by ensuring you can implement a stack and its core operations (push, pop, peek) from memory in your chosen language. Then, focus on pattern recognition. The key is to identify when a problem requires Last-In-First-Out (LIFO) processing, especially for matching, nesting, or backtracking.

A fundamental pattern is using a stack to track openers and match them with closers. Here is the standard solution for validating parentheses, brackets, and braces:

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

Internalize this pattern. The logic—using a map for matching pairs and a stack to track the order—applies to many nested validation problems.

Recommended Practice Order

1. Master the Fundamentals: Valid Parentheses, Min Stack, Implement Stack using Queues.
2. Apply to Evaluation: Evaluate Reverse Polish Notation, Basic Calculator.
3. Tackle State Management: Design a Stack With Increment Operation, Next Greater Element I.
4. Solve Advanced Patterns: Largest Rectangle in Histogram (monotonic stack), Decode String.

Practice by first solving the problem, then analyzing its time/space complexity, and finally, verbalizing why a stack was the optimal choice. This mirrors the interview process at Grammarly, where communication is as important as the code.

Practice Stack at Grammarly