LeetCode Study Plan for FAANG: Land Your Dream Job in 3 Months

You've decided to grind LeetCode to land a $300K+ FAANG job. But staring at 2,900+ problems is overwhelming.

Which problems matter? How many should you solve? What topics are most important?

This guide gives you a 12-week study plan used by engineers who landed offers at Google, Meta, and Amazon.

TL;DR: Solve 150 problems (not 500+) from curated list below. Focus on patterns, not memorization. Mock interviews in weeks 10-12.

---

The 12-Week Study Plan (Overview)

Weeks	Focus	Problems/Week	Difficulty
1-2	Arrays & Hashing	15	Easy-Medium
3-4	Two Pointers & Sliding Window	15	Medium
5-6	Trees & Graphs	20	Medium-Hard
7-8	Dynamic Programming	15	Medium-Hard
9	Heaps, Stacks, Queues	10	Medium
10-12	System Design + Mocks	5 + mocks	-

Total: 150 problems + 10 mock interviews = FAANG-ready

---

Week 1-2: Arrays & Hashing (Foundation)

Why Start Here?

• 40% of FAANG coding questions involve arrays/hash maps
• Easiest to build confidence early

Problems to Solve (15 total):

Easy (5):

1. Two Sum
2. Contains Duplicate
3. Valid Anagram
4. Best Time to Buy and Sell Stock
5. Valid Parentheses

Medium (10):

6. Product of Array Except Self
7. Top K Frequent Elements
8. Group Anagrams
9. Longest Consecutive Sequence
10. Encode and Decode Strings
11. 3Sum
12. Container With Most Water
13. Subarray Sum Equals K
14. Longest Substring Without Repeating Characters
15. Minimum Window Substring

Key Patterns:

• Hash map for O(1) lookup
• Prefix sums for subarray problems
• Sliding window for substring problems

Goal: Solve all 15 problems, understand patterns, not memorize solutions.

---

Week 3-4: Two Pointers & Sliding Window

Why This Matters?

• Common in Amazon and Google interviews
• Optimizes brute force O(n²) solutions to O(n)

Problems to Solve (15 total):

Medium (12):

1. Two Sum II (sorted array)
2. 3Sum (with duplicates)
3. 4Sum
4. Trapping Rain Water
5. Longest Repeating Character Replacement
6. Permutation in String
7. Minimum Size Subarray Sum
8. Fruit Into Baskets
9. Max Consecutive Ones III
10. Longest Substring with At Most K Distinct Characters
11. Subarrays with K Different Integers
12. Minimum Window Substring

Hard (3):

13. Sliding Window Maximum
14. Minimum Window Substring (Hard version)
15. Longest Duplicate Substring

Key Patterns:

• Two pointers (left/right moving toward each other)
• Sliding window (expand right, contract left)
• Hash map + sliding window combo

Pro tip: Draw the window movement on paper—visualizing helps.

---

Week 5-6: Trees & Graphs (Critical)

Why This Matters?

• 30% of FAANG questions are tree/graph problems
• Tests recursive thinking and DFS/BFS mastery

Problems to Solve (20 total):

Trees (10):

1. Invert Binary Tree
2. Maximum Depth of Binary Tree
3. Same Tree
4. Subtree of Another Tree
5. Lowest Common Ancestor of BST
6. Binary Tree Level Order Traversal
7. Validate Binary Search Tree
8. Kth Smallest Element in BST
9. Construct Binary Tree from Preorder and Inorder
10. Serialize and Deserialize Binary Tree

Graphs (10):

11. Number of Islands
12. Clone Graph
13. Course Schedule (DFS cycle detection)
14. Course Schedule II (topological sort)
15. Pacific Atlantic Water Flow
16. Word Ladder
17. Redundant Connection (Union-Find)
18. Network Delay Time (Dijkstra)
19. Cheapest Flights Within K Stops
20. Alien Dictionary (topological sort)

Key Patterns:

• DFS vs BFS (when to use which?)
• Recursion for trees
• Topological sort for DAGs
• Union-Find for connected components

Cheat sheet:

• DFS: Use when exploring all paths, backtracking
• BFS: Use for shortest path, level-order traversal

---

Week 7-8: Dynamic Programming (The Final Boss)

Why This Matters?

• 20% of FAANG questions (especially Google)
• Separates senior from junior candidates

Problems to Solve (15 total):

1D DP (7):

1. Climbing Stairs
2. House Robber
3. House Robber II
4. Longest Palindromic Substring
5. Palindromic Substrings
6. Decode Ways
7. Coin Change

2D DP (8):

8. Unique Paths
9. Longest Common Subsequence
10. Best Time to Buy and Sell Stock with Cooldown
11. Coin Change 2
12. Target Sum
13. Interleaving String
14. Longest Increasing Path in Matrix
15. Edit Distance

Key Patterns:

• Top-down (memoization) vs bottom-up (tabulation)
• State definition: What does dp[i] represent?
• Recurrence relation: How does dp[i] relate to previous states?

Pro tip: Always start with brute-force recursive solution, then add memoization.

---

Week 9: Heaps, Stacks, Queues

Why This Matters?

• 10% of FAANG questions
• Often combined with other patterns (heap + greedy, stack + monotonic)

Problems to Solve (10 total):

Heaps (5):

1. Kth Largest Element in Array
2. Top K Frequent Elements
3. Find Median from Data Stream
4. Task Scheduler
5. Merge K Sorted Lists

Stacks & Queues (5):

6. Min Stack
7. Daily Temperatures
8. Largest Rectangle in Histogram
9. Trapping Rain Water (monotonic stack)
10. Sliding Window Maximum (monotonic deque)

Key Patterns:

• Min-heap vs max-heap (when to use which?)
• Monotonic stack (next greater/smaller element)
• Priority queue for scheduling problems

---

Week 10-12: System Design + Mock Interviews

Why This Matters?

• FAANG interviews have 1-2 system design rounds
• No amount of LeetCode will save you if you bomb system design

System Design Topics (Week 10-11):

1. Scalability basics: Load balancers, caching, CDNs
2. Databases: SQL vs NoSQL, sharding, replication
3. Messaging: Queues (SQS, Kafka), pub/sub
4. Design problems:
   • Design YouTube
   • Design Twitter feed
   • Design Uber
   • Design Google Drive
   • Design URL shortener

Resources:

• Designing Data-Intensive Applications (book)
• System Design Primer (GitHub repo)
• YouTube: Exponent, Tech Dummies

Mock Interviews (Week 12):

• 10+ mock interviews (Pramp, Interviewing.io, friends)
• Simulate real conditions (45 min, shared doc, no debugger)
• Record yourself and review

Pro tip: Mock interviews reveal gaps in communication, not just coding.

---

FAANG-Specific Problem Lists

Google (Hardest)

• Focus on Hard problems (30% of Google interviews)
• Topics: DP, graphs, trees
• Browse 1,200+ Google jobs

Must-do Google problems:

• Word Ladder II
• Serialize and Deserialize Binary Tree
• Alien Dictionary
• Edit Distance
• LRU Cache

Meta (Medium-Hard)

• Focus on medium problems with optimal solutions
• Topics: Arrays, hash maps, trees
• Browse 500+ Meta jobs

Must-do Meta problems:

• Product of Array Except Self
• Binary Tree Vertical Order Traversal
• Pow(x, n)
• Merge Intervals
• Valid Palindrome II

Amazon (Easiest)

• Focus on medium problems (Hards are rare)
• Topics: Arrays, trees, DFS/BFS
• Browse 2,500+ Amazon jobs

Must-do Amazon problems:

• Two Sum
• Merge Two Sorted Lists
• Number of Islands
• LRU Cache
• Top K Frequent Words

---

How to Study Effectively (Not Just Solve)

❌ Bad Approach:

• Solve 500+ problems randomly
• Look at solution after 5 minutes
• Memorize solutions

✅ Good Approach:

• Solve 150 curated problems by pattern
• Struggle for 30-45 minutes before looking at hints
• Redo problems 3 days later (spaced repetition)

Rule of thumb: If you can't solve a problem in 25 minutes on your 2nd attempt, you don't understand the pattern yet.

---

Time Management (12-Week Schedule)

If You Have a Full-Time Job:

• Weekdays: 1.5-2 hours/day (1-2 problems)
• Weekends: 4-5 hours/day (5-6 problems)
• Total: 15-20 hours/week

If You're Unemployed:

• Daily: 6-8 hours/day (5-7 problems)
• Total: 40-50 hours/week (finish in 6 weeks)

Burnout warning: Don't grind 10 hours/day—your brain needs rest.

---

Common Mistakes (Avoid These)

Step 1: Solving Too Many Problems

• Quality > quantity
• 150 problems deeply understood > 500 problems rushed

Step 2: Skipping System Design

• You can't LeetCode your way into Google without system design

Step 3: Not Doing Mocks

• Real interviews feel 10x harder than solo LeetCode

Step 4: Memorizing Solutions

• Interviewers can tell when you've memorized
• Focus on pattern recognition, not memorization

Step 5: Ignoring Edge Cases

• Empty arrays, null inputs, negative numbers
• FAANG interviewers always ask: "What edge cases did you consider?"

---

LeetCode Alternatives

Paid Platforms (Worth It):

• AlgoExpert ($99/year) - Best for system design
• Interviewing.io ($100/month) - Mock interviews with FAANG engineers
• NeetCode Pro ($39/month) - Video explanations for all 150 problems

Free Alternatives:

• NeetCode (YouTube) - Free video explanations
• Tech Interview Handbook (GitHub) - Free study guide
• Pramp - Free peer mock interviews

Our pick: NeetCode (free) + AlgoExpert (system design) = $99/year total

---

Study Resources

Books:

• Cracking the Coding Interview (Gayle McDowell)
• Elements of Programming Interviews (Aziz, Lee, Prakash)
• Designing Data-Intensive Applications (Martin Kleppmann)

YouTube Channels:

• NeetCode
• Nick White
• Back To Back SWE
• Exponent (system design)

Websites:

• LeetCode (duh)
• NeetCode.io (150-problem roadmap)
• Levels.fyi (salary negotiation)

---

Week-by-Week Checklist

Week 1-2: Arrays & Hashing

• Solve 15 problems
• Understand hash map O(1) lookup
• Master sliding window pattern

Week 3-4: Two Pointers & Sliding Window

• Solve 15 problems
• Understand two-pointer technique
• Optimize O(n²) to O(n)

Week 5-6: Trees & Graphs

• Solve 20 problems
• Master DFS vs BFS
• Understand recursion for trees

Week 7-8: Dynamic Programming

• Solve 15 problems
• Understand memoization vs tabulation
• Solve 1D and 2D DP problems

Week 9: Heaps, Stacks, Queues

• Solve 10 problems
• Understand heap operations
• Master monotonic stack

Week 10-11: System Design

• Study scalability, databases, caching
• Design 5 systems (YouTube, Twitter, Uber, etc.)
• Read DDIA (Chapters 1-6)

Week 12: Mock Interviews

• Do 10+ mock interviews
• Record and review your performance
• Fix gaps in communication

---

After 12 Weeks: Apply Strategically

Don't Just Apply to FAANG:

• Apply to 50+ companies (increase your odds)
• Target unicorns too: Stripe, Databricks, Airbnb
• Use referrals (3x higher interview rate)

Browse 200K+ tech jobs on Leethub

Top Companies Hiring Now:

• Google (1,200+ jobs)
• Meta (500+ jobs)
• Amazon (2,500+ jobs)
• Apple (400+ jobs)
• Netflix (50+ jobs)

---

Final Tips from FAANG Engineers

From a Google L5:

"I solved 120 problems over 3 months. Focused on patterns, not memorization. Got offers from Google and Meta."

From a Meta E5:

"Mock interviews were more valuable than solving 50 extra problems. Do them early and often."

From an Amazon L6:

"Amazon interviews are easier than people think. Solve 75 medium problems and you're golden."

---

You Got This! 💪

Action plan:

1. Week 1: Start with Arrays & Hashing (solve 7 problems this week)
2. Week 12: Apply to 50+ companies
3. Week 14: Get multiple offers, negotiate, accept $300K+ TC

Remember: Consistency > intensity. 1.5 hours/day for 12 weeks > 10 hours/day for 2 weeks.

Good luck! 🚀

---

Last updated: January 2025
Problems curated from: NeetCode, Blind 75, Grind 75, FAANG interview experiences