Curated Problem Lists

Reading time: ~15 min | Interview relevance: Critical | Roles: All AI/ML roles

You have spent weeks studying algorithms, brushing up on ML theory, and reading system design case studies. But when you sit down to actually practice, the question hits: which problems should I solve, and in what order? With thousands of LeetCode questions, hundreds of ML exercises, and an ever-growing list of system design scenarios, unfocused practice is the fastest way to burn out without making real progress.

This section is your antidote to aimless grinding. We have assembled curated, opinionated problem lists that map directly to what top AI/ML companies actually ask. Every problem has been selected for a reason, tagged by difficulty, and organized so you can build skills systematically rather than randomly.

Why Curated Lists Matter

:::tip The 80/20 of Interview Prep Research on interview preparation consistently shows that candidates who follow structured problem sets outperform those who solve random problems by a wide margin. Focused, deliberate practice on the right problems beats volume every time. :::

The Problem with Random Practice

Approach	Outcome
Solve 500 random LeetCode problems	Covers many patterns but misses depth; burnout likely
Follow a curated 50-problem core set	Covers all key patterns; deep understanding; sustainable
Role-specific targeted list (40 problems)	Maps directly to interview rounds; high ROI
Company-style practice (25 problems)	Calibrates to the exact format you will face

What Makes These Lists Different

1. AI/ML-specific -- Not generic software engineering lists. Every problem is selected for its relevance to AI/ML roles
2. Role-mapped -- Different roles get asked different things. An MLOps engineer will not face the same questions as a Research Engineer
3. Company-calibrated -- Google, Meta, and startups interview differently. We provide lists tuned to each style
4. Difficulty-tiered -- Build from Easy to Hard systematically, with clear progression markers
5. Time-estimated -- Know exactly how long each problem should take so you can plan realistic study sessions

How This Section Is Organized

The Core Foundation

Chapter	What It Covers	Who It Is For
The Core 50	The 50 essential problems every AI/ML candidate must know	Everyone

Role-Specific Lists

Chapter	Target Role	Problem Count
MLE Problems	Machine Learning Engineer	40+
AI Engineer Problems	AI Engineer / LLM Engineer	40+
Data Scientist Problems	Data Scientist	40+
MLOps Problems	MLOps / ML Platform Engineer	40+
Research Engineer Problems	Research Engineer / Research Scientist	40+
Data Engineer Problems	Data Engineer / Analytics Engineer	40+

Difficulty-Tiered Lists

Chapter	Difficulty	Problem Count	Best For
Easy Tier	Easy	30+	Warm-up, building confidence, fundamentals
Medium Tier	Medium	40+	Core preparation, most interview rounds
Hard Tier	Hard	30+	Senior roles, top-tier companies

Company-Style Lists

Chapter	Company Style	Problem Count	Focus Area
Google-Style	Google / DeepMind	25+	Scalability, clean code, multiple approaches
Meta-Style	Meta / Instagram	25+	Product ML, recommendation systems, speed
Startup-Style	Startups / Scale-ups	25+	Practical, end-to-end, take-home projects

How to Use These Lists

Step 1: Identify Your Target

Before diving into problems, answer these questions:

1. What role am I targeting? (MLE, AI Engineer, Data Scientist, etc.)
2. What companies am I applying to? (Big Tech, startups, research labs)
3. What is my current level? (New grad, mid-level, senior)
4. How much time do I have? (2 weeks, 1 month, 3 months)

Step 2: Choose Your Lists

Based on your answers, follow one of these study paths:

Path A: The Focused Sprint (2-4 weeks)

Week 1-2: Core 50 (all 50 problems)
Week 3-4: Your role-specific list (40 problems)

Path B: The Comprehensive Prep (1-2 months)

Week 1-2:   Easy Tier (confidence building)
Week 3-4:   Core 50 (pattern mastery)
Week 5-6:   Role-specific list (targeted prep)
Week 7-8:   Company-style list (format calibration)

Path C: The Deep Dive (2-3 months)

Week 1-2:   Easy Tier (warm-up)
Week 3-5:   Core 50 + Medium Tier (breadth)
Week 6-8:   Role-specific list (depth)
Week 9-10:  Hard Tier (challenge)
Week 11-12: Company-style list + mock interviews

:::note Choosing the Right Path If you have less than 2 weeks, skip straight to the Core 50 and your role-specific list. The Core 50 alone covers 80% of what you need. If you have more time, the deeper paths build significantly more confidence and flexibility. :::

Step 3: Track Your Progress

For each problem, track:

Field	Why It Matters
Date attempted	Enables spaced repetition scheduling
Time taken	Identifies slow areas needing more practice
Solved independently?	Distinguishes real understanding from pattern matching
Key insight	Forces articulation of the core concept
Review date	Scheduled revisit for retention

The Spaced Repetition Approach

:::tip Why Spaced Repetition Works Solving a problem once teaches you the pattern. Solving it again 3 days later cements it. Solving it a third time 7 days later makes it permanent. This is not opinion -- it is backed by decades of cognitive science research on the spacing effect. :::

The Review Schedule

After solving a problem for the first time:

Review	When	What to Do
Review 1	Day 1 (next day)	Re-solve from scratch. Should be faster.
Review 2	Day 3	Re-solve. If stuck, review notes, then retry.
Review 3	Day 7	Re-solve. Should feel natural.
Review 4	Day 14	Quick mental walkthrough. Code only if unsure.
Review 5	Day 30	Final check. If solid, move to archive.

Categorizing Your Problems

After each attempt, categorize the problem:

Category	Meaning	Action
Green	Solved independently in target time	Standard review schedule
Yellow	Solved with hints or over time	Extra review at Day 2 and Day 5
Red	Could not solve or needed solution	Re-study pattern, re-attempt in 1 day

Building a Review Queue

Problem Categories Explained

Every problem in these lists is tagged with a category. Here is what each category means and why it matters:

Coding Categories

Category	Description	Example Topics
Arrays & Hashing	Fundamental data manipulation	Two Sum, sliding window, frequency maps
Linked Lists	Pointer manipulation	Reversal, cycle detection, merge
Trees & Graphs	Hierarchical and network structures	BFS, DFS, shortest path, topological sort
Dynamic Programming	Optimal substructure problems	Knapsack, LCS, edit distance
Sorting & Searching	Ordering and lookup	Binary search variants, merge sort
Strings	Text processing	Parsing, pattern matching, encoding
Stacks & Queues	LIFO/FIFO structures	Monotonic stack, BFS with queue
Heaps	Priority-based access	Top-K, median finding, scheduling
Greedy	Locally optimal choices	Interval scheduling, Huffman coding
Math & Bit Manipulation	Numerical computation	Modular arithmetic, bitwise operations

ML Categories

Category	Description	Example Topics
ML Implementation	Code an ML algorithm from scratch	Linear regression, k-means, decision tree
Feature Engineering	Transform raw data into useful features	Encoding, scaling, feature selection
Model Evaluation	Assess model performance correctly	Cross-validation, metrics selection, bias-variance
ML System Design	End-to-end ML system architecture	Recommendation systems, search ranking, fraud detection
Deep Learning	Neural network implementation and theory	Backpropagation, CNN, RNN, Transformer
NLP / LLM	Text and language model problems	Tokenization, embeddings, RAG, fine-tuning
Statistics	Probability and statistical inference	Hypothesis testing, Bayesian reasoning, distributions

System & Infrastructure Categories

Category	Description	Example Topics
SQL	Database querying and optimization	Joins, window functions, query plans
Data Processing	ETL and data pipeline problems	Pandas, Spark, streaming
System Design	Large-scale architecture	Distributed training, model serving, feature stores
MLOps	ML operations and infrastructure	CI/CD for ML, monitoring, deployment
Cloud & Infra	Cloud platform and tooling	Kubernetes, Docker, GPU management

Difficulty Calibration

Understanding what "Easy," "Medium," and "Hard" mean in context:

Coding Problems

Difficulty	LeetCode Equivalent	Target Time	What It Tests
Easy	LC Easy	10-15 min	Basic patterns, syntax, edge cases
Medium	LC Medium	20-30 min	Pattern combination, optimization
Hard	LC Hard	35-45 min	Complex algorithms, multiple techniques

ML Problems

Difficulty	What It Tests	Target Time
Easy	Single concept recall and basic implementation	15-20 min
Medium	Concept combination, tradeoff analysis	25-35 min
Hard	Novel problem framing, deep mathematical reasoning	40-60 min

System Design Problems

Difficulty	What It Tests	Target Time
Easy	Single-component design, standard patterns	20-25 min
Medium	Multi-component systems, scaling considerations	30-40 min
Hard	Novel architectures, complex tradeoffs, cost analysis	45-60 min

Company Tags Explained

Problems are tagged with companies that have asked similar questions:

Tag	Companies Included	Interview Style
FAANG	Google, Meta, Amazon, Apple, Netflix	Structured, multi-round, high bar
Big Tech	Microsoft, Uber, Airbnb, LinkedIn, Stripe	Structured with domain focus
AI Labs	OpenAI, Anthropic, DeepMind, Cohere	Research + engineering blend
Unicorns	Databricks, Scale AI, Anyscale, Hugging Face	Fast-paced, practical
Startups	Series A-C AI companies	End-to-end, take-home heavy

:::warning Company Tags Are Approximate No problem list can guarantee exactly what a company will ask. Tags indicate that similar problems have been reported in interviews at these companies. Use them as directional guidance, not guarantees. :::

Time Investment Guide

How Many Problems Do You Actually Need?

Candidate Profile	Recommended Problems	Estimated Hours
New grad, first AI role	Core 50 + Easy Tier + Role list = ~120	80-100 hours
Experienced SWE switching to ML	Core 50 + Role list = ~90	60-80 hours
Mid-level MLE, same role	Role list + Company style = ~65	40-50 hours
Senior, targeting top company	Core 50 + Hard Tier + Company style = ~105	70-90 hours
Career changer, no CS background	Easy Tier + Core 50 + Role list = ~120	100-120 hours

Daily Practice Schedule

:::tip Consistency Over Volume Solving 3 problems per day for 30 days beats solving 30 problems in a weekend. Your brain needs sleep to consolidate pattern recognition. Aim for 1-3 problems per day maximum. :::

Time Available	Recommended Daily Plan
30 min/day	1 review problem + study 1 new problem
60 min/day	2 review problems + solve 1 new problem
90 min/day	2 review problems + solve 1-2 new problems
2+ hours/day	3 review problems + solve 2 new problems + 1 system design

Cross-Referencing with Other Sections

These problem lists are designed to work together with the rest of this handbook:

If You Struggle With...	Go Review...
Coding patterns	Section 4: Coding Interviews
ML fundamentals	Section 5: ML Fundamentals
Deep learning theory	Section 6: Deep Learning
LLM questions	Section 7: LLM Interviews
System design	Section 8: ML System Design
Paper discussion	Section 9: Paper Discussion
Behavioral rounds	Section 10: Behavioral
Take-home projects	Section 11: Take-Home Projects

Tracking Template

Use this template (spreadsheet, Notion, or plain text) to track your progress:

Problem: [Name]
Category: [e.g., Arrays & Hashing]
Difficulty: [Easy/Medium/Hard]
Date First Attempted: [YYYY-MM-DD]
Time Taken: [minutes]
Result: [Green/Yellow/Red]
Key Insight: [1-2 sentences about the core technique]
Review Dates: [Day 1] [Day 3] [Day 7] [Day 14] [Day 30]
Notes: [Any additional observations]

Sample Filled Entry

Problem: Two Sum
Category: Arrays & Hashing
Difficulty: Easy
Date First Attempted: 2026-03-01
Time Taken: 8 min
Result: Green
Key Insight: Hash map for O(1) complement lookup instead of O(n) nested loop
Review Dates: 03/02 [done] 03/04 [done] 03/08 [done] 03/15 [skip] 03/31 [pending]
Notes: Remember to handle duplicate values in the same pass

Common Mistakes to Avoid

:::danger Top 5 Prep Mistakes

1. Grinding without reviewing -- Solving 200 problems means nothing if you cannot recall the patterns from problem #5
2. Skipping easy problems -- Easy problems build the vocabulary you need for medium and hard problems
3. Only doing coding -- AI/ML interviews are multi-dimensional. System design and ML theory carry equal weight
4. Not timing yourself -- Interview problems have strict time limits. Practice under time pressure
5. Ignoring company style -- A Google interview feels nothing like a startup interview. Calibrate accordingly :::

Recommended Problem-Solving Framework

For every problem, follow this structured approach:

For Coding Problems (UMPIRE)

Step	Action	Time
Understand	Restate the problem. Clarify inputs, outputs, constraints	2-3 min
Match	Identify which pattern(s) apply	1-2 min
Plan	Write pseudocode or outline your approach	3-5 min
Implement	Write clean, well-structured code	10-15 min
Review	Walk through your code with a test case	2-3 min
Evaluate	Analyze time/space complexity; discuss tradeoffs	2-3 min

For ML Problems

Step	Action	Time
Clarify	What is the task? What data is available? What metric?	3-5 min
Formulate	Frame as supervised/unsupervised/RL. Choose approach	5 min
Design	Architecture, features, training strategy	10 min
Evaluate	Metrics, baselines, failure modes	5 min
Iterate	What would you try next? How would you improve?	5 min

For System Design Problems

Step	Action	Time
Requirements	Functional and non-functional requirements	5 min
High-Level Design	Components, data flow, API design	10 min
Deep Dive	Critical component details, algorithms, data structures	15 min
Scale & Reliability	Scaling strategy, failure handling, monitoring	10 min
Tradeoffs	Alternative approaches, cost analysis	5 min

What Success Looks Like

After completing your chosen lists, you should be able to:

• Recognize a problem's pattern within 2-3 minutes of reading it
• Articulate multiple solution approaches and their tradeoffs
• Write clean, correct code for any medium-difficulty problem in under 25 minutes
• Design an end-to-end ML system with clear component boundaries in 35-40 minutes
• Discuss ML concepts with depth and nuance, connecting theory to practice
• Handle curveball questions by decomposing them into known patterns

:::note The Compound Effect Every problem you solve adds to your pattern library. After 50 problems, you start recognizing families of problems. After 100, you can decompose most novel problems into known sub-problems. After 150, interviews start feeling routine rather than intimidating. Trust the process. :::

Next Steps

Start with The Core 50 -- the 50 problems every AI/ML candidate should master before anything else. These form the foundation that all other lists build upon.

If you already feel strong on fundamentals, jump directly to your role-specific list:

• MLE Problems
• AI Engineer Problems
• Data Scientist Problems
• MLOps Problems
• Research Engineer Problems
• Data Engineer Problems