Array Questions at TCS: What to Expect

Array questions make up over half of TCS's coding problems—116 out of 217 total. This isn't random. Arrays are the most fundamental data structure, and TCS uses them to test core programming logic, attention to detail, and the ability to handle constraints efficiently. Success here demonstrates you can manipulate data, a daily requirement for software roles. If you can't solve array problems cleanly, you likely won't progress.

What to Expect — Types of Problems

TCS array questions fall into predictable categories. You won't see obscure algorithms; instead, expect practical problems testing foundational skills.

1. Basic Traversal and Search: Finding elements, counting occurrences, or identifying min/max values. These test loop control and condition handling.
2. Subarray Problems: Finding subarrays with a given sum, maximum sum (Kadane's Algorithm), or fixed length. These assess your ability to manage sliding windows or prefix sums.
3. Sorting and Rearrangement: Rearranging based on conditions (e.g., moving zeros, segregating even/odd numbers) often without using extra space. This tests in-place manipulation.
4. Two-Pointer Techniques: Used for problems like pair sum, reversing arrays, or removing duplicates from a sorted array. This evaluates efficiency and pointer logic.
5. Basic Hashing Applications: Using a hash map (or dictionary) to find pairs, duplicates, or first non-repeating elements efficiently.

The constraints are typically moderate, but an O(n²) brute-force solution might fail on larger test cases. They expect an optimal O(n) or O(n log n) approach.

How to Prepare — Study Tips with One Code Example

Focus on patterns, not memorizing solutions. Master these five techniques: traversal, sorting, hash maps, two-pointers, and the sliding window. Then, map any new problem to the closest pattern.

Practice writing clean, constraint-aware code. Always check for edge cases: empty arrays, single elements, all positive/negative numbers, and large inputs. Dry-run your logic with sample inputs.

A key pattern is the Two-Pointer Swap for Reversal. Here’s how to implement it across languages:

def reverse_array(arr):
    left, right = 0, len(arr) - 1
    while left < right:
        # Swap elements
        arr[left], arr[right] = arr[right], arr[left]
        left += 1
        right -= 1
    return arr

This pattern teaches in-place manipulation and pointer movement, which is essential for many array operations.

Recommended Practice Order

Start simple and build complexity. This order ensures you solidify concepts before tackling combined challenges.

1. Foundation: Begin with basic traversal, search, and counting problems.
2. Sorting: Practice in-place rearrangement algorithms (e.g., move zeros, segregate even/odd).
3. Hashing: Solve problems requiring frequency counts or pair finding.
4. Two-Pointers: Tackle pair sum, array reversal, and duplicate removal.
5. Subarrays & Windows: Progress to maximum sum subarray and fixed-size sliding window problems.
6. Hybrid Problems: Finally, solve questions that mix patterns, like finding a subarray with a sum using hashing and two-pointers.

Allocate time for consistent, timed practice. Solve each problem, then analyze optimal solutions to learn the most efficient pattern.

Practice Array at TCS