Stack Questions at Tinkoff: What to Expect

Stack questions appear in about 15% of Tinkoff's technical interview problems (4 out of 27 based on recent data). This makes them a non-negotiable area of study. Successfully solving stack problems demonstrates your ability to handle nested structures, track state, and manage LIFO (Last-In, First-Out) logic—skills directly applicable to real-world financial and transactional software development at Tinkoff. Missing these fundamentals can quickly derail an interview.

What to Expect — Types of Problems

Tinkoff's stack questions typically fall into three practical categories:

1. Parentheses & Syntax Validation: Checking for balanced brackets in strings, validating XML/HTML tags, or evaluating expressions. These test your understanding of matching open and close symbols.
2. Monotonic Stack Problems: These are high-frequency. You'll use a stack to maintain a sorted order (increasing or decreasing) to efficiently find the next greater or smaller element, calculate areas in histograms, or handle stock span problems. This pattern is crucial for optimizing array-based tasks.
3. Stack as a State Machine: Using the stack to simulate recursion, manage function calls (like a call stack), undo/redo operations, or traverse trees (depth-first search). It tests your ability to use a stack for control flow.

Expect the problems to be framed in a business or algorithmic context, not just abstract exercises.

How to Prepare — Study Tips with One Code Example

Focus on pattern recognition, not memorization. Understand the core principle: a stack is ideal when you need to process elements in reverse order of their arrival or match recent elements. Practice drawing the stack's state step-by-step on a whiteboard.

A fundamental pattern is "Next Greater Element." For each element in an array, find the first element to its right that is larger. A brute-force solution is O(n²). The optimal O(n) solution uses a monotonic decreasing stack to hold indices of elements for which we haven't yet found a greater element.

def nextGreaterElement(nums):
    result = [-1] * len(nums)
    stack = []  # stores indices

    for i, num in enumerate(nums):
        # While current element > element at stack's top index
        while stack and nums[stack[-1]] < num:
            idx = stack.pop()
            result[idx] = num  # Current num is next greater for idx
        stack.append(i)
    return result

# Example: [4, 2, 1, 5] -> [5, 5, 5, -1]

Recommended Practice Order

Build competence incrementally:

1. Master Fundamentals: Valid Parentheses, Min Stack.
2. Learn Key Patterns: Daily Temperatures (Next Greater Element variant), Stock Span.
3. Tackle Advanced Applications: Largest Rectangle in Histogram (monotonic stack), Evaluate Reverse Polish Notation.
4. Simulate the Interview: Solve Tinkoff's specific stack problems under timed conditions.

Practice Stack at Tinkoff