Choosing the Right Problems

Not all practice problems are created equal. Here's how to choose problems that accelerate your learning.

The Problem Selection Framework

Level 1: Pattern-Based Selection (Weeks 1-4)

Goal: Learn and master each pattern.

How to choose:

1. Pick a pattern (e.g., sliding window)
2. Find 10-15 problems tagged with that pattern
3. Sort by difficulty and acceptance rate
4. Start with highest acceptance (easiest)
5. Progress to medium, then hard

Example - Sliding Window:

Easy (Build Confidence):
1. Maximum Average Subarray I
2. Minimum Size Subarray Sum
3. Find All Anagrams in a String

Medium (Core Practice):
4. Longest Substring Without Repeating Characters
5. Longest Repeating Character Replacement
6. Minimum Window Substring
7. Fruit Into Baskets

Hard (Edge Cases):
8. Sliding Window Maximum
9. Minimum Window Subsequence
10. Subarrays with K Different Integers

Level 2: Mixed Pattern Selection (Weeks 5-8)

Goal: Recognize patterns without hints.

How to choose:

1. Don't filter by pattern/tag
2. Mix difficulties
3. Force yourself to identify the pattern
4. Draw from multiple topics you've studied

Example Daily Mix:

Problem 1: Two Sum II (Two Pointers)
Problem 2: Top K Frequent Elements (Hash Map + Heap)
Problem 3: Letter Combinations (Backtracking)

Level 3: Company-Specific Selection (Weeks 9-12)

Goal: Prepare for target companies.

How to choose:

1. Use company tags on LeetCode
2. Check Glassdoor for recent questions
3. Focus on their most frequent questions
4. Practice in their interview format

The Difficulty Progression

Start Too Easy, Not Too Hard

The Goldilocks Zone:

Current skill → Start one level below

If you're targeting mediums:
- Start with easy
- Build to medium
- Occasionally try hard

If you're comfortable with mediums:
- Quick review of easy
- Focus on medium
- Build to hard

The 70% Rule

You should be able to solve ~70% of problems at your current level:

Too Easy (>90% success): Not learning much
Just Right (60-80% success): Optimal growth zone
Too Hard (<50% success): Frustrating, inefficient

When to Move Up

Move to next difficulty when:

• ✅ Solving 80%+ without hints
• ✅ Can explain solution clearly
• ✅ Recognize patterns quickly
• ✅ Finish in reasonable time

Problem Quality Indicators

High-Quality Problems ✅

Characteristics:

• Teaches a clear pattern
• Appears frequently in interviews
• Has good test cases
• Clear problem statement
• Reasonable constraints

LeetCode Indicators:

• High acceptance rate (for its difficulty)
• Many "Helpful" votes in discussions
• Tagged "Top Interview Questions"
• Company tagged (especially FAANG)
• 1000+ submissions

Examples:

• Two Sum
• Valid Parentheses
• Longest Substring Without Repeating
• Course Schedule
• LRU Cache

Low-Quality Problems ❌

Characteristics:

• Trick question or obscure knowledge
• Poorly written description
• Unrealistic constraints
• Rarely asked in interviews
• No clear pattern

LeetCode Indicators:

• Low acceptance rate with many downvotes
• Many complaints in discussions
• Ambiguous problem statement
• No company tags
• < 100 submissions

Skip these - they won't help your interview prep.

Problem Lists by Goal

Goal: Get First Offer

Focus: Most common patterns

Blind 75: 75 essential problems covering all patterns
- Best for: First-time prep
- Time: 4-6 weeks
- Link: Popular curated list

Grind 75: Modernized version of Blind 75
- Best for: Up-to-date prep
- Time: 6-8 weeks
- Organized by week

Leetcode Top 100 Liked Questions
- Best for: Broad coverage
- Time: 6-8 weeks

Goal: FAANG Specifically

Focus: Company-tagged questions

For each target company:
1. LeetCode premium company tag
2. Last 6 months of questions
3. Focus on most frequent
4. Practice in pairs (phone screen format)

Priority Order:
- Meta: Focus on medium problems, fast solutions
- Google: Expect harder problems, clean code
- Amazon: Leadership principles + medium problems
- Apple: Design + implementation
- Microsoft: Balanced, emphasis on explanation

Goal: Strengthen Weak Areas

Focus: Targeted practice

Weak at DP?
→ Do 20 DP problems, easy to hard

Slow at implementation?
→ Timed practice, 30 min per problem

Miss edge cases?
→ Do problems with tricky edge cases
   (empty input, single element, duplicates)

Can't optimize?
→ Do problems with obvious O(n²) → O(n) optimization

The Daily Problem Selection

Balanced Day (1-2 hours)

Problem 1 (30 min): Easy/Warm-up
- Review topic
- Build confidence
- Get in the zone

Problem 2 (45 min): Medium/Main Practice
- Core difficulty level
- Pattern practice
- Most time here

Problem 3 (30 min): Stretch Problem
- Hard problem OR new pattern
- Push boundaries
- Okay to not finish

Intense Day (3-4 hours)

Morning (2 hours):
- 1 medium (solve completely)
- 1 hard (attempt, learn from solution)

Break

Afternoon (1.5 hours):
- 2-3 medium from mixed topics
- Review mistakes

Evening (30 min):
- Review today's problems
- Update pattern notes

Light Day (30 min)

- 1-2 easy problems
- Review previous solutions
- Watch a solution video
- Read about new technique

Problem Sources Ranked

Tier 1: Best ROI

LeetCode

• Pros: Largest database, company tags, community
• Cons: Expensive for premium
• Best for: Everyone

Blind 75 / Grind 75

• Pros: Curated, proven list
• Cons: Might miss some patterns
• Best for: Time-limited prep

Tier 2: Good Supplementary

AlgoExpert

• Pros: Video explanations, organized
• Cons: Smaller problem set
• Best for: Visual learners

HackerRank

• Pros: Structured paths, good for beginners
• Cons: Not as interview-focused
• Best for: Fundamentals

Tier 3: Specific Use Cases

CodeSignal

• Best for: Company assessments

Pramp

• Best for: Mock interviews

Daily Coding Problem

• Best for: Consistency

Problem Selection Anti-Patterns

❌ Random Browsing

Bad: "Let me just pick whatever looks interesting"

Why it's bad: No pattern reinforcement, no systematic coverage.

Fix: Follow a structured list or study by pattern.

❌ Only Easy Problems

Bad: "I'll just do 100 easy problems to build confidence"

Why it's bad: False confidence, won't be ready for interview difficulty.

Fix: Progress to medium quickly. 60% of practice should be medium.

❌ Only Hard Problems

Bad: "I'll just do hard problems to challenge myself"

Why it's bad: Frustrating, slow progress, miss fundamentals.

Fix: Build foundation with easy/medium first.

❌ Chasing Acceptance Rate

Bad: "I'll only do problems with >70% acceptance rate"

Why it's bad: Miss important patterns, false sense of skill.

Fix: Mix difficulties. Some important problems are hard.

❌ Repeating Same Problems

Bad: "I'll do this problem I already know 10 more times"

Why it's bad: Not learning anything new.

Fix: Review periodically (spaced repetition), but prioritize new problems.

Weekly Problem Plan Template

Monday: Pattern Focus Day
- Learn new pattern OR review weak pattern
- 3 problems in that pattern (easy → medium → medium)

Tuesday: Mixed Practice
- 2-3 medium problems, different patterns
- No hints/tags, identify pattern yourself

Wednesday: Depth Day
- 1 hard problem
- Spend 1-2 hours understanding deeply
- Study multiple solutions

Thursday: Speed Day
- 3-4 easy/medium problems
- Set 30-minute timers
- Practice for speed

Friday: Mock Interview
- 1-2 problems in interview conditions
- Time yourself: 45 minutes
- Practice explaining solution

Weekend: Review & Learn
- Saturday: Review week's mistakes
- Sunday: Learn new technique or deep-dive topic

Progression Checklist

Track your problem-solving ability:

Beginner (Weeks 1-2):

• Can solve easy problems (>80%)
• Understand basic patterns
• Can implement with guidance

Intermediate (Weeks 3-6):

• Can solve medium problems (>60%)
• Recognize patterns independently
• Can optimize brute force solutions

Advanced (Weeks 7-12):

• Can solve medium problems (>80%)
• Can attempt hard problems
• Can explain and optimize clearly

Interview Ready:

• Medium problems in < 30 minutes
• Can explain while coding
• Handle edge cases naturally
• Mock interview scores: 3+/4

Key Takeaway

Smart problem selection is about progressive difficulty, pattern focus, and quality over quantity. Start with curated lists, focus on one pattern at a time, and gradually mix patterns as you build confidence. The right 50 problems learned deeply beats 300 problems done superficially.