Technical Interview: Minimum DSA You Actually Need

You Don't Need to Solve 500 LeetCode Problems to Get a Job in India#

Let me say that louder for the people in the back: you do not need to grind 500 LeetCode problems.

I see this panic every placement season. Students on r/developersIndia posting things like "I've solved only 150 LeetCode problems, is it enough?" or "Should I do Striver's A2Z sheet or NeetCode 150 or CodeStudio?"

And seniors replying "bro minimum 400 problems, focus on patterns" as if everyone's interviewing at Google.

Here's the reality check:

95% of Indian freshers are NOT interviewing at Google, Amazon, or Microsoft. They're interviewing at TCS Digital, Infosys Power Programmer, Wipro Turbo, Cognizant GenC, Capgemini, Accenture, and a bunch of mid-size product companies.

The DSA bar for these companies is WILDLY different from FAANG.

I'm going to tell you exactly what you need to know, topic by topic, based on real interview experiences from 2024-2026. No fluff, no "just solve more problems bro." Actual minimum viable DSA.

First: Understand the Tiers#

Not all companies ask the same level of DSA. Here's a rough breakdown:

Tier 1: Basic DSA (Arrays, Strings, Sorting, Basic Searching)

Companies: TCS Ninja, Infosys SP, Wipro Elite, Cognizant GenC, Capgemini, Accenture ASE, most mass recruiters

What they actually ask: Array manipulation, string operations, sorting algorithms, basic searching, simple math problems. Think: find the second largest element, reverse a string, check if a number is prime, basic pattern printing.

LeetCode equivalent: Easy. Maybe 1-2 medium problems.

Prep needed: 50-80 problems. 2-3 weeks of focused practice.

Tier 2: Moderate DSA (+ Stacks, Queues, Linked Lists, Basic Trees, Hashing)

Companies: TCS Digital, Infosys PP, Wipro Turbo, Cognizant GenC Next, Tech Mahindra, mid-size product companies (Zoho, Freshworks, smaller startups)

What they actually ask: Everything from Tier 1, plus linked list operations, stack/queue problems, basic binary tree traversals, HashMap usage, two-pointer technique, sliding window basics.

LeetCode equivalent: Medium (but the easier side of medium).

Prep needed: 100-150 problems. 4-6 weeks of focused practice.

Tier 3: Strong DSA (+ Graphs, DP, Advanced Trees, Backtracking)

Companies: Amazon, Microsoft, Google, Flipkart, PhonePe, Uber, Atlassian, top product companies

What they actually ask: Everything from Tier 1 and 2, plus dynamic programming, graph algorithms (BFS, DFS, shortest path), advanced tree problems, backtracking, greedy algorithms.

LeetCode equivalent: Medium to Hard.

Prep needed: 200-300 problems. 2-3 months of focused practice.

See the difference? If you're preparing for TCS Digital, you do NOT need graph algorithms. If you're aiming for Wipro Elite, you don't even need linked list problems. Know your target and prepare accordingly.

The Minimum DSA Checklist (Topic by Topic)#

Here's exactly what to study, in priority order. Start from the top. Stop when you've covered what your target tier needs.

1. Arrays (MUST for ALL tiers)

This is where 40-50% of all interview coding questions come from. If you nail arrays, you've handled half the battle.

Must-know operations:

• Traversal, insertion, deletion
• Finding min/max, second largest/smallest
• Reversing an array
• Rotating an array (left and right)
• Removing duplicates from sorted array
• Merging two sorted arrays

Must-know patterns:

• Two pointer technique: Used in problems like "find pair with given sum", "container with most water", "remove duplicates"
• Sliding window: Used for "maximum sum subarray of size k", "longest substring without repeating characters"
• Prefix sum: Used for range sum queries, subarray sum problems
• Kadane's algorithm: Maximum subarray sum. This gets asked A LOT.

Practice problems (20-25):

• Two Sum (LeetCode #1)
• Best Time to Buy and Sell Stock (#121)
• Maximum Subarray (#53, Kadane's)
• Merge Sorted Array (#88)
• Move Zeroes (#283)
• Contains Duplicate (#217)
• Product of Array Except Self (#238)
• Rotate Array (#189)
• Find the Duplicate Number (#287)
• Subarray Sum Equals K (#560)

2. Strings (MUST for ALL tiers)

Second most common topic. Especially in IT services companies.

Must-know operations:

• Reverse a string
• Check palindrome
• Count character frequency (using HashMap or array)
• String comparison
• Substring operations
• String to integer, integer to string conversions

Must-know patterns:

• Anagram check: Sort both strings or use frequency count
• Palindrome check: Two pointers from both ends
• Character frequency: HashMap or int[26] array

Practice problems (15-20):

• Valid Anagram (#242)
• Valid Palindrome (#125)
• Longest Common Prefix (#14)
• Reverse String (#344)
• First Unique Character in a String (#387)
• String to Integer (atoi) (#8)
• Longest Palindromic Substring (#5)
• Group Anagrams (#49)

3. Sorting and Searching (MUST for ALL tiers)

Must-know algorithms:

• Bubble Sort: Know the logic. You won't use it, but interviewers ask to explain it.
• Selection Sort: Same, know the concept.
• Insertion Sort: Actually useful for nearly-sorted arrays.
• Merge Sort: MUST know. Time: O(n log n), Space: O(n). Understand divide and conquer.
• Quick Sort: MUST know. Time: O(n log n) average, O(n^2) worst. Understand partitioning.
• Binary Search: MUST. MUST. MUST. If you learn one algorithm perfectly, make it this one.

Binary Search variations you need:

• Standard binary search
• First occurrence of element
• Last occurrence of element
• Search in rotated sorted array
• Find peak element
• Square root using binary search

Practice problems (10-15):

• Binary Search (#704)
• Search in Rotated Sorted Array (#33)
• Find Minimum in Rotated Sorted Array (#153)
• Search a 2D Matrix (#74)
• Find Peak Element (#162)
• Sort Colors (#75, Dutch National Flag)

4. Hashing / HashMap (MUST for Tier 2+)

HashMap is the Swiss Army knife of DSA. So many problems become easy once you know how to use it.

Must-know:

• How HashMap works (key-value pairs, O(1) average lookup)
• When to use HashMap vs array for frequency counting
• Collision handling (chaining, open addressing) for theory questions

Common patterns:

• Frequency counting
• Two Sum using HashMap
• Finding duplicates
• Subarray with given sum
• Grouping elements

Practice problems (8-10):

• Two Sum (#1, HashMap approach)
• Group Anagrams (#49)
• Longest Consecutive Sequence (#128)
• Subarray Sum Equals K (#560)
• Top K Frequent Elements (#347)

5. Linked Lists (Tier 2+)

Linked list questions are becoming less common in actual interviews, but they still show up at product companies and Tier 2 IT companies.

Must-know operations:

• Traversal
• Insertion (beginning, end, middle)
• Deletion
• Reverse a linked list (iterative AND recursive)
• Detect cycle (Floyd's algorithm)
• Find middle element
• Merge two sorted linked lists

Practice problems (8-10):

• Reverse Linked List (#206)
• Linked List Cycle (#141)
• Merge Two Sorted Lists (#21)
• Remove Nth Node From End (#19)
• Middle of the Linked List (#876)
• Palindrome Linked List (#234)

6. Stacks and Queues (Tier 2+)

Must-know:

• Stack: LIFO, push, pop, peek. Implementation using array.
• Queue: FIFO, enqueue, dequeue. Implementation using array.
• When to use stack vs queue
• Recursion and stack connection

Must-know patterns:

• Balanced parentheses: Classic stack problem
• Next greater element: Monotonic stack
• Min stack: Stack with O(1) min retrieval

Practice problems (8-10):

• Valid Parentheses (#20)
• Min Stack (#155)
• Next Greater Element I (#496)
• Implement Queue using Stacks (#232)
• Daily Temperatures (#739)

7. Trees (Tier 2+)

Must-know:

• Binary tree vs BST (Binary Search Tree)
• Tree traversals: Inorder, Preorder, Postorder (both recursive and iterative)
• Level order traversal (BFS)
• Height of tree
• Check if BST
• Lowest Common Ancestor

Practice problems (10-12):

• Maximum Depth of Binary Tree (#104)
• Invert Binary Tree (#226)
• Same Tree (#100)
• Binary Tree Level Order Traversal (#102)
• Validate BST (#98)
• Lowest Common Ancestor of BST (#235)
• Diameter of Binary Tree (#543)
• Symmetric Tree (#101)

8. Recursion and Backtracking (Tier 2+ for recursion, Tier 3 for backtracking)

Must-know (Recursion):

• Factorial, Fibonacci
• Power of a number
• Print all subsequences
• Recursion with arrays/strings

Must-know (Backtracking, Tier 3 only):

• N-Queens (concept)
• Subset generation
• Permutations
• Sudoku solver (concept, rarely asked to code fully)

Practice problems (8-10):

• Subsets (#78)
• Permutations (#46)
• Combination Sum (#39)
• Letter Combinations of Phone Number (#17)
• Generate Parentheses (#22)

9. Dynamic Programming (Tier 3 ONLY)

Here's where most people waste time. If you're not targeting Amazon/Google/Microsoft level companies, you can skip most DP.

Minimum DP you should know (even for Tier 2):

• Fibonacci (memoization concept)
• Climbing stairs
• 0/1 Knapsack (concept)
• Longest Common Subsequence (concept)

For Tier 3, add:

• Coin Change
• Longest Increasing Subsequence
• Edit Distance
• Matrix Chain Multiplication
• DP on grids
• DP on strings

Practice problems (10-15 for Tier 3):

• Climbing Stairs (#70)
• House Robber (#198)
• Coin Change (#322)
• Longest Increasing Subsequence (#300)
• Longest Common Subsequence (#1143)
• 0/1 Knapsack (GFG)
• Edit Distance (#72)
• Unique Paths (#62)

10. Graphs (Tier 3 ONLY)

Again, unless you're targeting top product companies, skip this.

Minimum graph knowledge:

• BFS and DFS (both traversals)
• Adjacency list representation
• Detecting cycle in undirected/directed graph
• Shortest path (Dijkstra's, basic concept)
• Topological sort (concept)

Practice problems (8-10):

• Number of Islands (#200)
• Clone Graph (#133)
• Course Schedule (#207)
• Rotting Oranges (#994)
• Word Ladder (#127)

The 4-Week Minimum DSA Plan (For Tier 2 Companies)#

If you have 4 weeks before placements and you're targeting TCS Digital, Infosys Power Programmer, Wipro Turbo, or similar companies, here's your plan:

Week 1: Arrays + Strings

• 5 problems per day
• Focus on patterns: two pointer, sliding window, frequency counting
• Total: 25-30 problems

Week 2: Sorting + Searching + Hashing

• Binary search deep dive (all variations)
• HashMap problems
• Quick sort and merge sort implementation
• 4-5 problems per day
• Total: 20-25 problems

Week 3: Linked Lists + Stacks + Queues

• Linked list: focus on reverse, cycle detection, merge
• Stack: balanced parentheses, next greater element
• 4-5 problems per day
• Total: 20-25 problems

Week 4: Trees + Recursion + Revision

• Binary tree traversals
• BST operations
• Basic recursion problems
• REVISE Week 1-3 problems (redo at least 50%)
• Total: 15-20 new problems + revision

Grand total: 80-100 problems in 4 weeks. That's it. That's enough for Tier 2 companies.

The 2-Week Emergency Plan (For Tier 1 Companies)#

If placements are in 2 weeks and you're targeting TCS Ninja, Wipro Elite, Cognizant GenC, or similar mass recruiters:

Week 1: Arrays + Strings + Basic Sorting

• Focus on the top 20 most-asked problems
• Two Sum, Reverse String, Kadane's, Binary Search, Sort Colors
• 5-6 problems per day
• Total: 30-35 problems

Week 2: Remaining gaps + Revision

• Any weak areas from Week 1
• Practice on HackerRank/HackerEarth (these platforms are used in actual tests)
• Time yourself: 2 problems in 30 minutes
• Total: 20-25 problems + full revision

Grand total: 50-60 problems. Enough for mass recruiters.

What About Theory?#

Some interviews (especially at IT services companies) ask theoretical DSA questions:

• "What is the time complexity of merge sort?" (O(n log n))
• "Difference between stack and queue?" (LIFO vs FIFO)
• "What is a binary search tree?" (Left < root < right)
• "What is hashing?" (Key to index mapping)
• "When would you use a linked list over an array?" (Frequent insertions/deletions)

For these, make a one-page cheat sheet with:

• Time and space complexity of all sorting algorithms
• Properties of each data structure (array, linked list, stack, queue, tree, graph, HashMap)
• When to use which data structure

Review this cheat sheet the night before your interview.

Common Mistakes in DSA Prep#

1. Solving problems without understanding patterns

Don't just solve and move to next. After solving, ask: "What pattern did this use? Where else can I apply this?"

Two Sum uses HashMap. Okay, where else? Subarray sum, finding duplicates, frequency counting. Now you've learned a pattern, not just a problem.

2. Spending too much time on one problem

Rule: if you can't figure out the approach in 15-20 minutes, look at the hint or solution. Understand it. Code it yourself. Move on. Come back in 2 days and solve it again without looking.

Spending 2 hours on one problem when you have 100 to cover is bad time management.

3. Not practicing on the actual platform

If your company uses HackerRank, practice on HackerRank. If they use HackerEarth, practice there. Each platform has slightly different UI, input/output format, and time limits. Get comfortable with the platform before the test.

4. Ignoring time complexity

Solving a problem is not enough. You need to explain the time and space complexity. Practice saying: "This solution is O(n) time and O(1) space because..."

5. Not revising

You'll forget 70% of what you solved within a week. Revision is not optional. Re-solve problems you found difficult every 3-5 days.

Resources (Free, No Paid Courses Needed)#

You do NOT need to buy a paid course for DSA. Everything is free:

1. Striver's SDE Sheet (takeuforward.org): The most popular DSA sheet in India. Well-organized by topic. Video explanations for each problem.

2. NeetCode 150 (neetcode.io): 150 curated problems. Great for pattern-based learning. Roadmap format.

3. LeetCode (leetcode.com): The largest problem bank. Filter by company and topic. Free tier is enough.

4. GeeksforGeeks (geeksforgeeks.org): Best for Indian interview-specific problems. Company-wise archives.

5. YouTube channels:

   • Take U Forward (Striver): Best for DSA in India
   • NeetCode: Great pattern explanations
   • Abdul Bari: Algorithms theory
   • Kunal Kushwaha: Java DSA complete course (free)

Don't use more than 2 resources. Pick one sheet (Striver's or NeetCode) and one platform (LeetCode or GFG). Stick to it.

The Honest Truth About DSA in Indian Placements#

Let me be real with you.

DSA is important, but it's not everything. In most Indian interviews (especially service companies), they also test:

• DBMS: SQL queries, normalization, joins
• OS: Process vs thread, scheduling algorithms, deadlock
• Computer Networks: TCP vs UDP, HTTP methods, OSI model
• OOP concepts: Inheritance, polymorphism, abstraction, encapsulation
• One programming language deeply: Java or Python, know it well

If you spend all your time on DSA and can't answer "What is normalization?" or "Explain polymorphism with an example," you'll still get rejected.

Balance your prep. DSA is 40-50% of a technical interview. The rest matters too.

Your Action Plan#

1. Figure out your target tier (1, 2, or 3)
2. Follow the corresponding week plan above
3. Track your progress: problems solved per day, topics covered
4. Revise every 3 days
5. Practice on the actual platform your target company uses
6. Don't forget CS fundamentals (DBMS, OS, OOP)

And when you're ready to test yourself, try a mock technical interview on JobRise. It simulates real company-specific questions, TCS, Infosys, Wipro, and more, so you know exactly what to expect on the actual day.

Stop overthinking DSA prep. Start with the minimum, build from there, and focus on patterns over problem count. 100 well-understood problems beat 500 mindlessly solved ones every single time.