Two Pointers Questions at TCS: What to Expect

Two Pointers is a critical pattern for TCS coding interviews. With 38 dedicated problems out of their 217-question bank, it represents roughly 17.5% of their technical assessment content. Mastering this technique is non-negotiable for efficiency and problem-solving depth. TCS often uses these problems to evaluate a candidate's ability to optimize beyond brute-force solutions, testing both logical structuring and clean code implementation under time constraints.

What to Expect — Types of Problems

TCS Two Pointers questions typically fall into three categories, often involving arrays or strings.

1. Opposite-End Pointers: Used for problems where you process a sorted array from both ends. Classic examples include finding a pair with a target sum, or reversing an array or string in-place.
2. Fast & Slow Pointers: Applied to linked lists or arrays to detect cycles or find midpoints. While less frequent in TCS's array-heavy question set than in other company banks, it's a fundamental pattern to know.
3. Sliding Window: A subset of the two-pointer technique used for contiguous subarrays or substrings. You'll encounter problems asking for the maximum sum of a subarray of size k, or the longest substring with k distinct characters.

Expect variations that combine sorting with the two-pointer approach, or problems that initially seem to require a hash map but can be optimized with pointers for reduced space complexity.

How to Prepare — Study Tips with One Code Example

Start by understanding the brute-force solution, then identify how two pointers can reduce time complexity, usually from O(n²) to O(n). Draw the logic on paper or a whiteboard. Trace pointer movement with sample inputs. The core skill is recognizing when the array's sorted nature (or your ability to sort it) allows you to intelligently move pointers based on a comparison.

A foundational pattern is finding a pair in a sorted array that sums to a target. The brute force checks all pairs (O(n²)). The two-pointer method starts one pointer at the beginning (left) and one at the end (right). If their sum is too small, you increment left to increase the sum. If it's too large, you decrement right to decrease it. This works because the array is sorted.

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, right]  # Indices are often 1-based in problems
        elif current_sum < target:
            left += 1
        else:
            right -= 1
    return []  # No solution found

Recommended Practice Order

Build competence progressively. Begin with basic opposite-end pointer problems (Two Sum II, Reverse String). Next, tackle sliding window problems (Maximum Sum Subarray of Size K, Longest Substring with K Distinct Characters). Then, practice fast & slow pointer problems on linked lists (Linked List Cycle, Middle of the Linked List). Finally, solve TCS's mixed-difficulty problems, focusing on their question bank. Always analyze time and space complexity.

Practice Two Pointers at TCS