Code With Wilson

Wilson Wu

I'm using AI to learn AI, and I'm publishing the journey as I go. Each episode is a NotebookLM-generated audio overview of a study brief I wrote — Chip Huyen chapters, LeetCode problem walkthroughs, AI Engineering interview topics. Built for myself, useful for anyone studying AI engineering for Google Cloud, Anthropic, OpenAI, or similar roles. Made transparently with NotebookLM (audio) and Claude (briefs). — Wilson Wu

  1. 1D AGO

    LeetCode #15 — 3Sum, Walked Through the Six-Phase Framework

    You're given an array and asked to find all unique triplets `(a, b, c)` where `a + b + c = 0`. Naive: three nested loops, O(n³). NeetCode's optimal: **sort the array, then for each `a`, run two pointers on the rest looking for `b + c = -a`**. O(n²) total. The clever parts are (1) sorting first to enable two pointers and (2) carefully skipping duplicates at three levels to avoid duplicate triplets in the output. 3Sum is **sort + two-pointer**, with three de-duplication skips. NeetCode's canonical approach is the keystone of the Two Pointers category. **The pattern composes: sorting enables two-pointer, fixing one element reduces 3Sum to 2Sum, and de-duplication relies on duplicates being adjacent post-sort.** **The pattern transfer: any K-sum problem reduces to "fix K-2 elements, two-pointer the remaining two."** This is one of the most leverage-able compositions in LeetCode. ---

    21 min

  2. 1D AGO

    LeetCode #3 — Longest Substring Without Repeating Characters, Walked Through the Six-Phase Framework

    Whenever a problem asks for the longest (or shortest) **subarray or substring** with some property, the answer is **sliding window**. Two pointers — `left` and `right` — define a window over the input. The right pointer expands the window; when the property breaks, the left pointer shrinks until the property holds again. NeetCode's canonical approach uses a **hashset** to track unique characters and shrinks the window from the left until the duplicate is gone. Longest Substring Without Repeating Characters is the **canonical sliding window**. Two pointers, a hashset, one pass. The window grows from the right and shrinks from the left when the uniqueness property breaks. **O(n) time by amortization** — each character is touched at most twice. NeetCode's `while`-loop shrink is the part that makes the algorithm correct on multi-char duplicates. **The pattern transfer: any time the problem says "longest" or "shortest" plus "substring" or "subarray" with some property, reach for sliding window. The data structure tracking 'what's in the window' depends on the property.** ---

    18 min

  3. 1D AGO

    LeetCode #121 — Best Time to Buy and Sell Stock, Walked Through the Six-Phase Framework

    You're given a list of stock prices and you need to find the maximum profit from buying once and selling once on a later day. The brute force is O(n²) — try every (buy, sell) pair. The optimization: as you walk the array, **maintain the minimum price seen so far**. At each day, the best possible profit *if you sold today* is `current_price - min_so_far`. Track the maximum across all days. **One pass, two running variables, done.** Best Time to Buy and Sell Stock is the **prototype of the running-state pattern**. Maintain a small number of running variables that summarize "everything seen so far," update them in one pass, return the final state. **NeetCode's canonical solution: single-pass with `min_price` and `max_profit`. O(n) time, O(1) space.** **The pattern transfer: any time the question is "best result over a left-extending range of the array," the answer is running state in a single pass.** This is the gateway pattern to dynamic programming. ---

    16 min

  4. 1D AGO

    LeetCode #20 — Valid Parentheses, Walked Through the Six-Phase Framework

    Whenever a problem involves **matching pairs that nest** — parentheses, function calls, undo/redo, HTML tags — the answer is a stack. The stack remembers what's still "open" so you can match the next "close" against the most recent open. **The pattern is "last opened, first closed" = LIFO = stack.** Get this once and you transfer it to the next dozen stack problems instantly. Valid Parentheses is the **introduction to the Stack pattern**. Stack remembers the most recent unclosed open; LIFO matches the nesting structure of brackets. The close-to-open hashmap collapses the comparison into one line. **Memorize NeetCode's approach as the canonical implementation — it's the template you'll modify on every other stack problem.** **The pattern transfer: any time the problem involves matching pairs with nesting, undo/redo, or "find the most recent thing of type X," reach for a stack.** ---

    19 min

  5. 3D AGO

    LeetCode #125 — Valid Palindrome, Walked Through the Six-Phase Framework

    A palindrome reads the same forwards and backwards. The naive way is to reverse the string and compare. The optimal way is to walk two pointers from the ends inward, comparing characters. The two-pointer pattern is the single most common alternative to hashmap when the data has natural "structure from both ends" — symmetry, sortedness, monotonicity. **Two pointers is what you reach for when the problem has structure but doesn't need memory.** Valid Palindrome is **the introduction to the two-pointer pattern**. Two pointers from both ends, moving inward, comparing as they go, with skip-logic for irrelevant characters. Time stays O(n); space drops to O(1). The pattern applies whenever data has symmetric or monotonic structure. **The pattern transfer: two-pointer is the alternative to hashmap when the problem has structure (sortedness, symmetry, monotonicity) instead of needing memory of past elements. Hashmap asks "have I seen this?"; two-pointer asks "what's at the other end?".** Knowing both, and knowing when to reach for which, covers the majority of array and string problems. ---

    16 min

  6. 3D AGO

    LeetCode #238 — Product of Array Except Self, Walked Through the Six-Phase Framework

    This problem looks like it should be solved with division (compute total product, divide by each element). But the problem explicitly *forbids* division. That constraint forces you to invent the prefix/suffix product pattern: for each index, the answer is "everything to my left, multiplied by everything to my right." Build those two products in two linear passes — done. Product of Array Except Self introduces the **prefix/suffix array** pattern. Whenever the answer at each position depends on "everything to the left" or "everything to the right," build those two products (or sums, or maxes) in linear passes. The space-optimized version reuses the output array, giving O(1) extra space. **The pattern transfer: this is the same skeleton as prefix sums, prefix maxes, prefix XORs, and the running-buy-low/sell-high trick in Best Time to Buy and Sell Stock. The data structure is implicit (no hashmap, no heap) — it's just two running variables and careful indexing.** ---

    17 min

  7. 3D AGO

    LeetCode #347 — Top K Frequent Elements, Walked Through the Six-Phase Framework

    Top K Frequent reduces to a two-step pipeline: (1) count occurrences with a hashmap, (2) extract the top k counts using a selection algorithm. The whole interesting decision is *how* you do step 2 — heap, full sort, or bucket sort. **Bucket sort is the optimal answer; heap is the standard interview answer; full sort is the brute force.** Knowing all three and articulating the tradeoff is the senior move. Top K Frequent is **count + select**. Counting is the hashmap pattern. Selection has three flavors: full sort (brute force), heap (standard), bucket sort (optimal when frequency range is bounded by n). Recognizing all three, picking the right one, and articulating the choice is the skill being tested. **The pattern transfer: any "top-k" problem decomposes into "produce candidates" plus "select top-k." The selection step is a heap problem unless something about the data structure (bounded keys, sorted input) opens a faster path.** ---

    13 min

  8. 3D AGO

    LeetCode #128 — Longest Consecutive Sequence, Walked Through the Six-Phase Framework

    Longest Consecutive Sequence asks for the longest run of consecutive integers in an unsorted array, in O(n) time. Sorting takes O(n log n), so we can't sort. The trick: **start a run only from a number that has no predecessor in the set**. That single observation collapses what looks like an O(n²) problem into a clean linear scan. Longest Consecutive Sequence is the **start-of-run** problem. The hashset gives O(1) membership; the trick is recognizing that you should only expand from numbers without predecessors. That single observation collapses an apparent O(n²) into a clean O(n). **The pattern transfer: when computing something over runs/groups in unordered data, find a way to identify each group exactly once — usually by checking whether you're at the "start" or "canonical representative" of that group.** This generalization shows up in flood-fill (visit each component from one seed), union-find (each component has one root), and many graph problems. ---

    20 min
See All (27)

About

I'm using AI to learn AI, and I'm publishing the journey as I go. Each episode is a NotebookLM-generated audio overview of a study brief I wrote — Chip Huyen chapters, LeetCode problem walkthroughs, AI Engineering interview topics. Built for myself, useful for anyone studying AI engineering for Google Cloud, Anthropic, OpenAI, or similar roles. Made transparently with NotebookLM (audio) and Claude (briefs). — Wilson Wu

Information

  • Creator
    Wilson Wu
  • Years Active
    2K
  • Episodes
    27
  • Rating
    Clean
  • Copyright
    © 2026 Wilson Wu
  • Show Website
    Code With Wilson