Skip to content

Problem lists: which one to do

For anyone choosing what to solve on LeetCode. You leave with one list, an end date, and the week you switch to company-tagged problems.

Tip: Do one core list, not five. Jugal: "I solved 120 LeetCode problems and still got into Amazon, Google, and Meta" (post). Interviews test how fast you spot the pattern, not how many problems you have done.

The short answer

If you... Start with Then
Have never studied DSA Sean Prashad's Beginner Roadmap (68), or NeetCode 250 if you have 4+ months After the Beginner Roadmap: NeetCode 150
Know arrays, hash maps, trees, recursion Grind 75 or NeetCode 150. Pick one The other list's extra problems, then company tags
Are a first or second-year intern candidate LeetCode 75 Grind 75
Have 0 to 3 years of experience Grind 169 Company tags
Have under 4 weeks Grind 75 set to your real weeks and hours Company top 20
Are interviewing for data roles SQL 50 DataLemur, then the pandas plans
Target quant or HFT software roles NeetCode 250 or Grind 169 CSES sections
Prepare for Indian campus placements Striver's A2Z sheet Striver's SDE Pattern Sheet

Not sure which row you are in? Take the 1-hour test in Which list should you do?

Every major list compared

Counts as of Oct 2026 (checked Oct 4, 2026). "Days" assumes 2 or 3 new problems a day, 7 days a week. Re-solves add time (see how to practice).

Core interview lists

List Problems (Easy / Medium / Hard) Days at 2 / 3 a day Who it is for Cost
LeetCode 75 75 (22 / 53 / 0) 38 / 25 Interns, absolute first list, OA warm-up. Zero Hards. Free
Blind 75 75 (19 / 49 / 7). Unchanged since Dec 2018 38 / 25 A 4 to 5 week refresh if you already know DSA Free. 6 are LeetCode Premium, all free on NeetCode
Grind 75 75 (24 / 42 / 9, as labelled on the Grind site). Site estimate: 64 hours 38 / 25 Default first list for new grads who know the basics Free, 0 Premium
Grind 169 169 (41 / 102 / 26, as labelled on the Grind site). Site estimate: 150 hours 85 / 57 12-week plans. Engineers with 0 to 3 years doing a refresh Free, 12 Premium
NeetCode 150 150 (28 / 101 / 21) 75 / 50 Main list if you know the basics. Video for every problem Free
NeetCode 250 250 (60 / 155 / 35) 125 / 84 Beginners with 4+ months. Google targets Free
Top Interview 150 150 (39 / 93 / 18) 75 / 50 Swap for NeetCode 150 if you prefer LeetCode editorials Free
Top 100 Liked 100 (20 / 68 / 12) 50 / 34 Extra classics after a core list Free
Sean Prashad LeetCode Patterns 179 (41 / 112 / 26), plus a Beginner (68) and Experienced (75) roadmap 90 / 60 for all 179 Pattern-first learners. Shows which companies asked each problem Free, 13 Premium
Tech Interview Handbook best practice questions 50, in a fixed 5-week order 5 weeks A 5-week crunch when you want zero decisions Free

Full courses and regional sheets

List Size Time Who it is for Cost
Striver's A2Z DSA Sheet 495 items: 400+ problems and 50 theory lessons. Site: 131.4 hours About 6 months (site) Starting from zero, no DSA needed. Indian placements Free sheet, TUF+ paid
Striver's SDE Pattern Sheet 179 problems, 17 modules. Site: 64.1 hours 90 / 60 days Indian placements after the basics Free sheet, TUF+ paid
Striver's 150 150 problems. Site: 51.6 hours 75 / 50 days Alternative to NeetCode 150 if you like Striver's videos Free sheet, TUF+ paid
Striver's 75 75 problems. Site: 30.3 hours 38 / 25 days Last-month revision after a core list Free sheet, TUF+ paid
Love Babbar 450 448 links: 394 to GeeksforGeeks, 28 to LeetCode 224 / 150 days Legacy. Only for GfG-style Indian campus rounds. Tracker last updated July 2023 Free

Topic and specialty lists

List Size Time Who it is for Cost
LeetCode Dynamic Programming plan 50 in 10 DP patterns 25 / 17 days DP is your weak topic. Google targets Mostly free
LeetCode Binary Search plan 42 in 8 patterns 21 / 14 days Binary search on the answer ("On Solution Space" group) Some Premium
LeetCode Graph Theory plan 44 in 8 topics (BFS, union-find, topological sort, Dijkstra, MST) 22 / 15 days Graph-heavy loops at Google and Meta Some Premium
LeetCode SQL 50 50 (32 / 17 / 1) 10 to 13 days at 4 to 5 a day Data analyst, data engineer, data scientist Free
Introduction to Pandas then 30 Days of Pandas 15 then 33 1 to 2 weeks Data roles with a Python data round Mostly free (5 Premium)
CSES Problem Set 400 in 18 sections, stdin/stdout format Months Quant and HFT software roles, competitive programming Free

Do not try to finish these

Resource Size Use it only for Cost
NeetCode All 973 problems, unstructured by design Extra reps in one weak pattern 824 free, 149 Pro
Premium Algo 100 100 Only if you already pay for Premium and finished a core list Premium
Grokking the Coding Interview (Design Gurus) 300+ problems, 41 patterns A paid pattern course. The free lists cover the same patterns $197 lifetime (paid)
AlgoMonster Pattern course Skip the course. Use the free flowchart when stuck and read the free pattern stats page once Paid, price behind login

How to use each list

Grind 75 and Grind 169 (5-minute setup)

  1. Open Grind 75 in the author's order. The default view sorts by difficulty, which puts all 9 Hards in the last week. order=all_rounded rotates topics every week.
  2. Set "weeks" to the weeks until your first interview. Set "hours" to the hours per week you will really study.
  3. Check that "Time needed" says "Fits into your schedule".
  4. Bookmark the URL. Your settings live in the URL.
  5. Tick problems as you finish. Progress is saved only in that browser. Do not clear site data or switch browsers.
  6. Use each problem's minutes (15 to 45) as your timer. If you still need longer after 20 to 30 problems, spend a week on topics before continuing (the Grind FAQ gives the same advice).

Ready-made schedules (counts computed with the site's own scheduler):

2 weeks x 15 h/week (39 problems):  https://www.techinterviewhandbook.org/grind75?weeks=2&hours=15&order=all_rounded
4 weeks x 15 h/week (71 problems):  https://www.techinterviewhandbook.org/grind75?weeks=4&hours=15&order=all_rounded
8 weeks x 8 h/week (75 problems):   https://www.techinterviewhandbook.org/grind75?order=all_rounded
12 weeks x 8 h/week (111 problems): https://www.techinterviewhandbook.org/grind75?weeks=12&hours=8&order=all_rounded
8 weeks x 20 h/week (all 169):      https://www.techinterviewhandbook.org/grind75?weeks=8&hours=20&order=all_rounded
All 169, no schedule:               https://www.techinterviewhandbook.org/grind75?mode=all

NeetCode 150 and NeetCode 250

  1. Open the NeetCode roadmap. It draws NeetCode 150 as a tree of 18 topics, starting at Arrays & Hashing.
  2. Go in roadmap order. Do not start a topic until the one above it is done. Jugal: "It's sequenced so each topic sets up the next one" (post).
  3. Work 20 to 30 minutes alone before you open the video.
  4. After each solve, write the pattern in your tracking sheet.
  5. Solve Premium-only problems free on NeetCode. All 6 LeetCode Premium problems in Blind 75 (7 in NeetCode 150) have free copies, for example Meeting Rooms.
  6. On NeetCode 250, the extra 100 problems (32 Easy, 54 Medium, 14 Hard) add more reps per topic. If you already know the basics, use them only for your two weakest topics.
  7. Prefer tracking on LeetCode? Save the public NeetCode 150 list to your account (user-made, shows when logged in).

LeetCode study plans

  1. Log in before you open a plan. Logged-out views hide Premium items, so counts look short.
  2. LeetCode 75 is not the LeetCode version of Blind 75. Only 10 problems overlap, and 45 of its 75 are not in NeetCode 250 at all.
  3. Use Top Interview 150 instead of NeetCode 150, not on top of it. They share 77 problems.
  4. When one topic keeps failing, spend 2 to 3 weeks on its plan: Dynamic Programming, Binary Search or Graph Theory.
  5. Skip the "Amazon Spring '23" and "Google Spring '23" high-frequency plans. They are from 2023.

Sean Prashad LeetCode Patterns

  1. Beginners: open the Beginner Roadmap tab (68 problems in 11 phases, each with a one-line hint). Read the hint only after 30 minutes on your own.
  2. Experienced: use the Experienced roadmap (Sean's version of Blind 75). If stuck for 15 minutes, open the Helpful Tips tab. It maps cues to approaches: a sorted input array, for example, points to binary search or two pointers.
  3. Use the company column for free company signal. Each problem lists the companies that asked it and how often.
  4. Filter by pattern to drill a weak area. For the hints offline, open src/data/roadmaps.ts in the repo.

Striver sheets (takeUforward Prep Hub)

  1. Open the Prep Hub. Pick A2Z if you are starting from zero, the SDE Pattern Sheet if you know the basics, Striver's 75 for the last month.
  2. Striver uses his own problem names. Search for the LeetCode version: "Kadane's Algorithm" is Maximum Subarray. "Sort an array of 0's 1's and 2's" is Sort Colors.
  3. The free tier covers the free questions. TUF+ is paid and adds full practice and premium questions.
  4. Old links to the classic "SDE Sheet" now redirect to the 179-problem SDE Pattern Sheet.

Blind 75

  1. Practice it through NeetCode's Blind 75 page: one video per problem, Premium problems free.
  2. Read the original 2018 post only for history. Its author, Yangshun Tay, later built Grind 75 as the updated, prioritized version.
  3. Blind 75 has no stack, backtracking, or greedy section. NeetCode 150 fills that gap.
  4. Track on LeetCode with the public Blind 75 list.

The 36 problems every list agrees on

Each of these appears in at least six of seven major lists (Blind 75, Grind 75, NeetCode 150, LeetCode 75, Top Interview 150, Top 100 Liked, Sean Prashad). All 36 are free. If a phone screen is days away, do these first, 5 or 6 a day, timed with the limits on how to practice.

Which list should you do?

  1. Test your basics (1 hour). Solve Two Sum, Valid Parentheses, Reverse Linked List and Maximum Depth of Binary Tree. Give each 15 minutes, no help. Solved 3 or 4: you know the basics. Solved 2 or fewer: start as a beginner and read topics first.
  2. Count your weeks. Count weeks until your first online assessment or phone screen, not the onsite. Count honest hours per week. Benchmark from the Tech Interview Handbook study plan: about 3 months at 11 hours a week for thorough prep.
  3. Pick your row and column below. Write the list name and end date at the top of your tracking sheet.
  4. Adjust for your track with the rules after the table.
  5. Commit for 2 weeks before you judge the list. Switching lists in week one restarts your clock.
Your level 2 weeks 4 weeks 8 weeks 12 weeks 16+ weeks
Beginner LeetCode 75 for 2 weeks. Ask the recruiter for more time Sean Prashad Beginner Roadmap (68) Beginner Roadmap, then the 51 Grind 75 problems it does not cover Beginner Roadmap, then the 111 NeetCode 150 problems it does not cover NeetCode 250, or Striver A2Z for Indian placements
Knows the basics Grind, 2 weeks x 15 h (39) Grind, 4 weeks x 15 h (71), or Blind 75 at 3 a day NeetCode 150 at 3 a day, or Grind 75 default (8 x 8 h) Grind 75, then the 92 NeetCode 150 problems it does not cover NeetCode 250, then the 47 Grind 169 problems it does not cover
0 to 3 years experience Grind, 2 weeks x 15 h Grind, 4 weeks x 15 h Grind 169 at 8 weeks x 20 h Grind 169, then company tags Grind 169 plus NeetCode 250 extras, then company tags

Watch out: Every plan ends with company-tagged problems and mocks: the last 4 days of a 4-week plan, the last 2 to 3 weeks of a 12 to 16-week plan. Size your list so it finishes before that.

Track rules:

  • Intern (first or second year): LeetCode 75, then Grind 75. LeetCode 75 has zero Hards. See intern interviews for what each company asks interns.
  • New grad: use the "knows the basics" row. Jugal's view on NeetCode 150: "For new grad and most mid-level roles, getting through this list is enough on its own" (post). The data mostly agrees: it covers 30 to 36 of the top 50 recent tagged problems at Google, Meta, Amazon and Microsoft.
  • 0 to 3 years experience: use the experience row and start system design in parallel.
  • Google target: add the LeetCode DP plan and the Google Hard set below. NeetCode 250 covers 44 of Google's top 50 recent tags, the most of any list. Recent Google questions are on the Google page.
  • Meta target: after NeetCode 150, add these recent Meta tags it misses: Subarray Sum Equals K, Minimum Remove to Make Valid Parentheses, Next Permutation, Max Consecutive Ones III, Minimum Size Subarray Sum, Find Peak Element, Random Pick with Weight, Find First and Last Position of Element in Sorted Array, plus Valid Word Abbreviation and Binary Tree Vertical Order Traversal (both Premium). Details on the Meta page.
  • Data analyst, data engineer, data scientist: SQL 50 at 4 to 5 a day (2 weeks). Then DataLemur (freemium: $15 a month or $60 a year for premium) or takeUforward SQL 75. Then the two pandas plans if there is a Python round. Add LeetCode 75 if the job also has a DSA round.
  • Quant or HFT software: finish NeetCode 250 or Grind 169. Then CSES Sorting and Searching (35), Dynamic Programming (23), Graph Algorithms (36) and Tree Algorithms (16), reading the matching chapter of the free CSES book first. Then Jugal's 10 HFT problems (post).
  • Indian campus placements: Striver A2Z or the SDE Pattern Sheet. Use Love Babbar 450 only if your college's rounds are GfG-style.

Google Hard set

Google-tagged Hards from the last 6 months (liquidslr dataset, Aug 2026), highest frequency first, all free. In week 10 of the default plan, do 2 a day from the top of the core set (about 14), then finish it in weeks 11 and 12. Target 40 minutes each, hard stop at 60.

Default: knows the basics, 12 weeks, 2 to 2.5 hours a day

  1. Weeks 1 to 4: Grind 75 in All Rounded order (about 3 a day).
  2. Weeks 5 to 9: the 92 NeetCode 150 problems not in Grind 75. On the NeetCode page, skip anything you already ticked in Grind.
  3. Week 10: Hards. Google targets: the Google Hard set. Everyone else: the NeetCode 150 Hards you skipped (21 total).
  4. Weeks 11 to 12: top 30 to 40 company-tagged problems you have not done, plus 4 mock interviews.
  5. Total: about 200 to 220 problems, plus re-solves.

Beginner: 16 weeks, about 2 hours a day

  1. Weeks 1 to 4: Sean Prashad Beginner Roadmap (68 problems in 11 phases). Read the matching topics section before each phase.
  2. Weeks 5 to 10: NeetCode 150 in roadmap order. About 111 are new after the Beginner Roadmap, so about 2 to 3 a day.
  3. Weeks 11 to 13: the extra 100 of NeetCode 250 for your two weakest topics, or the 63 Grind 169 problems not in NeetCode 150.
  4. Weeks 14 to 15: company tags for your top target, 30 to 40 Medium and Hard.
  5. Week 16: 4 to 6 timed mocks. Re-solve every problem you failed.
  6. Total: about 230 to 280 problems.

8 weeks

  1. Weeks 1 to 7: NeetCode 150 at 3 a day. If you only have about 1.2 hours a day, use Grind 75's default 8 weeks x 8 hours instead.
  2. Week 8: company top 20 to 30, plus 2 to 3 mocks.

4-week crunch

  1. Days 1 to 24: Grind at 4 weeks x 15 hours (71 problems), or Blind 75 on NeetCode at 3 a day.
  2. Days 25 to 28: company "last 30 days" or "last 3 months" list, top 15 to 20 Medium and Hard. 2 mocks.

2-week emergency (phone screen already booked)

  1. Days 1 to 11: Grind at 2 weeks x 15 hours (39 problems, about 3 to 4 a day). Under a week left? Do the 36 problems above instead.
  2. Days 12 to 14: company "last 30 days" list, top 10 to 15. One mock.
  3. If you can, ask the recruiter for more time. Recruiters rarely mind which week you interview (interviewing.io on postponing). Use the script on how to practice.

Experienced refresh (0 to 3 years), 6 to 8 weeks

  1. Grind 169 compressed: 8 weeks x 20 hours returns all 169.
  2. Then company tags. Meta: include its Premium-only tags (Valid Word Abbreviation, Binary Tree Vertical Order Traversal, Nested List Weight Sum).

Add the difference, never stack lists

Never run two core lists in parallel. Finish one, then add only the problems it does not have.

You finished Then add New problems Running total
Blind 75 Grind 75 35 110
LeetCode 75 NeetCode 150 130 205
Sean Beginner Roadmap (68) NeetCode 150 111 179
Grind 75 NeetCode 150 92 167
Grind 75 Grind 169 94 169
Grind 75 NeetCode 250 186 261
NeetCode 150 Top 100 Liked 27 177
NeetCode 150 Grind 169 63 213
NeetCode 150 Top Interview 150 73 223
NeetCode 250 Grind 169 47 297

Blind 75 sits entirely inside NeetCode 150, which sits entirely inside NeetCode 250. Doing all three "separately" is doing NeetCode 250.

Jugal's 60-day pattern roadmap

A pattern-first alternative to a list. Source: I Cleared Amazon, Google, and Meta With Only 120 LeetCode Problems, with problems per pattern in his Company Wise DSA patterns page.

Days Patterns Rule for the block
1 to 10 Fast and slow pointers, two pointers, prefix sum, sliding window (fixed and variable), then cyclic sort 3 to 4 problems per pattern. Move on only when you can name the pattern from the problem statement alone
11 to 20 Linked list reversal, matrix manipulation, monotonic stack, bitwise XOR Learn each template. A 45-minute monotonic stack problem should drop under 10 minutes
21 to 35 BFS and DFS, trees (level order, construction, height, root-to-leaf, ancestors), graphs (topological sort, union-find, shortest paths, MST), backtracking The heaviest block. Give it the most time
36 to 45 DP in layers: take/not take, unbounded, LIS, grids, strings, stocks, partition Go in order. By day 45, name the DP family within 60 seconds
46 to 52 Modified binary search, top K with k-way merge, two heaps, overlapping intervals Do top K and k-way merge together (both use heaps)
53 to 58 Company sprint: the 4 patterns your target favors (list in the post) 2 to 3 timed problems per pattern
59 to 60 Mock interviews only 45 minutes, one problem, out loud. No new problems

Tip: In the graph block, learn Dijkstra first. The Tech Interview Handbook graph page rates Bellman-Ford, Floyd-Warshall, Prim and Kruskal as almost never asked.

Want it day by day? Jugal's earlier Master DSA with patterns runs 60 days at 60 to 90 minutes a day. Copy its last three days into any plan:

  • Day 58, mistake log: re-solve your 3 most painful misses from scratch and write which pattern you should have recognized.
  • Day 59, full mock: 2 Mediums and 1 Hard (one DP or graph, one tree or backtracking, one array, interval or greedy) in 75 to 90 minutes, then a short debrief.
  • Day 60, trigger phrases: for each pattern, write 1 to 2 phrases ("sliding window when...") and one problem to redo later.

Jugal's 5-week company plans

Each plan has 42 to 45 problems over 4 weeks with a time cap per problem, then a week of three 45-minute mocks.

Company Post Weeks 1 to 4 Fix before you start
Meta Part 1 Fundamentals (15 Easy, 15 min each); trees and basic graphs; advanced graphs and tries; two pointers, sliding window, DP basics Graph Valid Tree, Number of Connected Components and Alien Dictionary are Premium: solve them free on NeetCode
Amazon Part 2 Arrays and hash tables; trees and BST; heaps, sorting, basic DP; graphs and advanced DP Meeting Rooms II is Premium (free on NeetCode). Longest Substring with At Most K Distinct Characters is Premium: practice the free Fruit Into Baskets, the same window with k = 2
Google Part 3 Arrays, strings, bit manipulation; trees and BST; graphs; DP and bitmask DP The Find Mode link is broken. Use Find Mode in Binary Search Tree. Alien Dictionary and Graph Valid Tree are Premium (free on NeetCode)
Apple Part 4 Arrays and strings; trees and BST; DP; graphs and backtracking Graph Valid Tree is Premium (free on NeetCode). "Implement strStr()" was renamed: use Find the Index of the First Occurrence in a String
Netflix Part 5 Arrays and strings; graphs and trees; DP and sliding window; backtracking and advanced graphs Graph Valid Tree, Alien Dictionary and Number of Connected Components are Premium (free on NeetCode). Same strStr rename as Apple

All five posts link LeetCode company filters that now need Premium. Use the free route below instead.

Michael's 10-week pattern roadmap

A lighter plan: 5 to 6 problems a week, one or two patterns per week. It comes from Jugal's interview with Michael, CEO of Simplify (Michael's 10-week FAANG roadmap). Michael's Guide to FAANG DSA has the same roadmap plus 5 sample problems for each of 15 patterns. Use it beside classes, or as a pattern review after a core list.

Week Patterns
1 Sliding window, two pointers
2 Fast and slow pointers, merge intervals
3 Cyclic sort, in-place linked list reversal
4 BFS, DFS
5 Backtracking and recursion
6 1D dynamic programming
7 2D dynamic programming
8 Greedy, intervals
9 Binary search
10 Graphs: topological sort, union-find, trie

Fix before you start:

Company-tagged lists: last, not first

Start company tags 2 to 5 weeks before a scheduled interview, after a core list. Before you start, read your target's company page for its rounds and recent questions.

The core lists already cover most of what big companies' recent tags contain. The table shows how many of each company's top 50 most frequent problems from the last 6 months each list includes (liquidslr dataset, Aug 2026).

List Google Meta Amazon Microsoft Bloomberg Apple Uber
Blind 75 22 20 23 24 23 17 10
Grind 75 20 20 24 24 21 18 10
NeetCode 150 32 30 34 36 32 29 14
Top Interview 150 35 35 34 35 36 27 13
Grind 169 36 37 38 42 39 33 19
NeetCode 250 44 37 43 43 42 33 18
Any list combined 46 45 49 47 46 41 24

Read it this way: Blind 75 alone is a refresher, not a full plan. NeetCode 250 or Grind 169 already covers 72 to 88% of these recent tags at Google, Meta, Amazon, Microsoft and Bloomberg. Company tags matter most where the bank is unusual (Uber: only 24 of 50 appear in any list) and for Meta.

With LeetCode Premium

  1. Buy one month when your interview is 2 to 5 weeks away.
  2. Open your company's question list. Set the window to the last 6 months. Use the last 3 months for companies with the largest banks (Google, Amazon).
  3. Sort by frequency. Skip Easy problems and anything you solved already.
  4. Do the top 30 to 50 Medium and Hard. Stop there.
  5. Run 2 to 3 timed "Interview Simulations" for your company.
  6. Cancel before renewal.

Free, without Premium (about 15 minutes to set up)

  1. Clone the dataset (470 companies, last updated Aug 16, 2026):

    git clone --depth 1 https://github.com/liquidslr/leetcode-company-wise-problems.git

  2. Make done.txt with every problem you solved, one LeetCode URL or slug per line.

  3. Save the script below as company_top.py and run it on your company's "Six Months" file. It prints the top unsolved problems by frequency.
  4. Cross-check the top 20 against the second dataset, snehasishroy (July 2026 snapshot, rows sorted by ID, so the script sorts them for you). Prefer problems that appear in both.
  5. For a Premium-only problem, search NeetCode for a free copy, or read the statement in interview reports and solve it in your editor.
  6. Stop after 30 to 50 problems.
"""Print the top company-tagged LeetCode problems you have NOT solved yet.

Works with both open datasets:
  liquidslr:     <Company>/3. Six Months.csv   (columns: Difficulty, Title, Frequency, Link, ...)
  snehasishroy:  <company>/six-months.csv      (columns: ID, URL, Title, Difficulty, Frequency %, ...)

Usage:
  python3 company_top.py "leetcode-company-wise-problems/Google/3. Six Months.csv" done.txt 40 no-easy

done.txt: one LeetCode problem URL or slug per line (what you already solved).
no-easy (optional): hide Easy problems, which are the noisiest tags.
"""
import csv
import sys

path = sys.argv[1]
done_file = sys.argv[2] if len(sys.argv) > 2 else None
limit = int(sys.argv[3]) if len(sys.argv) > 3 else 40
skip_easy = len(sys.argv) > 4 and sys.argv[4] == "no-easy"


def slug(text):
    text = text.strip().rstrip("/")
    return text.split("/problems/")[-1].split("/")[0] if "/problems/" in text else text


def freq(row):
    value = row.get("Frequency") or row.get("Frequency %") or "0"
    return float(value.rstrip("%") or 0)


done = set()
if done_file:
    with open(done_file, encoding="utf-8") as f:
        done = {slug(line) for line in f if line.strip()}

with open(path, encoding="utf-8") as f:
    rows = list(csv.DictReader(f))

rows.sort(key=freq, reverse=True)
shown = 0
for row in rows:
    link = row.get("Link") or row.get("URL")
    if slug(link) in done:
        continue
    if skip_easy and row["Difficulty"].lower() == "easy":
        continue
    shown += 1
    print(f"{shown:>3}. {row['Difficulty']:<6} {freq(row):>5.1f}  {row['Title']}  {link}")
    if shown >= limit:
        break

Read company tags with care

  • Tags come from user surveys ("have you seen this question in a real interview?"), per LeetCode's own FAQ on the subscribe page. They show what people practiced and ticked, not exactly what a company asks.
  • Two Sum is the number one tag at Google, Meta, Amazon, Microsoft and Bloomberg. Half of Google's 6-month top 10 are LeetCode problems 1 to 10. Filter out Easy problems.
  • Small companies have tiny samples: 7 problems in 6 months for Netflix, Flipkart and PhonePe, 12 for Adobe, 14 for Oracle. Use interview reports on the company pages instead.
  • Ignore the "Acceptance Rate" column in the liquidslr files. It is broken (Two Sum shows 0.0058).
  • Check commit dates, not README dates. The liquidslr README still says June 2025, but its data was refreshed Aug 16, 2026. Older repos (hxu296, 2022; krishnadey30, 2023) are stale.
  • Free company signal without any dataset: Sean Prashad's site lists companies and frequency for each of its 179 problems.

Is LeetCode Premium worth it?

Prices as of Oct 2026 (US page, shown as discounts that can change): $35 a month or $159 a year. Check the subscribe page before you buy. Prices in other countries were not checked.

Situation Verdict
Interview scheduled at Google, Amazon, Meta, Microsoft or Bloomberg, core list done Worth one month ($35). These companies have hundreds of recent tags
Meta loop Worth it. 3 of Meta's top 50 recent tags are Premium-only
You will keep it 5+ months Yearly ($159) beats 5 months of monthly ($175)
Still working through a core list Not yet. Every core list is free, and NeetCode hosts free copies of the Premium problems in Blind 75 and NeetCode 150
Target is Netflix, Flipkart, Adobe or Oracle Not worth it. Their 6-month tag lists have 7 to 14 problems
Splitting one account with friends Do not. LeetCode's terms forbid letting anyone else use your account and allow termination without refund

Jugal used Premium this way before Amazon: "Company frequency sorting let me prioritize high-yield questions that appeared often" (The Definitive Guide for Meta & Amazon Engineering Interviews).

Other paid options:

  • NeetCode Pro: $119 a year or $297 lifetime (sale prices, Oct 2026). Courses, AI hints, company tags for 100+ companies. No student discount. Not needed for the free lists.
  • Grokking the Coding Interview: $197 lifetime. Optional. The free lists cover the same patterns.

Next: How to practice