LeetCode Preparation Guide India 2026: How to Crack DSA for Product Company Interviews

Which companies use LeetCode-style problems?

High LeetCode bar (Hard expected, advanced data structures):

• Google, Meta, Apple: LeetCode Hard, sometimes very Hard (with non-obvious insights)

Medium-High bar (Medium-Hard, some advanced topics):

• Amazon, Flipkart, Microsoft, Swiggy, Zomato: LeetCode Medium to Hard

Medium bar (Medium, some Easy):

• Razorpay, Zerodha, CRED, PhonePe, Meesho: LeetCode Easy-Medium

Low bar (Easy, sometimes basic OA only):

• TCS, Infosys, Wipro, Cognizant: Easy to Medium, often MCQ-heavy

The 80/20 of LeetCode topics: Solving 500 random problems is far less effective than solving 150 problems across the 10 most important patterns. Interviewers draw from a finite set of patterns: you're learning to recognise patterns, not memorise solutions.

Quality over quantity:

• Understanding 100 problems deeply > grinding 300 problems shallowly
• After each problem, write down: the pattern, the key insight, the time/space complexity, and one similar problem
• A 'solved' problem you can't re-solve in 20 minutes without hints is not learned

Every LeetCode problem (with a few exceptions) is a variant of one of these patterns:

1. Two Pointers: time O(n), removes nested loops When to use: sorted arrays, finding pairs with a target sum, removing duplicates Example: Two Sum II, Container with Most Water, Remove Duplicates

2. Sliding Window: time O(n), for contiguous subarrays/substrings When to use: 'longest/shortest subarray/substring with condition X' Example: Longest Substring Without Repeating Characters, Minimum Window Substring

3. Binary Search: time O(log n) When to use: sorted array, monotonic function, 'find the minimum X that satisfies condition' Example: Search in Rotated Sorted Array, Find Peak Element, Koko Eating Bananas

4. BFS (Breadth-First Search): level-order traversal, shortest path in unweighted graphs When to use: shortest path, level-by-level processing, flood fill Example: Binary Tree Level Order, Rotting Oranges, Word Ladder

5. DFS (Depth-First Search): explore deeply, backtracking When to use: connected components, paths, tree traversals, permutations/combinations Example: Number of Islands, Path Sum, All Paths from Source to Target

6. Dynamic Programming: overlapping subproblems, optimal substructure When to use: 'find the minimum/maximum', 'how many ways to...', 'can you achieve...' Example: Climbing Stairs, House Robber, Longest Common Subsequence, 0/1 Knapsack

7. Fast and Slow Pointers (Floyd's cycle detection) When to use: cycle detection in linked list/array, middle of linked list Example: Linked List Cycle, Find the Duplicate Number, Happy Number

8. Monotonic Stack When to use: 'next greater element', 'previous smaller element', histogram problems Example: Next Greater Element, Daily Temperatures, Largest Rectangle in Histogram

9. Heap / Priority Queue When to use: top-K elements, merge K sorted lists, scheduling problems Example: Top K Frequent Elements, Merge K Sorted Lists, Find Median from Data Stream

10. Trie (Prefix Tree) When to use: prefix search, autocomplete, word dictionary Example: Implement Trie, Word Search II, Design Search Autocomplete System

This plan targets Amazon SDE-1, Flipkart SDE-1, Microsoft SDE-1, Razorpay, and Swiggy (Medium-Hard bar).

Week 1–2: Arrays, Strings, and Two Pointers (30 problems)

• Two Sum, Three Sum, Container with Most Water
• Move Zeroes, Remove Duplicates from Sorted Array
• Valid Palindrome, Longest Palindromic Substring (Manacher's optional)
• Sliding Window: Minimum Window Substring, Longest Substring Without Repeating Characters
• Daily target: 3 Easy + 1 Medium; don't spend more than 30 min on any problem

Week 3–4: Trees and Recursion (25 problems)

• Binary tree traversals (in/pre/post/level-order)
• Validate BST, Lowest Common Ancestor, Diameter of Binary Tree
• Max Path Sum, Serialize/Deserialize Binary Tree
• Recursion: generate parentheses, permutations, combinations

Week 5–6: Graphs and Dynamic Programming (25 problems)

• Graphs: Number of Islands, Clone Graph, Course Schedule (topological sort), Dijkstra's
• DP: Climbing Stairs, House Robber, Coin Change, Longest Increasing Subsequence, 0/1 Knapsack

Week 7: Stacks, Queues, Heaps (15 problems)

• Valid Parentheses, Min Stack, Daily Temperatures
• Top K Frequent Elements, Merge K Sorted Lists, Kth Largest Element

Week 8: Mock Interviews (10 full mock sessions)

• Two LeetCode problems per session, 45 minutes, no hints
• Verbalise your approach before coding (build the interview habit)
• Review misses and add to your 'pattern book'

This plan targets Google L3–L4, Meta E3–E4, Amazon SDE-2/Bar Raiser level. Assumes the 8-week fundamentals are complete or equivalent.

Weeks 9–10: Advanced Graph Algorithms

• Dijkstra's shortest path, Bellman-Ford (negative weights)
• Floyd-Warshall (all-pairs shortest path)
• Topological sort (Kahn's BFS variant + DFS variant)
• Strongly Connected Components: Kosaraju's algorithm
• Minimum Spanning Tree: Prim's + Kruskal's with Union-Find

Weeks 11–12: Advanced DP and Interval Problems

• DP on trees: Tree diameter, max independent set on tree
• Interval DP: Burst Balloons, Strange Printer, Minimum Cost Tree from Leaf Values
• Bitmask DP: Travelling Salesman Problem variants, Stickers to Spell Word
• Interval greedy: Merge Intervals, Non-overlapping Intervals, Meeting Rooms II

Weeks 13–14: String Algorithms and Segment Trees

• KMP pattern matching, Rabin-Karp rolling hash
• Trie: design prefix tree, word search II
• Segment trees (range sum, range minimum): for Google/Amazon L4+

Weeks 15–16: Mocks and Pattern Consolidation

• Daily: 1 Hard LeetCode problem, 45 minutes, no hints
• Weekly: 2 full timed mock interviews (2 problems each, 45 min)
• Practice on Google Docs occasionally (no syntax highlighting) to simulate real interview

What separates Good from Great at this level:

• Speed: solve Easy in <10 min, Medium in <20 min, Hard in <35 min
• Optimisation: always ask 'can I do better than this O(n²)?'
• Edge cases: null/empty/single element without prompting
• Communication: explain the pattern before coding, narrate complexity at the end

Free resources:

• NeetCode.io: curated 150-problem list by pattern, free video explanations, highly recommended starting point
• Striver's SDE Sheet (TakeUForward): 191 problems with detailed Hindi/English video explanations, extremely popular among Indian candidates
• LeetCode free tier: 750+ free problems, company tags (premium feature, but many lists on GitHub)

Paid resources (worth it for serious preparation):

• LeetCode Premium: unlock company-specific problem lists (Amazon, Google, Microsoft). ~₹1,500–2,000/month. Worth it for 2–3 months of focused preparation
• NeetCode Pro: structured learning paths, additional problems beyond the 150
• Algomaster.io: system design + LeetCode combined

Practice platforms beyond LeetCode:

• HackerRank: used by TCS NQT, Infosys, Wipro for online assessments: practice their specific OA format here
• HackerEarth: used by Flipkart, CRED for OAs
• Codility: used by Microsoft, some MNCs

Community:

• Reddit r/cscareerquestionsIN: Indian-specific career and interview discussions
• Reddit r/leetcode: problem discussions, contest rankings
• LinkedIn: follow NeetCode, Abdul Bari, Striver for content

Mindset for Indian candidates: Most Indian engineers from tier-2 colleges feel their DSA is 'not good enough' for product companies: the data doesn't support this. Flipkart, Razorpay, and Swiggy regularly hire from NIT, IIIT, and private engineering colleges. The bar is about preparation quality, not college tier. A 16-week dedicated plan, done right, is enough for most non-Google target companies.