🚀 100 Must-Solve DSA Questions for MAANG+ Interviews 🌟

📝 Note: This curated list is your ultimate guide 🌍 to acing MAANG+ interviews! Handpicked to cover the most essential Data Structures and Algorithms (DSA) concepts, these problems ensure you build a solid foundation for your coding interviews 🚀.

📚 Table of Contents

1. 🔢 Arrays
2. 🔤 Strings
3. 👯 Two Pointers
4. 🥞 Stack & Queue
5. 🔄 Recursion & Backtracking
6. 💻 Dynamic Programming
7. 🌲 Tree
8. 🔗 Graph & BFS/DFS
9. 🔍 Binary Search
10. 📈 Greedy
11. ➕ Math
12. 🔣 Bit Manipulation
13. 🔗 Linked List
14. 🏗️ Heap/Priority Queue
15. 🪟 Sliding Window / Interval Problems

🔢 Array

1. Two Sum

   • Concepts: Hashing, Single-pass solution
   • Why Important: Classic question testing array traversal and hash map usage.

2. Best Time to Buy and Sell Stock

   • Concepts: Sliding Window, Greedy
   • Why Important: Tests ability to track min/max values in one pass.

3. Move Zeroes

   • Concepts: Two-pointer approach
   • Why Important: In-place array manipulation and partitioning technique.

4. Remove Duplicates from Sorted Array

   • Concepts: In-place updates, Two pointers
   • Why Important: Frequently asked for array manipulation.

5. 3Sum

   • Concepts: Sorting, Two pointers
   • Why Important: Tests array manipulation and avoiding duplicates.

6. Product of Array Except Self

   • Concepts: Prefix and suffix products
   • Why Important: Classic problem without using division.

7. Subarray Sum Equals K

   • Concepts: Prefix sums, Hashing
   • Why Important: Common pattern for solving subarray sum problems.

8. Next Permutation

   • Concepts: Lexicographical ordering, In-place transformations
   • Why Important: Tests the understanding of array rearrangements.

9. 4Sum

   • Concepts: Sorting, Two Pointers
   • Why Important: Extension of 2-sum and 3-sum patterns.

10. Find the Duplicate Number

    • Concepts: Floyd's Tortoise and Hare (Cycle detection)
    • Why Important: Pattern for detecting cycles with constant extra space.

🔤 Strings

11. Longest Common Prefix

    • Concepts: String traversal, Comparison
    • Why Important: Basic string processing pattern.

12. Valid Palindrome II

    • Concepts: Two pointers
    • Why Important: Palindrome checks are very common in interviews.

13. Longest Substring Without Repeating Characters

    • Concepts: Sliding window, Hashing
    • Why Important: Tests efficient sub-string search technique.

14. Group Anagrams

    • Concepts: Hashing, Sorting
    • Why Important: Common approach to grouping based on sorted keys.

15. Minimum Remove to Make Valid Parentheses

    • Concepts: Stack-based approach, String building
    • Why Important: Handling mismatched parentheses is a common interview theme.

16. Longest Palindromic Substring

    • Concepts: Expand around center, Dynamic programming
    • Why Important: Shows multiple ways (center expansion, DP) to handle string DP.

17. Integer to Roman

    • Concepts: Greedy, Mapping
    • Why Important: Classical string + math combination.

18. Reverse Words in a String

    • Concepts: String manipulation, Splitting
    • Why Important: Tests in-place reversal logic.

19. Zigzag Conversion

    • Concepts: Simulation, String building
    • Why Important: Pattern-based re-indexing.

20. Minimum Window Substring

    • Concepts: Sliding window, Frequency counts
    • Why Important: Widely asked, tests multiple edge cases in string processing.

👯 Two Pointers

21. Sort Colors

    • Concepts: Dutch National Flag problem
    • Why Important: Common partitioning approach.

22. Partition Labels

    • Concepts: Greedy, Counting frequency
    • Why Important: Great example of multi-pass scanning.

23. Longest Repeating Character Replacement

    • Concepts: Sliding window, Frequency counts
    • Why Important: Classic substring + two-pointer approach.

24. Maximum Number of Visible Points

    • Concepts: Geometry, Two pointers
    • Why Important: Showcases advanced two-pointer usage.

25. Subarrays with K Different Integers

    • Concepts: Sliding window, HashMap
    • Why Important: Important for subarray + distinct element problems.

🥞 Stack & Queue

26. Min Stack

    • Concepts: Stack, Track min in O(1)
    • Why Important: Implementation detail & design.

27. Next Greater Element I

    • Concepts: Monotonic stack
    • Why Important: Very common interview question pattern.

28. Implement Queue using Stacks

    • Concepts: Stack, Queue
    • Why Important: Data structure transformation.

29. Daily Temperatures

    • Concepts: Monotonic stack
    • Why Important: Extension of next greater element.

30. Evaluate Reverse Polish Notation

    • Concepts: Stack usage
    • Why Important: Expression parsing is common in interviews.

🔄 Recursion & Backtracking

31. What is Recursion?

    • Conceptual question
    • Why Important: Understand the fundamental principle of recursive calls.

32. Pow(x, n)

    • Concepts: Divide and Conquer, Fast exponentiation
    • Why Important: Basic recursion with optimization.

33. Subsets

    • Concepts: Backtracking
    • Why Important: Foundation for generating combinations/powersets.

34. Permutations

    • Concepts: Backtracking, Swapping
    • Why Important: Very commonly asked for generating permutations.

35. Combination Sum

    • Concepts: Backtracking, Branching
    • Why Important: Tests handling repeated numbers in combinations.

36. Letter Combinations of a Phone Number

    • Concepts: Backtracking, String building
    • Why Important: Common pattern for recursion tree building.

37. Word Search

    • Concepts: DFS, Backtracking
    • Why Important: 2D grid backtracking.

38. N-Queens

    • Concepts: Backtracking, Constraint checks
    • Why Important: Quintessential backtracking problem.

39. Partition to K Equal Sum Subsets

    • Concepts: Backtracking, Subset sum
    • Why Important: Tests optimization with memoization or backtracking prunes.

40. Rat in a Maze (Classic)

    • Concepts: Backtracking on a grid
    • Why Important: Interviewers love variations of grid-based backtracking.

💻 Dynamic Programming

41. Maximum Subarray

    • Concepts: Kadane’s algorithm
    • Why Important: Most asked in interviews. Classic DP example.

42. Climbing Stairs

    • Concepts: Fibonacci pattern
    • Why Important: Intro to DP basics.

43. House Robber

    • Concepts: DP with adjacency constraints
    • Why Important: 1D DP with skipping constraints.

44. Coin Change

    • Concepts: Unbounded knapsack pattern
    • Why Important: Classic DP problem for combination sums.

45. Longest Increasing Subsequence

    • Concepts: Binary search optimization, DP
    • Why Important: Another all-time favorite DP problem.

46. Palindrome Substrings

    • Concepts: Expand around center, DP
    • Why Important: String-based DP problem focusing on substring checks.

47. Maximal Square

    • Concepts: 2D DP
    • Why Important: Common 2D grid DP approach.

48. Decode Ways

    • Concepts: String DP
    • Why Important: Tests the understanding of sequential DP states.

49. Word Break

    • Concepts: String DP, Checking dictionary subsets
    • Why Important: Realistic scenario—commonly asked.

50. Trapping Rain Water

    • Concepts: Two-pointer or DP approach
    • Why Important: Very frequently asked, tests ability to calculate trapped water by heights.

🌲 Tree

51. Invert Binary Tree

    • Concepts: Tree traversal, Recursion
    • Why Important: Classic easy question to warm up with trees.

52. Symmetric Tree

    • Concepts: BFS/DFS
    • Why Important: Checking symmetry via recursion or queue-based BFS.

53. Binary Tree Inorder Traversal

    • Concepts: DFS, Using stack
    • Why Important: Basic traversal pattern, iterative vs recursive.

54. Diameter of Binary Tree

    • Concepts: DFS, Postorder
    • Why Important: Tests recursion on subtrees.

55. Lowest Common Ancestor of a Binary Tree

    • Concepts: DFS
    • Why Important: LCA is a must-know pattern for many advanced tree problems.

56. Validate Binary Search Tree

    • Concepts: DFS with range constraints, Inorder checks
    • Why Important: Checking BST property is a standard interview question.

57. Binary Tree Level Order Traversal

    • Concepts: BFS
    • Why Important: Foundation for BFS on trees.

58. Binary Tree Right Side View

    • Concepts: BFS or DFS
    • Why Important: Classic BFS level-by-level variant.

59. Kth Smallest Element in a BST

    • Concepts: Inorder traversal
    • Why Important: BST property usage + traversal.

60. Binary Tree Maximum Path Sum

    • Concepts: DFS, Postorder
    • Why Important: Common tricky question involving returning multiple info up the recursion.

🔗 Graph & BFS/DFS

61. Number of Islands

    • Concepts: BFS/DFS
    • Why Important: Fundamental grid connectivity.

62. Course Schedule II

    • Concepts: Topological Sort, DFS
    • Why Important: Must-know approach for scheduling/dependency problems.

63. Clone Graph

    • Concepts: Graph traversal, HashMap
    • Why Important: Tests deep copy of graph structures.

64. Shortest Bridge

    • Concepts: BFS from boundary
    • Why Important: BFS on 2D grids with region identification.

65. All Paths From Source to Target

    • Concepts: DFS, Backtracking
    • Why Important: Paths enumeration in a DAG.

66. Is Graph Bipartite?

    • Concepts: BFS/DFS, Graph coloring
    • Why Important: Classic bipartite check is widely asked.

67. Network Delay Time

    • Concepts: Dijkstra’s Algorithm
    • Why Important: Weighted graph shortest path in coding interviews.

68. Number of Provinces

    • Concepts: Union-Find or DFS
    • Why Important: Basic connectivity checks in graphs.

69. Critical Connections in a Network

    • Concepts: Tarjan’s algorithm, Bridges in a graph
    • Why Important: Advanced graph problem frequently asked in top-tier interviews.

70. Word Ladder

    • Concepts: BFS in word transformation
    • Why Important: Classic BFS with transformation rules.

🔍 Binary Search

71. Binary Search

    • Concepts: Iterative / Recursive search
    • Why Important: Foundation of efficient searching.

72. Search in Rotated Sorted Array

    • Concepts: Modified Binary Search
    • Why Important: Very common pattern for rotating arrays.

73. Find First and Last Position of Element in Sorted Array

    • Concepts: Binary search boundaries
    • Why Important: Edge-case heavy problem, testing boundary conditions.

74. Find Peak Element

    • Concepts: Binary search, Local maxima
    • Why Important: Interviews love variations of peak-finding.

75. Median of Two Sorted Arrays

    • Concepts: Binary search on partitions
    • Why Important: Top-tier problem testing advanced binary search skills.

📈 Greedy

76. Gas Station

    • Concepts: Greedy, Circuit completeness
    • Why Important: Determining start point for a circular tour.

77. Task Scheduler

    • Concepts: Greedy, Counting
    • Why Important: Scheduler-type problems are popular.

78. Non-overlapping Intervals

    • Concepts: Interval scheduling
    • Why Important: Sorting intervals + selecting optimal sets is a frequent ask.

79. Remove K Digits

    • Concepts: Stack-based greedy
    • Why Important: Minimizing a numeric string with constraints.

80. Candy

    • Concepts: Greedy distribution
    • Why Important: Another commonly asked problem in big tech.

➕ Math

81. Reverse Integer

    • Concepts: Overflow checks, Math manipulation
    • Why Important: Edge cases with integer bounds.

82. Add Binary

    • Concepts: Bitwise addition, String manipulation
    • Why Important: Shows how to handle carry bits in strings.

83. Palindrome Number

    • Concepts: Numerical palindrome check
    • Why Important: Quick math problem, easy to slip on edge cases.

84. Power of Two

    • Concepts: Bitwise check or repeated multiplication
    • Why Important: Basic check that’s often asked as a warm-up.

85. String to Integer (atoi)

    • Concepts: Parsing, Edge cases
    • Why Important: Handling whitespace, signs, overflow.

🔣 Bit Manipulation

86. Sum of Two Integers

    • Concepts: Bitwise operations, Full adder logic
    • Why Important: Fundamental for bit manipulation mastery.

87. Count of 1 Bits

    • Concepts: Bit manipulation, n & (n-1)
    • Why Important: Basic yet common in bit manipulation discussions.

🔗 Linked List

88. Reverse Linked List

    • Concepts: Pointers, Iteration, Recursion
    • Why Important: Fundamental reversal logic.

89. Merge Two Sorted Lists

    • Concepts: Linked List pointers
    • Why Important: Basic merging of sorted data.

90. Linked List Cycle

    • Concepts: Cycle detection (Floyd’s Tortoise and Hare)
    • Why Important: Classic question testing cycle detection.

91. Linked List Cycle II

    • Concepts: Finding cycle start
    • Why Important: Extension to cycle detection, a must-know.

92. Intersection of Two Linked Lists

    • Concepts: Dual-pointer technique
    • Why Important: Common pattern for list intersections.

93. Palindrome Linked List

    • Concepts: Midpoint, Reverse second half
    • Why Important: Tests combined knowledge of reversal, pointers, and palindrome check.

94. Merge k Sorted Lists

    • Concepts: Divide and Conquer, Priority Queue
    • Why Important: Often asked in big tech, extends merging concept.

🏗️ Heap/Priority Queue

95. K Closest Points to Origin

    • Concepts: Max-heap or Quickselect
    • Why Important: Classic top-k problem.

96. Kth Largest Element in an Array

    • Concepts: Heap or Quickselect
    • Why Important: Very common question for partial sorting.

97. Reorganize String

    • Concepts: Max-heap or counting
    • Why Important: Tests building strings from frequency constraints.

98. Ugly Number II

    • Concepts: DP, Min-heap
    • Why Important: Interesting approach mixing DP and heap logic.

🪟 Sliding Window / Interval Problems

99. Max Consecutive Ones III

    • Concepts: Sliding window with conditional expansion
    • Why Important: Variation of subarray with constraints.

100. Grumpy Bookstore Owner

     • Concepts: Sliding window with partial sums
     • Why Important: Perfect demonstration of window with a twist.

---

Feel free to dive into each section for detailed problems and discussions designed to prepare you comprehensively for your upcoming interviews. Remember, practice makes perfect!

⭐ Tip: Click the badges next to problem names to filter by difficulty!

💬 Contributing

We welcome pull requests and issues from the community! Check the contributing guidelines for more details on how to propose enhancements or report bugs. If you find this resource helpful, please don't forget to star 🌟 the repo!

---

🙌 Support

If you found this repository helpful, please consider giving it a star ⭐ and sharing it with others preparing for their interviews!