Two Pointers Questions at Tinkoff: What to Expect

Two Pointers is a high-frequency pattern at Tinkoff, appearing in roughly 22% of their technical interview problems (6 out of 27 cataloged questions). For candidates, this means you are statistically very likely to encounter at least one problem requiring this technique. Mastering it is not optional; it's a direct efficiency upgrade for solving array and string manipulation problems that might otherwise require O(n²) brute-force solutions. A strong performance here demonstrates you can optimize for both time and space complexity, a key screening criterion.

What to Expect — Types of Problems

Tinkoff's Two Pointers questions typically fall into two categories, often on sorted or sortable input.

1. Opposite-End Pointers: This is the classic pattern. You place one pointer at the start and another at the end of an array or string, moving them inward based on a condition. Tinkoff uses this for problems like finding a pair with a target sum in a sorted array, checking for a palindrome, or reversing sequences.
2. Fast & Slow (or Sliding Window Adjacent) Pointers: Both pointers start at the beginning, with the "fast" runner moving ahead to explore or expand a window, and the "slow" runner lagging to maintain a condition or mark a position. Expect this in problems involving in-place deletions (e.g., "remove duplicates from sorted array"), cycle detection in sequences, or partitioning elements.

The input is usually a 1D array, list, or string. The core challenge is identifying the correct condition to move each pointer to maintain a valid state and progress toward the solution in O(n) time.

How to Prepare — Study Tips with One Code Example

Focus on the underlying logic, not memorization. Start by drawing the problem and pointer movements on a whiteboard. Verbally explain each step: "I move the left pointer because the current sum is too small..." This builds the muscle memory for interviews.

Practice this core pattern: finding two numbers in a sorted array that sum to a target. The brute force solution is O(n²). The two-pointer solution is O(n). Here is the standard implementation:

def two_sum_sorted(numbers, target):
    left, right = 0, len(numbers) - 1
    while left < right:
        current_sum = numbers[left] + numbers[right]
        if current_sum == target:
            return [left + 1, right + 1]  # 1-based index often required
        elif current_sum < target:
            left += 1  # Need a larger sum
        else:  # current_sum > target
            right -= 1  # Need a smaller sum
    return [-1, -1]  # No solution

Recommended Practice Order

Build competency progressively. Do not jump to Tinkoff's specific problems first.

1. Fundamentals: Solve the classic "Two Sum II - Input Array Is Sorted" (as above) and "Remove Duplicates from Sorted Array." These cement the two main pointer movement patterns.
2. Core Variations: Practice "3Sum," "Container With Most Water," and "Valid Palindrome." These test your ability to adapt the pattern to more complex conditions and nested loops.
3. Tinkoff-Specific Problems: Finally, apply your skills to the actual problems from Tinkoff's question bank. This order ensures you understand the tool before using it on the specific test.

Practice Two Pointers at Tinkoff