12 — Complete Problem Index#

Every problem you need, in order, with the pattern and the one-line insight. Do not read the insight before attempting the problem — it's for the review pass and for when your 22-minute timer runs out.

Legend: E Easy · M Medium · H Hard · ⭐ = also in Blind 75 · 🔥 = very frequently asked

---

Phase 1 — NeetCode 150 (weeks 1–13)#

Arrays & Hashing (9)#

Two Pointers (5)#

Sliding Window (6)#

Stack (7)#

Binary Search (7)#

Linked List (11)#

Trees (15)#

Tries (3)#

Heap / Priority Queue (7)#

Backtracking (9)#

Graphs (13)#

Advanced Graphs (6)#

1-D Dynamic Programming (12)#

2-D Dynamic Programming (11)#

Greedy (8)#

Intervals (6)#

Math & Geometry (8)#

Bit Manipulation (7)#

---

Phase 2 — High-frequency extras (weeks 14–22)#

Not in NeetCode 150, but asked often enough that they're worth doing. Grouped by why they matter.

Very frequently asked (do all of these) 🔥#

Strings#

Trees & Tries, extended#

Graphs, extended#

DP, extended#

Design / OOP-flavored#

Concurrency (Amazon, some backend loops)#

See 16 — CS Fundamentals for the underlying concepts.

---

Phase 3 — completing NeetCode 250 (weeks 20–26)#

The 100 problems NeetCode 250 adds on top of the 150. Roughly 40 of them already appear in Phase 2 above; the 59 listed here are the remainder, so working this section takes you to full 250 coverage. They're easier on average than Phase 2 — a lot are Easy warm-ups that build fluency — so treat them as volume, 3–4 per session rather than 2.

One new pattern first: cyclic sort (index-as-hash)#

Not in NeetCode's category list, but it's the technique behind several problems below, and it's the answer whenever you see "values are in the range 1..n" with an O(1) space requirement.

The idea: if values are 1..n and the array has length n, then value v belongs at index v-1. Put each value where it belongs by swapping, then scan for the index whose value is wrong. That index is your answer.

def first_missing_positive(nums):
    n = len(nums)
    for i in range(n):
        # keep swapping nums[i] into its home until it's out of range or settled
        while 1 <= nums[i] <= n and nums[nums[i] - 1] != nums[i]:
            v = nums[i]
            nums[i], nums[v - 1] = nums[v - 1], nums[i]
    for i in range(n):
        if nums[i] != i + 1:
            return i + 1
    return n + 1
# O(n) time, O(1) space. The while loop is amortised O(1): each swap
# places one value permanently, so there are at most n swaps overall.

Being able to argue that the nested while is still O(n) total is the whole point of this problem. Same technique: Find All Numbers Disappeared in an Array, Find the Duplicate Number (array variant), Missing Number, Set Mismatch.

Arrays & Hashing (8)#

Two Pointers (4)#

Rotate Array's triple-reversal is worth memorising — it's the standard O(1)-space rotation and it shows up in string rotation problems too.

Sliding Window (2)#

Stack (3)#

Maximum Frequency Stack is the best "compose two structures" exercise in the set — pop the highest frequency group, which is naturally LIFO within itself.

Binary Search (4)#

Search in Rotated Sorted Array II is specifically valuable: it's the same problem as the 150 version but duplicates destroy the invariant, and being able to explain why the guarantee breaks is a stronger answer than the original problem provides.

Linked List (1)#

Trees (5)#

Write all three traversals iteratively at least once. The postorder-via-reversed-preorder trick is the kind of thing that reads as genuine understanding.

Heap / Priority Queue (2)#

Backtracking (4)#

Tries (1)#

The trie-plus-DP combination is the point here — it's the shape behind Word Break, Concatenated Words, and Palindrome Pairs.

Graphs (3)#

Advanced Graphs (4)#

Path with Minimum Effort generalises Swim in Rising Water — both replace "sum of edges" with "max edge along the path" inside Dijkstra. Learn the substitution once.

1-D Dynamic Programming (4)#

Combination Sum IV next to Coin Change II is the cleanest demonstration of why loop order decides combinations vs permutations. Do them back to back.

Greedy (5)#

Maximum Sum Circular Subarray's all-negative edge case (where total − min wrongly yields 0) is the trap the problem exists to test.

Intervals (1)#

Math & Geometry (5)#

Bit Manipulation (3)#

Bitwise AND of Numbers Range has a satisfying one-liner: shift both right until they're equal, then shift back. Any differing bit means some number in the range has a 0 there.

---

How to use this index#

Weeks 1–13: work Phase 1 strictly in order. The ordering encodes prerequisites.

Weeks 14–22: Phase 2, prioritizing 🔥 first, then whichever category your tracker shows as weakest.

Before a specific company (2–3 weeks out): buy LeetCode Premium, filter by that company + "last 6 months," and do 20–30 from that list. This is the only time premium is worth paying for.

Company tendencies (2026):

One 2026 change worth knowing: some companies now run an AI-assisted coding round, where you're given a model in the editor and evaluated on how well you direct and verify it. The skill being tested is judgment — decomposition, prompting, and catching wrong output — not memorized syntax. Your existing agent work is directly relevant preparation for that.

→ Next: 13 — Low-Level Design, in depth