These problems appear in 80%+ of technical interviews across top tech companies. Mastering these will significantly boost your interview success rate.
Highest Frequency Problems (>90%)
Problems that appear in nearly every interview cycle at FAANG and top tech companies.Minimum Remove to Make Valid Parentheses
Frequency: 100.0% · Medium · Stack, StringRemove minimum parentheses to make string valid. Essential stack problem testing parenthesis matching with complexity constraints.Why it’s asked: Tests stack fundamentals, string manipulation, and optimization thinking.
Valid Word Abbreviation
Frequency: 95.4% · Easy · String, Two PointersCheck if a word matches an abbreviation pattern. Common in text processing scenarios.Why it’s asked: Tests two-pointer technique and edge case handling with strings.
Binary Tree Vertical Order Traversal
Frequency: 93.4% · Medium · Tree, BFS, Hash TableTraverse tree nodes by vertical column order. Critical for spatial data organization.Why it’s asked: Tests BFS, coordinate tracking, and hash table usage in tree problems.
Valid Palindrome II
Frequency: 92.7% · Easy · String, Two PointersCheck if string can become palindrome by removing at most one character.Why it’s asked: Tests two-pointer optimization and conditional logic branching.
Lowest Common Ancestor of Binary Tree III
Frequency: 89.6% · Medium · Tree, Hash TableFind LCA with parent pointer available. Essential tree traversal pattern.Why it’s asked: Tests tree navigation and cycle detection techniques.
Kth Largest Element in an Array
Frequency: 86.9% · Medium · Array, Heap, QuickselectFind kth largest using optimal heap or quickselect approach.Why it’s asked: Tests heap data structures and divide-and-conquer optimization.
Binary Tree Right Side View
Frequency: 86.0% · Medium · Tree, BFS, DFSReturn rightmost node at each level. Common pattern for level-order traversal.Why it’s asked: Tests BFS/DFS mastery and level tracking in trees.
Basic Calculator II
Frequency: 84.0% · Medium · Stack, String, MathImplement calculator with +, -, *, / operators. Classic stack application.Why it’s asked: Tests operator precedence handling and stack-based evaluation.
Must-Know Classics (>75%)
The foundation problems every software engineer should master.Two Sum
Frequency: 76.4% · Easy · Array, Hash TableFind two numbers that add up to target. The most iconic interview problem.Pattern: Hash table for O(1) complement lookup.Time: O(n) | Space: O(n)
Merge Intervals
Frequency: 77.9% · Medium · Array, SortingMerge all overlapping intervals. Essential for scheduling and calendar problems.Pattern: Sort by start time, then greedy merge.Time: O(n log n) | Space: O(n)
Top K Frequent Elements
Frequency: 77.9% · Medium · Array, Hash Table, HeapReturn k most frequent elements. Tests optimal selection algorithms.Pattern: Bucket sort for O(n) or heap for O(n log k).Time: O(n) | Space: O(n)
Merge k Sorted Lists
Frequency: 76.4% · Hard · Linked List, Heap, Divide & ConquerMerge k sorted linked lists efficiently. Classic heap application.Pattern: Min heap to track smallest current element across k lists.Time: O(N log k) | Space: O(k)
Best Time to Buy and Sell Stock
Frequency: 76.4% · Easy · Array, Dynamic ProgrammingMaximize profit with single buy/sell. Foundation for DP problems.Pattern: Track minimum price while calculating max profit.Time: O(n) | Space: O(1)
Valid Parentheses
Frequency: 74.9% · Easy · String, StackCheck if parentheses are properly matched. Fundamental stack problem.Pattern: Use stack to match opening/closing brackets.Time: O(n) | Space: O(n)
Clone Graph
Frequency: 71.4% · Medium · Graph, DFS, Hash TableDeep copy a graph with DFS/BFS. Essential graph traversal pattern.Pattern: Hash map to track old→new node mapping during traversal.Time: O(N + E) | Space: O(N)
LRU Cache
Frequency: 62.4% · Medium · Design, Hash Table, Linked ListImplement cache with O(1) get/put. Classic system design problem.Pattern: Hash table + doubly linked list for O(1) operations.Time: O(1) get/put | Space: O(capacity)
High-Difficulty Essentials (60%+)
Hard problems that separate strong candidates from exceptional ones.Minimum Window Substring
Frequency: 62.4% · Hard · String, Sliding Window, Hash TableFind minimum window containing all characters of target. Classic sliding window.Pattern: Expand window to find solution, contract to minimize.Time: O(m + n) | Space: O(k)
Find Median from Data Stream
Frequency: 40.7% · Hard · Design, Heap, Data StreamMaintain running median with two heaps. Advanced heap application.Pattern: Max heap for lower half, min heap for upper half.Time: O(log n) add, O(1) find | Space: O(n)
Preparation Strategy
Master the Top 8 (>80%)
Focus intensively on problems #001-#008. These appear in virtually every interview cycle. Understand not just the solution, but why these patterns are so fundamental.
Build Foundation with Classics
Study Two Sum, Valid Parentheses, Merge Intervals, and LRU Cache. These teach the core patterns that appear in hundreds of variations.
Practice Problem Variations
Once you master the core problem, practice its variations:
- Two Sum → Two Sum II, Three Sum, Four Sum
- Valid Parentheses → Remove Invalid Parentheses, Minimum Remove
- Merge Intervals → Insert Interval, Meeting Rooms II
Priority Tiers
- 🔥 Critical (Week 1)
- ⭐ Essential (Week 2)
- 💪 Advanced (Week 3-4)
Must master these first:
- Two Sum (#017) - Hash table fundamentals
- Valid Parentheses (#020) - Stack basics
- Merge Intervals (#016) - Sorting + greedy
- Best Time to Buy/Sell Stock (#018) - Simple DP
- Minimum Remove Parentheses (#001) - Stack + string manipulation
Interview Success Tips
How to Recognize High-Frequency Patterns
How to Recognize High-Frequency Patterns
When you see these keywords in a problem, think of these approaches:
- “Find two numbers that…” → Hash table for O(1) lookup
- “Matching/Valid parentheses” → Stack
- “Kth largest/smallest” → Min/max heap of size k
- “Merge intervals/meetings” → Sort + greedy merge
- “Maximum/Minimum subarray” → Kadane’s or sliding window
- “Design a cache/data structure” → Combine multiple structures (hash + list)
Common Interview Follow-Ups
Common Interview Follow-Ups
Be prepared for these variations:Two Sum:
- What if array is sorted? (Two pointers)
- What if we need all pairs? (Avoid duplicates)
- What about three numbers? (3Sum pattern)
- What if we can remove characters? (Minimum Remove)
- Count minimum insertions needed? (Counter approach)
- How to handle concurrent access? (Locks)
- What if we need LFU instead? (Two hash maps + freq tracking)
Complexity Expectations
Complexity Expectations
For high-frequency problems, interviewers expect optimal solutions:
| Problem Type | Expected Time | Expected Space |
|---|---|---|
| Array/String search | O(n) | O(1) or O(n) |
| Sorting required | O(n log n) | O(1) or O(n) |
| Tree traversal | O(n) | O(h) |
| Graph traversal | O(V + E) | O(V) |
| Heap operations | O(n log k) | O(k) |
| Design problems | O(1) operations | O(capacity) |
Why These Problems Matter
These high-frequency problems aren’t arbitrary—they test fundamental skills that translate directly to production engineering:- Hash tables (Two Sum, LRU Cache): Core to caching, indexing, and fast lookups in real systems
- Stacks (Valid Parentheses): Essential for parsing, expression evaluation, and undo/redo functionality
- Heaps (Kth Largest, Merge k Lists): Used in priority queues, task scheduling, and top-k queries
- Sliding window (Minimum Window): Powers rate limiting, moving averages, and stream processing
- Graph traversal (Clone Graph): Foundation for social networks, dependency resolution, and recommendation systems
Next Steps
Ready to master these problems? Check out our structured 4-week study plan with daily practice schedules and progress tracking.