Cracking DSA Interviews at Top Indian Tech Companies

After clearing interviews at three FAANG-tier companies and helping 50+ candidates prepare, here's what actually works for DSA preparation in the Indian tech hiring context.

The Reality of DSA Rounds

Most companies in India follow this pattern:

• OA Round: 2-3 problems, 60-90 minutes
• Technical Round 1: 1-2 medium problems + discussion
• Technical Round 2: 1 hard or 2 medium problems
• System Design: For senior roles

Topic Priority (Based on Frequency)

Must Master (Asked 70% of the time)

1. Arrays and Strings
2. Hash Maps and Sets
3. Two Pointers
4. Sliding Window
5. Binary Search
6. Trees (DFS, BFS)
7. Dynamic Programming (1D)

Important (Asked 30%)

8. Graphs
9. Linked Lists
10. Stacks and Queues
11. Heaps
12. DP (2D)
13. Backtracking

Study Plan (12 Weeks)

Weeks 1-4: Foundation

• 3 easy problems daily
• Focus on Arrays, Strings, Hash Maps
• Understand time/space complexity

Weeks 5-8: Intermediate

• 2 medium problems daily
• Trees, Graphs, DP patterns
• Start timed practice

Weeks 9-12: Advanced

• 1-2 hard problems daily
• Mock interviews
• Company-specific preparation

Pattern Recognition

Most problems are variations of these patterns:

Two Pointers

def two_sum_sorted(nums, target):
    left, right = 0, len(nums) - 1
    while left < right:
        current = nums[left] + nums[right]
        if current == target:
            return [left, right]
        elif current < target:
            left += 1
        else:
            right -= 1
    return []

Sliding Window

def max_sum_subarray(nums, k):
    window_sum = sum(nums[:k])
    max_sum = window_sum
    
    for i in range(k, len(nums)):
        window_sum += nums[i] - nums[i-k]
        max_sum = max(max_sum, window_sum)
    
    return max_sum

BFS for Trees/Graphs

from collections import deque

def level_order(root):
    if not root:
        return []
    
    result = []
    queue = deque([root])
    
    while queue:
        level = []
        for _ in range(len(queue)):
            node = queue.popleft()
            level.append(node.val)
            if node.left: queue.append(node.left)
            if node.right: queue.append(node.right)
        result.append(level)
    
    return result

During the Interview

1. Clarify (2-3 mins): Input constraints, edge cases
2. Approach (5 mins): Explain your solution before coding
3. Code (15-20 mins): Write clean, readable code
4. Test (5 mins): Walk through with an example

What Interviewers Look For

• Clear communication
• Breaking down the problem
• Handling edge cases
• Code quality
• Time/space analysis

Common Mistakes

1. Jumping to code - Always discuss approach first
2. Ignoring constraints - n=10^5 needs O(n log n) or better
3. Missing edge cases - Empty input, single element, negative numbers
4. Poor variable names - i, j is fine; a, b, c is not

Resources

• LeetCode (focus on Top Interview Questions)
• NeetCode roadmap (best structured)
• Abdul Bari (YouTube) for concepts
• Company-specific lists on LeetCode

Final Tips

Start early. Consistency beats cramming. 2 problems daily for 3 months beats 100 problems in 2 weeks.

Companies care more about how you think than whether you get the optimal solution immediately. Stay calm, communicate clearly, and practice under time pressure.