List: The 60-Problem LeetCode List for Senior Big-Tech Loops

Most “LeetCode for company X” lists are 250 problems scraped from an aggregator with no annotation, leaving you to guess which 30 carry the signal. This list inverts that. It’s ~60 core problems organized by a problem-recognition framework — eight recognizable kinds of problem, each with a question you can ask before you’ve picked an algorithm — plus a warm-up tier of durable old classics, and a ranked “what’s next” tier for the last 20% of value once the core runs clean under the clock.

Calibration assumption: you’re targeting a mid-to-senior loop (Meta E4/E5, Google L4/L5, Amazon SDE II/III, or equivalent). The pattern coverage extends to senior difficulty; new-grad loops ask easier slices of the same patterns. Pair it with the coding round guide for how to run the clock once you’re in the room.

Why tag lists are inefficient

Open any “LeetCode for company X” page and you get 20-plus tags — array, string, tree, dfs, bfs, two-pointer, recursion, backtracking, greedy, heap, and on. Tags describe a solution after you already have it. They don’t help the one moment that decides the round: the blank-page minute where you don’t yet know what kind of problem you’re looking at. A candidate who “knows the tags” can still freeze, because the tag isn’t visible until the approach is.

Recognition matters more than memorization

The senior candidates who pass aren’t the ones who’ve memorized 300 solutions. They’re the ones who, on an unfamiliar problem, quickly recognize what kind of problem it is — and the approach follows from the recognition. This mirrors the system design tradeoff framework: identify the tradeoff before choosing the solution. Here: recognize the problem before choosing the algorithm.

That reframes what this list is for. The ~60 problems below aren’t a checklist to complete — they’re training data for a recognition procedure. Internalize one problem per category and you can route a problem you’ve never seen.

Start here

The Problem Recognition Framework

Recognition before implementation. Before choosing an algorithm, recognize what kind of problem you’re solving. Almost every mainstream big-tech problem answers one of the recognition questions below — each asked before you’ve picked a data structure. The skill is running the questions, in order, until one fires; the category then tells you the technique.

The recognition order

The order matters. Run the eight recognition questions in sequence and take the first category that fits. Ask the specific, high-precision questions first and let the broad ones fall through — otherwise a broad category grabs a problem a sharper one should own:

flowchart LR
  Root([Recognize the problem]) --> D1[1 · Object Design]:::design
  Root --> D2[2 · Enumeration]:::enum
  Root --> D3[3 · Traversal]:::traversal
  Root --> D4[4 · Ordering]:::ordering
  Root --> D5[5 · Transformation]:::transform
  Root --> D6[6 · State Maintenance]:::state
  Root --> D7[7 · Decision / Optimization]:::decision
  Root --> D8[8 · Search]:::search

  classDef design    fill:#f3ecfb,stroke:#8250df,stroke-width:2px,color:#1f2937;
  classDef enum      fill:#eafaf0,stroke:#1a7f37,stroke-width:2px,color:#1f2937;
  classDef traversal fill:#e8f1fd,stroke:#0969da,stroke-width:2px,color:#1f2937;
  classDef ordering  fill:#e6f6f4,stroke:#0e7490,stroke-width:2px,color:#1f2937;
  classDef transform fill:#fdeef6,stroke:#bf3989,stroke-width:2px,color:#1f2937;
  classDef state     fill:#fdf0e6,stroke:#9a6700,stroke-width:2px,color:#1f2937;
  classDef decision  fill:#fdeaea,stroke:#cf4b2e,stroke-width:2px,color:#1f2937;
  classDef search    fill:#eef2f1,stroke:#2c5f5d,stroke-width:2px,color:#1f2937;

Each leaf is a category; the number is its place in the ask-order — run question 1 first and stop at the first category that fits. The recognition question and techniques for each are in the eight categories below. State Maintenance (6) is the broad residual — only land there after ruling out the more specific 1–5.

The eight categories

Each category below uses the same shape — the recognition question to ask yourself, the typical techniques it unlocks, and the representative problems (linked in the list) that teach it.

Object Design

• Ask yourself: Am I implementing an API/object with state and constraints — “build a class with these operations at these complexities”?
• Typical techniques: hash map + doubly linked list, dual heaps, auxiliary structures kept in sync.
• Representative problems: LRU Cache · Insert Delete GetRandom · Find Median from Data Stream · Min Stack · Design Twitter · Implement Trie.

Enumeration

• Ask yourself: Must I generate all valid possibilities (or count them) — every subset / permutation / combination / valid string?
• Typical techniques: backtracking with pruning, recursion trees.
• Representative problems: Subsets · Permutations · Letter Combinations · Word Search II.

Traversal

• Ask yourself: Is there an explicit or implicit graph, tree, or grid to explore? Cloning and serializing a structure live here too — the work is the traversal, not the encoding.
• Typical techniques: DFS, BFS, multi-source BFS, topological sort, union-find.
• Representative problems: Number of Islands · LCA · Binary Tree Max Path Sum · Level Order · Course Schedule · Rotting Oranges · Clone Graph · Connected Components.

Ordering

• Ask yourself: Does correctness depend on a global order — must I process elements smallest-first, by priority, or sweep intervals by endpoint?
• Typical techniques: sort, heap, k-way merge, interval sweep, sweep line.
• Representative problems: Merge Intervals · K Closest Points · Kth Largest · Merge k Sorted Lists · Meeting Rooms II.

Transformation

• Ask yourself: Is the core task reshaping or encoding an existing structure — rewiring linked-list pointers, rewriting an array in place, parsing/encoding a string? (A Trie is a technique you might use here, not a category.)
• Typical techniques: pointer/index manipulation, in-place rewrite, encode/decode.
• Representative problems: Add Strings · the linked-list classics (Reverse, Merge Two, Cycle) in the warm-up tier.

State Maintenance

• Ask yourself: Can one linear scan with a small evolving state do it — after ruling out everything above? This is the broad residual, deliberately near the end of the tree.
• Typical techniques: hash map, prefix sum, sliding window, two pointers, monotonic stack.
• Representative problems: Longest Substring Without Repeat · Group Anagrams · Product Except Self · Best Time to Buy/Sell · Daily Temperatures · Minimum Window Substring · Subarray Sum Equals K.

Decision / Optimization

• Ask yourself: Am I making a sequence of choices where each choice affects future possibilities, optimizing a min/max/count over the whole? (Both DP and greedy fall in here.)
• Typical techniques: dynamic programming; greedy when a local rule is provably optimal.
• Representative problems: Climbing Stairs · Coin Change · Word Break · Unique Paths · House Robber.

Search

• Ask yourself: Can I search an ordered answer space instead of constructing the answer — a sorted array, or a monotonic answer-space I can binary search? (This is broader than “binary search a sorted array”: rotated-array search and search-on-answer both live here because both binary-search an ordered space.)
• Typical techniques: binary search, binary-search-on-answer.
• Representative problems: Search in Rotated Sorted Array · Random Pick with Weight · Pow(x, n).

The list

Every problem below is placed by the Recognition Framework — it’s an example of a category, not a standalone entry. Don’t memorize the list. For each problem, practice recognizing which category it is first (run the tree), then solve the representative problems inside that category until the recognition is automatic. That transfer — category first, solution second — is the whole point; the problems are just the training data.

The groups follow the recognition order. That’s the order you ask the questions in — not necessarily the order you practice in (see How to use this list for a bedrock-first sequence). A short warm-up tier of old classics closes the list.

1. Object Design

You’re handed an API spec and asked to implement the class. The work is picking the backing structures and keeping their invariants in sync. Meta and Amazon lean on these; Google uses them as follow-up scaffolding. For senior backend candidates they increasingly test production instincts: API design, object modeling, extensibility, and tradeoff reasoning.

• 146. LRU Cache — the canonical “design + code in 30 minutes,” asked everywhere. Doubly-linked list + HashMap. Write it clean on a whiteboard and the pattern is internalized.
• 380. Insert Delete GetRandom O(1) — HashMap + dynamic-array swap. The duplicates variant 381 is a fair senior follow-up.
• 295. Find Median from Data Stream — two heaps. The pattern matters more than the problem: any “online aggregate over a stream” reduces to two heaps or a sorted structure.
• 155. Min Stack — the five-minute design warmup; the auxiliary-structure idea reappears in harder designs.
• 355. Design Twitter — combines object modeling, heap merge, and API design in one problem. Senior backend favorite: tests whether you think about the design holistically or just hack the test cases. Practice the clean OO version.
• 208. Implement Trie (Prefix Tree) — implement a class to a spec (insert, search, startsWith). A Trie is the technique; the recognition here is “build this data structure to an API.” If you can’t write it from scratch in 10 minutes, practice until you can.

2. Enumeration

The answer is every valid configuration (or the count). The recognition cue is “generate all …” → backtracking with pruning. Cover the template once; the senior-bar variants are permutation-with-duplicates, not exotic puzzles.

• 78. Subsets — the canonical template. Solve with both include/exclude recursion and the 5-line bit-manipulation version — the latter is the kind of thing interviewers remember.
• 46. Permutations — the swap-in-place version is cleanest; the duplicates variant 47 is a common follow-up.
• 17. Letter Combinations of a Phone Number — the friendliest backtracking question and a frequent warm-up; the template transfers to every “enumerate combinations” follow-up.
• 212. Word Search II — backtracking on a grid, pruned by a Trie. Senior-loop tier. The recognition is “enumerate paths”; the Trie is the technique that makes it tractable.

3. Traversal (the second round)

There’s a graph, tree, or grid to explore. The second coding round usually pulls from here. The bar shifts: instead of “clean in 12 minutes,” it’s “correct in 25, with a sensible discussion of trade-offs.” Cloning and serializing a structure live here too — the work is the traversal, not the encoding.

• 200. Number of Islands — the canonical grid traversal, asked everywhere relentlessly. Solve with both DFS and BFS templates and you’ve covered most grid questions.
• 236. Lowest Common Ancestor of a Binary Tree — classic recursive divide. Variants (LCA with parent pointers) are common follow-ups.
• 124. Binary Tree Maximum Path Sum — postorder traversal with global max tracking. The “return one value up, bookkeep another globally” pattern is the senior-level version of tree recursion. High-frequency at Google and Meta.
• 543. Diameter of Binary Tree — simpler version of the same “return + bookkeep” pattern. If 124 feels hard, start here.
• 199. Binary Tree Right Side View — level-order BFS or preorder DFS. Practice both — interviewers often ask for the alternative after your first solution.
• 102. Binary Tree Level Order Traversal — the BFS template for trees. Many tree problems reduce to “level-order with bookkeeping” — this is the base template. It’s also the backbone of tree serialization (BFS/DFS out, same order back in) — a common follow-up.
• 314. Binary Tree Vertical Order Traversal — the Meta tree question; appears elsewhere too. BFS with column tracking. Famous enough that interviewers can tell memorized from reasoned — be able to produce it cleanly on first try.
• 207. Course Schedule — cycle detection / topological sort, a Google and Amazon staple. Know Kahn’s algorithm (BFS in-degrees); the follow-up 210. Course Schedule II asks for the ordering itself.
• 994. Rotting Oranges — multi-source BFS, an Amazon favorite. The “start BFS from all sources at once” insight transfers to many shortest-time-on-grid problems.
• 133. Clone Graph — graph traversal with a HashMap to map original→copy. The recognition is traversal (DFS/BFS the graph); the cloning is bookkeeping along the way. The trap: getting the recursion-vs-iteration trade-off wrong out loud.
• 323. Number of Connected Components in an Undirected Graph — solvable with BFS/DFS or union-find. Practice the union-find version — it’s 15 minutes to learn and the pattern appears at Google, Meta, and Databricks with surprising frequency.

4. Ordering

Correctness depends on seeing elements in a particular order — sort first, pull from a heap, or sweep intervals by endpoint. If “process the smallest / next one” is the move, it’s Ordering. Strong candidates distinguish themselves here with the right data-structure choice.

• 56. Merge Intervals — the canonical interval problem, high-frequency at every company. Sort + linear merge. Templates for 57. Insert Interval and 435. Non-overlapping Intervals fall out of this one.
• 973. K Closest Points to Origin — the canonical top-k. Solve with both a size-k heap and quickselect, and explain when you’d choose each — the streaming-data follow-up is really asking why you chose the heap.
• 215. Kth Largest Element in an Array — same pattern, simpler framing. Quickselect is the canonical answer; explaining the average-O(n)/worst-O(n²) tradeoff is the signal. The follow-up is always “how do you avoid O(n²)?” — randomized pivot selection. Name it proactively.
• 23. Merge k Sorted Lists — heap-of-heads, an Amazon and Google staple. The k-way-merge template also underlies external sort discussions in follow-ups.
• 253. Meeting Rooms II — min-heap on end times. The trick is recognizing “what’s the smallest end time that’s free” → heap. Common variant: count concurrent meetings.

5. Transformation

The primary challenge is reshaping or encoding an existing structure: rewiring linked-list pointers, rewriting an array in place, parsing or encoding a string. The canonical warm-ups are the linked-list classics in the last section; in the core set the exemplar is string carry-arithmetic.

• 415. Add Strings — manual carry arithmetic (no BigInteger). Often a warmup; a frequent follow-up is 43. Multiply Strings. The recognition: you’re transforming/encoding, not searching or optimizing.

6. State Maintenance (the bedrock — practice these until they’re free)

The broad residual: one linear pass while maintaining a small evolving state — a running count, a window, a monotonic stack. Reach for it only when nothing above fired. The first coding question of most loops comes from here. Solving in 12–15 minutes with clean code is the bar; 25 minutes likely fails the round even if the solution works.

• 3. Longest Substring Without Repeating Characters — the canonical sliding window, asked everywhere. If you can’t write the two-pointer template for this in 8 minutes, the rest of the list won’t help. Do this first. Also the entry point for the sliding window dependency chain below.
• 49. Group Anagrams — hash map with a derived key (sorted string or character count). Tests whether you can design the right key for a hash-based grouping — the pattern transfers to many “group by property” problems.
• 238. Product of Array Except Self — prefix/suffix product without division. The “maintain state in both directions” pattern appears in many variations; this is the cleanest.
• 121. Best Time to Buy and Sell Stock — one-pass min tracking. The whole point: candidates over-engineer. The good solution is 10 lines.
• 125. Valid Palindrome — two-pointer string warm-up, often paired with 680. Valid Palindrome II as a follow-up (a Meta favorite) — prep both.
• 42. Trapping Rain Water — an Amazon and Google staple at the senior bar. Two-pointer with running maxes; also solvable with a monotonic stack. Knowing both and naming the tradeoff is the senior signal.
• 1249. Minimum Remove to Make Valid Parentheses — high-frequency, especially at Meta. Two-pass scan or stack. Often paired with 301. Remove Invalid Parentheses as a senior-level follow-up.
• 739. Daily Temperatures — the canonical monotonic stack problem. “For each day, how many days until a warmer day?” Maintain a stack ordered so you answer “next greater” in O(n). High-frequency at Amazon.
• 84. Largest Rectangle in Histogram — the harder monotonic-stack canonical. Understanding why the stack works here unlocks the Trapping Rain Water stack solution too.
• 76. Minimum Window Substring — the harder canonical sliding window. Template for any “smallest window containing all of X” problem.
• 560. Subarray Sum Equals K — prefix sum + HashMap. The classic “this isn’t actually sliding window” trap: reach for the window first and negative numbers break you. Learn to recognize it.
• 438. Find All Anagrams in a String — fixed-size window with frequency count. High-frequency at Meta. The “maintain a valid window” pattern with character counting.

7. Decision / Optimization (a smaller slice than the internet suggests)

Every step is a choice whose value depends on earlier choices, and you’re optimizing a min/max/count over the whole sequence: dynamic programming, or greedy when a local rule is provably optimal. Every company asks some DP; none of the mainstream loops ask the hardest tier. Cover the patterns broadly rather than grinding 30 specific problems — one problem per pattern below covers most of what appears.

• 70. Climbing Stairs — the warmup; 1D DP with two-state memory. Trivial, but the framing for more complex 1D DP.
• 322. Coin Change — classic unbounded knapsack. Internalize the bottom-up table; iterative is what you write under the clock.
• 139. Word Break — string DP with hashset lookup. The variant 140. Word Break II (DP + backtracking) is worth practicing only at the senior bar.
• 62. Unique Paths — the 2D grid-counting template; obstacle variant 63 falls out.
• 198. House Robber — the cleanest take/skip decision DP; the circular variant 213 is a fair follow-up.

8. Search

The answer lives in a sorted space, or a monotonic answer-space you can binary search, rather than one you must construct. Asked last because “search the answer” competes with a DP framing — rule the others out first. Don’t skip it: it’s the easiest pattern to fail on a typo and the cleanest template to memorize.

• 33. Search in Rotated Sorted Array — the canonical “binary search with a twist,” asked everywhere. Write it with zero off-by-ones in 15 minutes and the pattern is covered. Variant 81 with duplicates is a common follow-up.
• 528. Random Pick with Weight — cumulative array + binary search; high-frequency at Meta. The setup phase is half the problem.
• 50. Pow(x, n) — recursive binary exponentiation. Bug-prone; practice the negative-n edge case.

Old classics (warm-up tier — still seen)

Appendix, not a category: CtCI-era warm-ups that still open phone screens. The linked-list ones double as the canonical Transformation exercises (pointer rewiring). Don’t grind them — just make sure none can surprise you.

• 206. Reverse Linked List — the most-asked warm-up in history. Iterative and recursive, both in under five minutes. The base technique behind half the linked-list follow-ups.
• 21. Merge Two Sorted Lists — the two-pointer merge that 23. Merge k Sorted Lists (in Ordering) generalizes. Know this one cold first.
• 141. Linked List Cycle — Floyd’s fast/slow pointers. The follow-up 142 (find the cycle start) is the version that actually gets asked at the senior bar.
• 20. Valid Parentheses — the canonical stack warm-up; prerequisite for 1249. Minimum Remove in State Maintenance.
• 1. Two Sum — the hash-map one-liner everyone’s seen. Still a genuine phone-screen opener; the point is to solve it in 90 seconds and move on, not to be caught off guard.
• 88. Merge Sorted Array — in-place merge from the back. A deceptively common Meta/Amazon warm-up where the “fill from the end” trick is the whole signal.

What’s next: the last 20% (more effort, less gain, still real)

Nothing here is worthless — it’s the diminishing-returns tier. Each group below does appear in loops, just rarely enough that it’s a poor trade against the core list. Work these only once the core runs clean under the clock, and prioritize top-down: the earlier groups earn their marginal hour more than the later ones.

• Hard DP. 72. Edit Distance, 312. Burst Balloons, 44. Wildcard Matching, the 188. Stock IV variants. Try these if: you’re solid on Coin Change, Word Break, and House Robber and have hours to spare, or you’re targeting a Google loop that likes to mutate a DP into a harder one. Edit Distance is the single highest-value pickup here — it’s the only one that still surfaces with any regularity.
• Advanced graph algorithms. 743. Dijkstra (Network Delay Time), Bellman-Ford, Kruskal/Prim MST. Try these if: you’re targeting an infrastructure, maps, or logistics team, or a Google loop specifically — they earn their place there and almost nowhere else. Start with Dijkstra via Network Delay Time; it’s the one that actually appears.
• Advanced union-find. You’ve got the canonical 323 on the core list. Try next: 721. Accounts Merge and 305. Number of Islands II — the applied variants that actually show up (Meta likes Accounts Merge). Skip the weighted/path-compressed-with-rank competitive-programming tier.
• Bit manipulation. 136. Single Number is a fine warmup. Try next if Google-bound: 201. Bitwise AND of Numbers Range and 190. Reverse Bits — occasional at Google, near-absent elsewhere. One pass for recognition.
• Math / implementation. 12. Integer to Roman, 13. Roman to Integer, 171. Excel Column Number. These test careful implementation over pattern transfer. Low priority, but a fast confidence pass the week before if you have an idle evening.
• Hard backtracking. 51. N-Queens, 37. Sudoku Solver, 425. Word Squares. Try these if: Subsets and Permutations are automatic and you want to stress- test your pruning. N-Queens is the one interviewers occasionally reach for.
• Segment / Fenwick trees. 307. Range Sum Query - Mutable, 315. Count of Smaller Numbers After Self. Mostly competitive-programming territory. Try these only if: you’re targeting a quant/HFT or specialist infra loop that’s known to ask them — otherwise the marginal hour is far better spent on system design.
• The full Blind 75 / NeetCode 250, for completeness. Fine pattern catalogs that overlap this list heavily at the core — if you’ve done one, you’ve built the foundation. Finishing all 250 as a goal optimizes problem count over pattern fluency. If you have genuine surplus time, cherry-pick the handful they cover that this list doesn’t; don’t grind the whole set.
• Mock-interview platforms beyond a few sessions. Two or three are worth it for calibration. After that, marginal value drops sharply; real timed reps beat watched ones.

The pattern behind this tier: mainstream big-tech loops test breadth and speed, not depth in any one technique. These problems are real but rare — so the ordering above is deliberate. Spend down from the top only after the core list is fluent, and stop when the marginal hour would buy more on system design than on one more exotic technique.

Per-company emphasis

• Meta — two problems per 35-minute round; speed is the whole game. Over-index on arrays/strings and trees; expect the tagged Meta favorites above (Valid Palindrome II, Vertical Order Traversal, Minimum Remove, Find All Anagrams).
• Google — one problem that mutates: after your solve, constraints change (“what if it doesn’t fit in memory?”, “what if updates arrive concurrently?”). Practice extending your own solutions; toposort and search-on-answer binary search appear more here than anywhere.
• Amazon — one problem plus leadership-principle questions in the same hour, graded on maintainability as much as correctness — see the logical & maintainable guide. BFS-on-grid, k-way-merge, and monotonic stack are house staples.
• Apple / Netflix — team-driven and practical; the Object Design category above is the highest-yield group, and language fluency counts double.

Priority 10 by company

If you only have time for 10 problems per target company, these are the highest-ROI picks from the list above:

What senior candidates do differently

The same problem, solved by a mid-level and a senior candidate, looks different in the interviewer’s notes:

The pattern: at senior, every standard move comes with one extra sentence of meta-reasoning. See the coding round guide’s senior differentiation section for how to practice this.

Dependency chains within each category

The framework tells you which category a problem is; these chains tell you the order to practice within one. Once you’ve recognized a category, walk its representative problems in dependency order — each teaches a technique the next one assumes. Recognition → representative problems → this chain.

State Maintenance (sliding window sub-chain): 3 Longest Substring → 567 Permutation in String → 76 Minimum Window Substring → 438 Find All Anagrams

Ordering (interval sub-chain): 56 Merge Intervals → 57 Insert Interval → 253 Meeting Rooms II → 435 Non-overlapping Intervals

Traversal (tree recursion sub-chain): 543 Diameter (return + bookkeep) → 124 Maximum Path Sum (same pattern, harder) → 236 LCA (recursive divide)

Traversal (graph sub-chain): 200 Number of Islands (grid DFS/BFS) → 994 Rotting Oranges (multi-source BFS) → 207 Course Schedule (toposort) → 323 Connected Components (union-find)

Decision / Optimization (DP sub-chain): 70 Climbing Stairs (1D base) → 198 House Robber (take/skip) → 322 Coin Change (unbounded knapsack) → 139 Word Break (string DP)

Object Design (chain): 155 Min Stack (auxiliary structure) → 146 LRU Cache (DLL + HashMap) → 380 Insert Delete GetRandom (array + HashMap swap) → 355 Design Twitter (object modeling + heap merge)

Search (chain): basic sorted array → 33 Search in Rotated → 528 Random Pick with Weight (prefix sum + search)

If a problem feels impossible, check whether you skipped its prerequisite in the chain. Going back one step is almost always faster than grinding forward.

How to use this list

Practice bedrock-first (the reverse of the recognition order — you learn the common categories before the rare ones):

1. Week 1, day 1: blitz the old classics as a warm-up — six problems, one sitting, timed. They’re the floor; confirm none surprise you before building up.
2. Weeks 1–2: State Maintenance + Traversal, in order. ~30 problems solved cleanly. The bar is “clean code in target time,” not “completed at all.”
3. Week 3: Ordering + Search (heaps, intervals, binary search).
4. Week 4: Decision/Optimization + Object Design + Enumeration.
5. Week 5: re-solve everything you couldn’t finish in time during weeks 1–4. Reps, not new problems. If the core is genuinely fluent, spend down the what’s next tier from the top — Edit Distance, Accounts Merge, Dijkstra — not the whole thing.
6. Week 6: two timed mocks in your target company’s round shape. Adjust based on what fell apart under pressure.

If you have 2 weeks (20–25 hrs):

Skip Decision/Optimization (DP) beyond House Robber. Skip Enumeration beyond Subsets. Focus on State Maintenance, Traversal, Ordering, and Object Design. ~25–30 problems. The goal isn’t completeness — it’s pattern recognition on the highest-frequency categories.

If you have 3 days:

Four groups: the old classics (six warm-ups, half a morning), State Maintenance (the bedrock set), Traversal (five tree/graph problems), and two Object Design problems (LRU Cache, Insert/Delete/GetRandom). You’re not going to prepare a loop in 3 days; you’re going to refresh speed on the categories most likely to appear. Do not touch the “what’s next” tier — it’s pure diminishing returns on this timeline.

For all timeframes: time yourself. The difference between solving a problem in 18 minutes and solving the same problem in 38 is the difference between a hire and a no-hire, at every company on this list. Untimed practice teaches the wrong skill.

Related

• Guide: The Senior Coding Interview at Big Tech — how to run the clock: round shapes by company, the 6-step structure, the follow-up ladder, and the moves that read senior.
• Guide: Amazon’s Logical & Maintainable Coding Interview — the company specialization where clean, extensible code is the explicit rubric.
• Plan: Senior Backend Software Engineer Interview Prep — the broader 12-week plan; its coding track and this list cover the same patterns from two directions.