Code With Wilson

Wilson Wu
  • 0,0 (0)
  • TECNOLOGIA
  • DIÁRIO

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. HÁ 22 H

    LeetCode #169 — Majority Element: How to Actually Think About It

    Day 2, Problem 1 of LeetCode's Top Interview 150. This is one of those rare problems where the *natural* solution is fine, the *clever* solution is good, and the *optimal* solution is famously elegant — to the point of being named after its inventor. The optimal solution is called the **Boyer-Moore Voting Algorithm**, and it's the kind of thing that takes 3 lines of code but earns "interview gold" status because most candidates can't explain *why* it works. This episode is going to spend serious time on the *reasoning*, because the algorithm itself is short — but the proof of correctness is what separates senior candidates from junior ones. By the end of this episode you should be able to answer: (1) what are the three approaches and when would you reach for each? (2) why does Boyer-Moor...

    21 min

  2. HÁ 22 H

    LeetCode #26 — Remove Duplicates from Sorted Array: How to Actually Think About It

    Day 1, Problem 3 of LeetCode's Top Interview 150. The headline lesson of this episode: **problem qualifiers like "sorted" aren't decoration. They're optimization unlocks.** This problem reuses the slow/fast two-pointer scaffold from #27 Remove Element with one tiny change in the filter rule — but the *real* lesson is *why* that change works, and that lesson generalizes to dozens of other problems. By the end of this episode you should be able to answer: (1) what does the word "sorted" actually give you? (2) why don't you need a hashset for this problem, even though it's a deduplication problem? (3) how is this the same algorithm as Remove Element, with only the filter rule swapped? ## What we're doing here You're given an integer array `nums` sorted in non-decreasing order. Remove the d...

    17 min

  3. HÁ 22 H

    LeetCode #27 — Remove Element: How to Actually Think About It

    Day 1, Problem 2 of LeetCode's Top Interview 150. This is the cleanest possible introduction to a pattern called **slow/fast two-pointer** — also known as the "read pointer, write pointer" idiom. It looks deceptively easy. The trap isn't in the algorithm; it's in *understanding what "remove" actually means* when the problem says "in-place." By the end of this episode you should be able to answer: (1) what does "remove" mean when you can't actually delete? (2) what's the difference between this problem's two pointers and the two pointers we used in Merge Sorted Array? (3) why is the time complexity O(n) and not O(n²)? ## What we're doing here You're given an integer array `nums` and an integer `val`. Remove every occurrence of `val` from the array, in-place. Return how many elements are...

    18 min

  4. HÁ 23 H

    LeetCode #88 — Merge Sorted Array: How to Actually Think About It

    This is the first problem in LeetCode's official "Top Interview 150" list — Day 1, Problem 1. If you can think clearly about this one, you have the foundation for roughly 30 other problems in the same family. This episode assumes you already know the 6-phase framework (understand → recognize → brute force → optimize → implement → communicate). We're not going to belabor the structure. Instead, we're going to spend our time on the **actual mental moves** within each phase — the thinking that beginners skip and seniors do automatically. ## What we're doing here You're given two sorted integer arrays, `nums1` and `nums2`, and two integers `m` and `n`. Here's the part everybody misses on first read: **`nums1` is already length `m + n`**. The first `m` slots have real data. The last `n` slot...

    16 min

  5. 5 DE MAI.

    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

  6. 5 DE MAI.

    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

  7. 5 DE MAI.

    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

  8. 5 DE MAI.

    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
Ver tudo (31)

Sobre

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

Informações

  • Criado por
    Wilson Wu
  • Anos de atividade
    2 mil
  • Episódios
    31
  • Classificação
    Livre
  • Copyright
    © 2026 Wilson Wu
  • Site do podcast
    Code With Wilson