Stack Questions at Myntra: What to Expect

Stack questions appear in roughly 12.5% of Myntra's technical interviews (3 out of 24 problems). For a company managing complex e-commerce features like nested UI components, session history, cart operations, and inventory tracking, the Stack's Last-In-First-Out (LIFO) principle is fundamental. It's the ideal data structure for parsing, backtracking, and managing state in a controlled, sequential manner. Mastering it is non-negotiable for handling Myntra's frontend logic, order processing systems, and algorithmic challenges.

What to Expect — Types of Problems

Myntra's stack problems typically focus on practical applications rather than abstract theory. Expect these categories:

1. Expression & String Parsing: Validating or evaluating expressions, such as checking for balanced parentheses in a discount code rule or parsing a path string. This tests your ability to handle nested structures.
2. Next Greater Element (NGE) Patterns: Problems involving finding the next greater or smaller element in a sequence. This is highly relevant for features like "next item in view" or analyzing user behavior timelines.
3. Simulation with Stacks: Using a stack to simulate a process, like managing a sequence of user actions (e.g., "undo" in a cart) or simplifying a directory path. These questions test your ability to model real-world operations.
4. Hybrid Problems: Combining a stack with other techniques, like using it alongside a hash map for a more efficient solution (e.g., a more advanced parsing problem).

The problems are designed to assess not just your knowledge of the data structure, but your skill in recognizing where its LIFO property provides an optimal solution.

How to Prepare — Study Tips with One Code Example

Focus on pattern recognition, not memorization. Understand why a stack works for a given problem type. Practice by first solving problems using brute force, then identifying the repetitive or nested operations that a stack can optimize. Always analyze the time and space complexity of your stack solution.

A fundamental pattern is "Matching Parentheses" or validating balanced brackets. This is the cornerstone for many parsing problems.

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

    for char in s:
        if char in mapping:  # Closing bracket
            top_element = stack.pop() if stack else '#'
            if mapping[char] != top_element:
                return False
        else:  # Opening bracket
            stack.append(char)
    return not stack  # Stack must be empty if valid

Recommended Practice Order

Build competence sequentially. Start with core stack operations, then progress to classic patterns, and finally tackle Myntra-specific challenges.

1. Foundation: Implement a stack from scratch (array/linked list). Solve basic problems like parenthesis matching and stack reversal.
2. Core Patterns: Practice Next Greater Element variations, stock span problems, and celebrity problems. These solidify your understanding of monotonic stack techniques.
3. Advanced Application: Solve problems involving multiple stacks, like min-stack, queue using stacks, and expression evaluation (infix to postfix).
4. Myntra Context: Apply these patterns to scenarios like simplifying a file path (simulating navigation), validating HTML tags (UI component nesting), or designing a browser history manager (undo/redo logic).

Practice Stack at Myntra