🧠 Top 40 Problem-Solving Interview Questions by Pattern

A curated list of 40 must-practice coding problems commonly asked in top tech interviews, organized by problem-solving patterns.

---

✅ Patterns Covered

1. Sliding Window
2. Two Pointers
3. Fast & Slow Pointers
4. Stack
5. Binary Search
6. DFS/BFS
7. Topological Sort
8. Heap / Priority Queue
9. Backtracking
10. Dynamic Programming
11. Tree DFS/BFS
12. Prefix Sum / Tricks
13. Sorting & Greedy
14. Design
15. Trie, Union-Find, Matrix Traversal

---

📋 Problem List

🔄 Sliding Window

1. Longest Substring Without Repeating Characters
   DS: String, HashSet | Time: O(n)
   Note: Use HashMap/Set to track characters

2. Minimum Window Substring
   DS: String, HashMap | Time: O(n)
   Note: Two hash maps – one for required, one for window

3. Sliding Window Maximum
   DS: Deque | Time: O(n)
   Note: Maintain decreasing deque

---

↔️ Two Pointers

4. Container With Most Water
   DS: Array | Time: O(n)
   Note: Shrink window from sides, track max area

5. Trapping Rain Water
   DS: Array | Time: O(n)
   Note: Use leftMax and rightMax pointers

---

🧮 Hashing / Prefix Suffix

6. Two Sum
   DS: Array, HashMap | Time: O(n)
   Note: Complement pattern

7. Product of Array Except Self
   DS: Array | Time: O(n)
   Note: Avoid using division

---

🌀 Fast & Slow Pointers

8. Detect Cycle in Linked List
   DS: Linked List | Time: O(n)
   Note: Floyd’s Cycle Detection

9. Palindrome Linked List
   DS: Linked List | Time: O(n)
   Note: Reverse second half

---

🧱 Stack

10. Valid Parentheses
    DS: String, Stack | Time: O(n)
    Note: Match opening and closing

11. Min Stack
    DS: Stack | Time: O(1) per operation
    Note: Track min with auxiliary stack

---

🔍 Binary Search

12. Search in Rotated Sorted Array
    DS: Array | Time: O(log n)
    Note: Handle pivot logic

13. Find Minimum in Rotated Sorted Array
    DS: Array | Time: O(log n)
    Note: Binary search on rotated array

14. Median of Two Sorted Arrays
    DS: Array | Time: O(log(min(n,m)))
    Note: Partition logic in binary search

---

🌐 DFS / BFS

15. Number of Islands
    DS: Grid | Time: O(m*n)
    Note: Mark visited on grid

16. Clone Graph
    DS: Graph, HashMap | Time: O(V+E)
    Note: Use visited map

17. Word Ladder
    DS: Graph | Time: O(N * L^2)
    Note: Transform word by word

18. Binary Tree Level Order Traversal
    DS: Tree, Queue | Time: O(n)
    Note: Queue for level tracking

---

⛓ Topological Sort

19. Course Schedule
    DS: Graph | Time: O(V + E)
    Note: Kahn’s algorithm or DFS cycle detection

---

🔢 Heap / Priority Queue

20. Kth Largest Element in Array
    DS: Heap | Time: O(n log k)
    Note: Min Heap of size k

21. Top K Frequent Elements
    DS: Heap, HashMap | Time: O(n log k)
    Note: Frequency map + Heap

22. Merge K Sorted Lists
    DS: Linked List, Heap | Time: O(N log k)
    Note: Min Heap of list nodes

---

🔁 Backtracking

23. Subsets
    DS: Array | Time: O(2^n)
    Note: DFS include/exclude

24. Permutations
    DS: Array | Time: O(n!)
    Note: Track used elements

25. Combination Sum
    DS: Array | Time: O(2^n)
    Note: Include current or skip

---

📐 Dynamic Programming

26. Maximum Subarray
    DS: Array | Time: O(n)
    Note: Kadane’s Algorithm

27. Coin Change
    DS: Array | Time: O(amount * coins)
    Note: Bottom-up DP

28. Decode Ways
    DS: String | Time: O(n)
    Note: dp[i] = dp[i-1] + dp[i-2]

---

🌳 Trees (DFS / Recursion / Serialization)

29. Maximum Depth of Binary Tree
    DS: Tree | Time: O(n)

30. Lowest Common Ancestor
    DS: Tree | Time: O(n)

31. Serialize and Deserialize Binary Tree
    DS: Tree | Time: O(n)

32. Diameter of Binary Tree
    DS: Tree | Time: O(n)

---

🧮 Others

33. Merge Intervals
    Pattern: Sorting | Time: O(n log n)

34. Add Two Numbers
    Pattern: Linked List | Time: O(max(m,n))

35. LRU Cache
    Pattern: Design | Time: O(1)
    Note: Use HashMap + Doubly Linked List

36. Jump Game
    Pattern: Greedy | Time: O(n)

37. Redundant Connection
    Pattern: Union-Find | Time: O(n)

38. Implement Trie (Prefix Tree)
    Pattern: Trie | Time: O(n)

39. Daily Temperatures
    Pattern: Monotonic Stack | Time: O(n)

40. Spiral Matrix
    Pattern: Matrix Traversal | Time: O(m*n)