MEP-42 Linker and Runtime Recommendation

One paragraph each, Phase 1 vs Phase 2.

Code Signing and Notarization

Gatekeeper, notarytool, SmartScreen, Authenticode, and the real cost of shipping a desktop binary.

MEP-42 Phase 1: Naive Backend Recommendation

One-paragraph recommendation, plus reasoning, for which naive-emission technique Mochi MEP-42 should adopt as the first cut.

Static-PIE

Statically linked, position-independent, ASLR-friendly, and no dynamic loader required.

The Compile-Time vs Runtime Trade-Off

A conceptual essay on where Mochi MEP-42 should sit on the curve from "compile slowly, run fast" (LLVM -O3) through "compile and run at medium speed" (Cranelift, B3) to "compile instantly, run okay" (copy-and-patch, Sparkplug). Includes a back-of-envelope budget derived from MEP-17 and MEP-23 bench numbers.

MEP-42 Backend Survey: Summary and Recommendation

Comparison table and Phase 1 / Phase 2 recommendation for Mochi's native code-generation backend.

AOT Compilation Case Studies: Summary for MEP-42

Cross-cutting patterns from twelve production AOT pipelines, with a recommendation for which one Mochi should learn from most.

Hostable JIT/AOT Library Survey for Mochi

The "honorable mentions" beyond LLVM/Cranelift/MIR/QBE.

Emitting Object Files Directly for Mochi

What it takes to write a valid ELF/Mach-O/COFF from a backend's raw bytes.

Apple Universal Binaries

Fat Mach-O wrapping arm64 + x86_64, the lipo tool, and the end of x86_64 support.

Compiler Textbooks Relevant to a Naive Mochi Backend (2022-2026)

The published material a Mochi engineer should keep open while implementing MEP-42 phase 1. Cooper/Torczon 3rd ed for the canonical theory, Nystrom for a hands-on bytecode compiler walkthrough, Appel for the verified-compiler-curious, plus 2024-2026 course materials covering naive backends.

Source Maps and DWARF for WebAssembly

The two competing approaches to debugging Wasm, and why DWARF won inside Chrome.

Targets Summary

Single-page roll-up of every (target ISA x OS) combination Mochi MEP-42 could ship, with status and engineering complexity recommendations.

Static Python, Cinder, and CPython's Copy-and-Patch JIT

Meta's typed Python subset that can be AOT-aware, the Cinder JIT, and CPython 3.13+'s experimental copy-and-patch JIT.

Swift and Embedded Swift

Apple's Swift in two modes: full LLVM-driven AOT for app platforms, and a stripped Embedded Swift mode for microcontrollers and freestanding binaries.

GHC NCG and the LLVM Backend Choice

The Glasgow Haskell Compiler's native code generator: hand-written, x86_64 / aarch64 / risc-v, alongside an LLVM alternative.

Mojo

Python-syntax systems language built on MLIR, with both AOT and JIT pipelines, on the path to 1.0 in H1 2026.

APE (Actually Portable Executable) and Cosmopolitan Libc

A single binary that is simultaneously a valid ELF, Mach-O, PE, and BSD a.out.

WebAssembly Module Binary Format

The .wasm container, plus the component model binary and WAT text format.

Cranelift Internals: ISLE, Proof-Carrying Code, and the Portable Backend Story

The most actively researched mid-tier compiler backend of the 2020s. ISLE for instruction selection, proof-carrying code for Wasm-sandbox memory accesses, and VeriISLE for verified instruction-lowering rules. Where the "design and implementation of a portable codegen framework" line of work currently lives.

PE/COFF

The Windows executable and object format.

Mach-O

The Apple object/executable format: macOS, iOS, iPadOS, tvOS, watchOS, visionOS.

CodeView and PDB

Microsoft's native debug format, the sidecar PDB file, and the pain of producing one on Linux.

ELF (Executable and Linkable Format)

The universal Unix object/executable format: Linux, *BSD, Solaris, Haiku, embedded.

Wasmtime AOT as a Code-Generation Backend for Mochi

"Mochi → Wasm → wasmtime compile → native": skip the backend, use the wasm ecosystem.

TCC, chibicc, Cuik as Reference Points for Mochi

"How small can a useful native backend be?"

C as a Code-Generation Backend for Mochi

The lowest-cognitive-load path: emit C, let GCC/Clang do the rest.

MLIR as a Code-Generation Backend for Mochi

Multi-Level IR, dialect framework, the foundation under Mojo, IREE, and OpenXLA.

MLIR Dialect Literature 2023-2026

The Triton dialect (OpenAI, GPU codegen), the IREE dialect (Google, ML compiler), Mojo's MLIR-based KGEN compiler, and the broader trend of language frontends as MLIR dialects. The "if we wanted to be ambitious" backend story for Mochi.

POPL 2024 and 2025: Compiler-Construction Papers

Recent foundational work from POPL and its co-located CPP (Certified Programs and Proofs) workshop on verified compilation, secure calling conventions, and packet-filter codegen. Less directly applicable to a "naive emitter" than PLDI, but instructive for the verification story MEP-42 may eventually want.

DWARF 5 (and the DWARF 6 draft)

The cross-platform binary debug format, its current standard, and where the next version is going.

Freestanding / no-libc

Direct syscalls on Linux, why this is impossible on macOS, and the APE alternative.

PLDI 2024 and 2025: Relevant Code-Generation Papers

Recent work from the flagship PL conference on lightweight backends, baseline JIT design, superoptimization for stack bytecode, and library composition that sidesteps heavyweight compilation.

QBE as a Naive-But-Good-Enough Backend

A 14k-LOC SSA compiler backend by Quentin Carbonneaux that targets x86-64, arm64, and riscv64 from a textual SSA IR. The "70% of LLVM in 10% of the code" pitch. The natural fallback if writing our own emitter feels too risky.

Julia

JIT-first scientific language adding a real AOT path via juliac and a trimming-based static binary mechanism.

V Language

Statically-typed Go-influenced language that defaults to emitting C, with experimental native and LLVM backends and a multi-mode memory model.

Hare

Tiny systems language built on QBE, deliberately constrained, BSD/Linux-only, manual memory.

Nim

Static, GC-by-default systems language that emits C (or C++, JavaScript, LLVM) and inherits the host toolchain's optimiser.

The Go Runtime as a Library

cgo, c-shared, c-archive: keep vm3 in Go and call into it from native code.

Cosmopolitan Libc

One binary, six operating systems, two ISAs. The APE format and cosmocc toolchain.

golang-asm as a Code-Generation Backend for Mochi

Go's internal assembler exported as a library, already used by Mochi's vm2jit.

DynASM as a Code-Generation Backend for Mochi

Mike Pall's preprocessor-driven assembler with runtime patching; LuaJIT's secret weapon.

chibicc: A Minimal C Compiler as a Mochi Backend Reference

Rui Ueyama's ~10k LOC C compiler that emits x86-64 GAS assembly directly from a recursive-descent parser. The clearest published example of a single-pass codegen pipeline that produces correct code with no IR, no SSA, no register allocator. The right educational template for a "naive AOT" pass of MEP-42.

Copy-and-Patch as a Code-Generation Backend for Mochi

Stencil-based binary stitching from OOPSLA 2021, now shipping in CPython 3.13/3.14.

libgccjit as a Code-Generation Backend for Mochi

GCC as a shared library, used by Emacs native compilation, GCC Rust, GDC, Cython.

glibc

The default Linux libc, and the reasons "fully static linking" is officially unsupported.

MEP-41 Research Substrate: Memory Safety Advances 2023–May 2026

MEP-41 Research Substrate: Memory Safety Advances 2023–May 2026

Android Scudo + MTE inside ART

The canonical "secure allocator inside a managed runtime." Scudo is Android's hardened native heap, used for ART's non-managed allocations (JIT code, off-heap buffers, JNI). Pairs with ARM MTE on Armv9 hardware for hardware-checked tagging. Default for all native allocations on Android since 11.

Spectre Mitigations in Hosted JITs

Speculative-execution attacks haven't gone away. As of May 2026, every shipping JIT either implements index masking + bounds-check hardening, or relies on process-level Site Isolation, or both. The consensus: software mitigations alone are necessary but not sufficient; hardware (eIBRS, BHI controls, CET-IBT) carries the load on CPUs that have it.

W^X Enforcement in Modern JITs

What every shipping JIT must do on day 1 to be production-grade: never have a code page that is both writable and executable to the same thread at the same time. MAP_JIT + pthread_jit_write_protect_np on Apple Silicon, mprotect dance elsewhere, hardware shadow stacks (Intel CET, ARM BTI) increasingly mandatory.

V8 Pointer Compression Cage

A direct ancestor of vm3's 32-bit slab index. V8 squeezes 64-bit pointers down to 32-bit offsets within a per-isolate 4 GB virtual region (the "cage"). Cut V8's heap by 43%, Chrome renderer memory by 20%.

Inko — Singly-Owned Values

Single ownership with deterministic destruction, multiple simultaneous borrows allowed, runtime borrow-count enforcement. No GC, no compile-time borrow checker, no lifetime variables. Concurrency uses `uni T` (unique values) for safe inter-process transfer.

WasmGC

Native GC primitives in a portable bytecode. Ratified in Wasm 3.0 (Sep 2025), shipped in all major browsers by Dec 2024. Dart, Kotlin, OCaml, Java/Scala/Scheme can now compile to Wasm without bundling a GC.

Scala 3 Capture Checking

Capability tracking in the type system. Each value's type may carry a capture set listing which capabilities it could reference. Foundation for capability-based effects, separation checking (System Capybara), and ownership for resources.

WebAssembly Segmented Memory (and friends)

The CG-track answer to "what's beyond a single 4 GB linear memory?" Multiple memories shipped in Wasm 3.0 (Sep 2025). Memory64 shipped at the same time. A formal "segmented memory" proposal in the MSWasm vein has not yet entered the CG track but is influencing design.

Use-After-Free Landscape: Temporal vs Spatial, kCFI, and the Proven-by-Construction Story

The 2024-2026 industry picture on temporal memory safety, kernel mitigations, and the convergence of UAF defences.

Linear Haskell

Linearity attached to function arrows, not to types. Backwards-compatible: ordinary code continues to type-check unchanged. Experimental since GHC 9.0; still labelled experimental in 9.12 / 9.15 (2024–2026).

Intel LAM (Linear Address Masking) and the x86 top-byte-tag story

Intel LAM (Linear Address Masking) and the x86 top-byte-tag story

Capability-Machine Formalism and Endorsement Relations

Cerise, the CHERI-C Coq memory model, and capability-safety logical relations as the formal model behind handle-based runtimes.

Separation Logic for Managed (GC'd) Heaps

Iris-based separation logics with space credits, tracing GC, and the 2025 IrisFit + Nextgen-Modality lines.

Scudo & friends: hardened allocators in production

Scudo & friends: hardened allocators in production

MSWasm — Memory-Safe WebAssembly

A WebAssembly extension that replaces linear memory with segments and handles. Handles are unforgeable, typed pointers carrying bounds and provenance — closely modelled on CHERI capabilities but pure software.

Jane Street OxCaml — Modes (Uniqueness, Locality, Linearity)

Orthogonal modes layered onto OCaml's type system. Mode is a property of a value, separate from its type, tracked through inference. Production in Jane Street; open-sourced as OxCaml in 2025.

curl, Daniel Stenberg, and the "Is C/C++ The Actual Problem?" Debate

Stenberg's curl CVE data, the Hyper / Rust experiment, and the unresolved 2026 question of whether memory-safe languages are the whole answer.

V8 Sandbox

A purely software in-process sandbox for the V8 JS heap. Ban raw pointers, replace with offsets into a 1 TB sandbox region and indices into out-of-sandbox pointer tables. About 1% perf cost, enabled by default in Chrome 123. Every modern JIT is moving this direction.

Swift consuming / borrowing / inout & Noncopyable Types

Swift 6.x has shipped a complete move-only/noncopyable system layered on top of ARC. Parameter conventions are explicit; the law of exclusivity (Swift's variant from 2017) supplies the static aliasing discipline.

MarkUs and quarantine-style UAF prevention

MarkUs and quarantine-style UAF prevention

Formal Models of the Rust Borrow Checker

Stacked Borrows, the 2025 Tree Borrows replacement, and the trajectory of NLL / two-phase formalisation.

Chrome Memory-Safety Data and the Rust-in-Chrome Rollout

Chrome Security's published per-quarter memory-safety data for 2024-2026, the JSON / PNG / fonts Rust rollouts, and the V8 sandbox.

V8 — Orinoco + Oilpan

Chrome's two cooperating collectors. Orinoco runs V8's young-generation JS heap in parallel; Oilpan is Blink's traced C++ GC, recently hosted inside V8 as a library, learning to do generational collection with conservative stack scanning.

Project Verona Regions

Microsoft Research's experimental concurrent-ownership language. Ownership is over **regions** (groups of objects) instead of individual objects. Cowns (concurrent owners) serialise access; behaviours schedule work over multiple cowns atomically.

Intel CET Shadow Stack + IBT

Intel CET Shadow Stack + IBT

EU Cyber Resilience Act and Memory Safety

The CRA's 2026-2027 enforcement timeline and the implicit pressure toward memory-safe languages.

CakeML and the Verified-JIT Line

The bootstrapping verified ML compiler, its 2024 PLDI agenda, and the FM-JIT verified-JIT effort that builds on it.

Pony Reference Capabilities

Six capabilities (iso, trn, ref, val, box, tag) make actor-based concurrency data-race-free at compile time. Production at WallarooLabs and Microsoft; foundation for Verona's region work.

JavaScriptCore — Riptide

WebKit's retreating-wavefront concurrent garbage collector. Marks objects while JS runs, throttles allocation when it falls behind, and uses logical versioning to skip clearing bitmaps.

DoD Safe Coding Practices and Military / Aerospace Memory-Safety Procurement (2024-2026)

The DoD's evolving acquisition posture on memory-safe languages, the SWFT framework, and aerospace coding standards.

CompCert and the Verified-Compiler Toolchain

The production-grade formally verified C compiler, the CompCertO / Owlang line, and why it matters for JIT verification.

Arm PAC + BTI

Arm PAC + BTI

White House ONCD "Back to the Building Blocks" (February 2024)

The White House Office of the National Cyber Director's memory-safety report and the C/C++-adverse federal stance.

MTE in a Managed Runtime

MTE in a Managed Runtime

MMTk and LXR

A research framework that cleanly separates GC plans from policies, plus the LXR collector that proves a stop-the-world RC+mark-region design can beat industrial concurrent GCs on tail latency.

Austral

Strict linear types as the load-bearing primitive for memory and protocol safety, plus capability-based effect control. Spec-and-compiler-small enough to read in a weekend.

Aeneas

Rust verification by functional translation: compile Rust to a pure lambda calculus, verify there.

ZGC — Generational, Colored-Pointer GC (OpenJDK)

Java's flagship low-latency collector. Sub-millisecond pauses on multi-TB heaps via colored 64-bit pointers and concurrent everything.

NSA "Software Memory Safety" Guidance (2022) and the June 2025 Reissue

The NSA's formal language-level guidance, the named-language list, and the joint CISA reissue.

Mojo (2026)

A Rust-like ownership system with simpler call-site syntax, taped onto a Python-shaped surface, sitting on MLIR, headed to open source in fall 2026.

Kani

AWS's bit-precise bounded model checker for Rust, deployed in CI on Firecracker and the standard library.

Arm MTE

Arm MTE

Lobster — Compile-Time Reference Counting

A pragmatic language by Wouter van Oortmerssen that elides 95% of refcount ops at compile time through flow-typed lifetime analysis. Cycles handled by a cleanup at program exit.

Hylo (formerly Val)

Mutable value semantics with subscript-based projection borrowing, no lifetime variables, and the Law of Exclusivity enforced at call sites.

Creusot

A deductive verifier for safe Rust that compiles to Why3 and discharges to off-the-shelf SMT solvers.

CISA Secure-by-Design Pledge and the January 2026 Memory-Safety Deadline

The voluntary US federal pledge that has set the de-facto industry baseline for memory-safety roadmaps.

CHERIoT

CHERIoT

Verus

Microsoft Research's SMT-backed Rust verifier, the leading tool for verified systems software at scale in 2025-2026.

Vale Generational References

The direct intellectual ancestor of vm3's handle design: a per-allocation generation counter, a per-reference remembered generation, and a check on every dereference. Same idea, different layer.

Roc — Perceus in production-ish

The biggest real-world deployment of Perceus reference counting, layered with Morphic alias analysis and "seamless slices" so functional code rarely allocates.

Google: Android Rust, Chrome Rust, V8 Sandbox

Google's published 2022-2026 data on memory-safety progress — Android's 76% → <20% trajectory, the CVE-2025-48530 near-miss, the V8 sandbox.

Arm Morello

Arm Morello

RustBelt and Iris

Foundational separation-logic verification of Rust's safe / unsafe core, and its 2024-2026 RefinedRust successor.

Rust Polonius (2026)

The state of Rust's borrow checker as the Polonius "alpha" lands behind a nightly feature gate, and what a non-ownership language can still steal from it.

Perceus (Koka)

"Garbage-free" precise reference counting with reuse — in-place updates without locks, statically inserted at compile time.

Microsoft "70% of CVEs Are Memory Safety" Statistic

The canonical industry data point on memory-safety vulnerability prevalence, and every follow-up through 2026.

CHERI (Next Generation)

CHERI (Next Generation)

Other ISAs: PowerPC, MIPS, LoongArch, s390x, Apple GPU/Metal

Survey of niche or specialized architectures that MEP-42 should be aware of but probably defer.

WebAssembly

Wasm 3.0 (2025) as the stable target, plus WASI Preview 2/3 and the component model.

The Per-Opcode Template JIT Pattern

The general pattern that Sparkplug, Liftoff, JSC Baseline, and the HotSpot template interpreter all instantiate. Per-op native template, fixed register convention, stub calls for slow paths, optional inline caches as patchable code regions. Specifically considered here as an engineering implementation in pure Go without cgo.

Wasm Baseline Compilers: Liftoff, RabaldrMonkey, Winch

A converged design pattern across three independent implementations: per-opcode template emission, a virtual operand stack with lazy register promotion, no IR, no global optimization. The current state of the art in "fast and simple" Wasm code generation.

RISC-V RV64GC

The general-purpose 64-bit RISC-V baseline plus vector and recent extensions.

AArch64 Windows (Windows-on-ARM64)

Windows 11 on Snapdragon X / X2 Elite, Surface Pro X lineage, and ARM64EC interop.

musl libc

The static-friendly C library that makes "build once, ship anywhere" actually work on Linux.

Skipping the Linker Entirely

Emitting a self-contained executable from the compiler, no external linker required.

Crystal

Ruby-syntax statically-typed language with global type inference, LLVM backend, and Boehm GC.

Classical Single-Pass Code Generation

Tree-walk to tuples to native assembly. The textbook recipe from the Dragon Book and Cooper/Torczon, still the right starting point when you want correctness before performance.

Zig Self-Hosted Compiler

Systems language rebuilding its compiler around its own native backends, with LLVM demoted to an optional path.

Copy-and-Patch Compilation

Stencil-driven code generation that harvests pre-compiled opcode snippets at build time and stitches them into native code at runtime via relocation patches. No IR, no register allocator, no instruction selector. The technique CPython 3.13+ ships in production.

.NET NativeAOT

Microsoft's production successor to CoreRT: trimmed CoreCLR plus RyuJIT-as-AOT, shipping single-file native binaries.

GraalVM Native Image

Closed-world AOT compilation that turns a managed JVM application into a self-contained native executable.

MIR as a Code-Generation Backend for Mochi

Vladimir Makarov's lightweight JIT+AOT, fast compile times, lazy basic-block versioning.

GNU ld (bfd) and gold

The historical Linux workhorse and its dying sibling.

QBE as a Code-Generation Backend for Mochi

Quentin Carbonneaux's deliberately tiny SSA backend, "70% of LLVM in 10% of the code."

Apple's New Linker (ld_prime / ld_new)

The closed-source Mach-O linker that ships in Xcode 15 and later.

Cranelift as a Code-Generation Backend for Mochi

Bytecode Alliance's Rust-native SSA backend, ISLE-driven, ~10x faster compile than LLVM.

LLVM as a Code-Generation Backend for Mochi

The workhorse SSA infrastructure, version 20 era, evaluated for MEP-42.

AArch64 AAPCS64

The base 64-bit Arm calling standard, with Apple and Microsoft deltas called out.

x86_64 Windows (Microsoft x64) ABI

The 4-register fast-call convention used by every Windows-on-AMD64 binary.

mold: The Modern Linker

The fastest production ELF linker, single-author, MIT licensed.

JavaScriptCore Baseline JIT

Apple WebKit's original template-style baseline compiler, the longest-running production baseline JIT for a dynamic language, and the design template for every modern four-tier VM.

x86_64 System V AMD64 ABI

The default 64-bit Unix ABI: Linux, macOS, FreeBSD, OpenBSD, NetBSD, illumos.

Sparkplug: V8's Non-Optimizing Baseline JavaScript Compiler

A single-pass, IR-free transpiler from Ignition bytecode to native machine code, designed to add a fast tier between an interpreter and an optimizer with minimal engineering cost.

LLD: The LLVM Linker

One binary, four object formats, cross-link from any host.

LeetCode 1100: Find K-Length Substrings With No Repeated Characters

A clear explanation of counting substrings of length k with all unique characters using a sliding window.

LeetCode 1099: Two Sum Less Than K

A clear explanation of finding the maximum sum of two numbers less than k using a two-pointer approach on a sorted array.

LeetCode 1098: Unpopular Books

A clear explanation of finding books with fewer than 10 sales in the last year that were not sold in the last year using LEFT JOIN and GROUP BY.

LeetCode 1097: Game Play Analysis V

A clear explanation of finding the fraction of players retained the day after their first login using self-join and window functions.

LeetCode 1096: Brace Expansion II

A clear explanation of generating all strings from a brace expansion expression using recursive parsing and set union/concatenation.

LeetCode 1095: Find in Mountain Array

A clear explanation of finding a target in a mountain array using three binary searches on the interface API.

LeetCode 1094: Car Pooling

A clear explanation of determining if a car can transport all passengers using a difference array for passenger count tracking.

LeetCode 1093: Statistics from a Large Sample

A clear explanation of computing statistical measures (minimum, maximum, mean, median, mode) from a frequency count array.

LeetCode 1092: Shortest Common Supersequence

A clear explanation of finding the shortest string containing both input strings as subsequences using LCS dynamic programming.

LeetCode 1091: Shortest Path in Binary Matrix

A clear explanation of finding the shortest path from top-left to bottom-right in a binary matrix using BFS.

LeetCode 1090: Largest Values From Labels

A clear explanation of selecting the maximum sum subset under item and label count constraints using a greedy approach.

LeetCode 1089: Duplicate Zeros

A clear explanation of duplicating zeros in-place in an array without using extra space by working backwards.

LeetCode 1088: Confusing Number II

A clear explanation of counting confusing numbers up to n using digit backtracking with rotation validation.

LeetCode 1087: Brace Expansion

A clear explanation of generating all strings from a brace expansion pattern in lexicographic order using backtracking.

LeetCode 1086: High Five

A clear explanation of computing each student's top-5 average score using sorting and grouping.

LeetCode 1085: Sum of Digits in the Minimum Number

A clear explanation of checking if the digit sum of the array minimum is odd or even.

LeetCode 1084: Sales Analysis III

A clear explanation of finding products sold only in the first quarter of 2019 using GROUP BY with date range conditions.

LeetCode 1083: Sales Analysis II

A clear explanation of finding buyers who bought an iPhone but not an iPad using JOIN and NOT IN filtering.

LeetCode 1082: Sales Analysis I

A clear explanation of finding the best seller(s) by total price using GROUP BY, SUM, and a subquery for the maximum.

LeetCode 1081: Smallest Subsequence of Distinct Characters

A clear explanation of finding the lexicographically smallest subsequence with all distinct characters using a greedy stack approach.

LeetCode 1080: Insufficient Nodes in Root to Leaf Paths

A clear explanation of pruning tree nodes where all root-to-leaf paths through them have sum less than a limit, using post-order DFS.

LeetCode 1079: Letter Tile Possibilities

A clear explanation of counting all distinct non-empty sequences from a set of letter tiles using backtracking with frequency counting.

LeetCode 1078: Occurrences After Bigram

A clear explanation of finding all words that follow a two-word sequence in a text string.

LeetCode 1077: Project Employees III

A clear explanation of finding the most experienced employee(s) for each project using a window function or correlated subquery.

LeetCode 1076: Project Employees II

A clear explanation of finding the project with the most employees using GROUP BY, COUNT, and a subquery for the maximum.

LeetCode 1075: Project Employees I

A clear explanation of computing the average years of experience per project using JOIN and AVG aggregation.

LeetCode 1074: Number of Submatrices That Sum to Target

A clear explanation of counting submatrices with a given sum using 2D prefix sums combined with the subarray sum equals k technique.

LeetCode 1073: Adding Negative Numbers

A clear explanation of adding two non-positive integers represented as arrays of digits.

LeetCode 1072: Flip Columns For Maximum Number of Equal Rows

A clear explanation of finding the maximum number of rows that can be made all-equal by flipping columns, using row pattern normalization.

LeetCode 1071: Greatest Common Divisor of Strings

A clear explanation of finding the longest string that divides both strings using the GCD of their lengths.

LeetCode 1070: Product Sales Analysis III

A clear explanation of finding the first year each product was sold using a self-join or window function.

LeetCode 1069: Product Sales Analysis II

A clear explanation of computing total quantity sold per product using GROUP BY and SUM aggregation.

LeetCode 1068: Product Sales Analysis I

A clear explanation of retrieving product names and their sale years using a JOIN between Sales and Product tables.

LeetCode 1067: Digit Count in Range

A clear explanation of counting the occurrences of a specific digit in all numbers from 1 to n using digit dynamic programming.

LeetCode 1066: Campus Bikes II

A clear explanation of finding the minimum total Manhattan distance to assign bikes to workers using bitmask dynamic programming.

LeetCode 1065: Index Pairs of a String

A clear explanation of finding all index pairs where a word from the list appears in a text string using a trie.

LeetCode 1064: Fixed Point

A clear explanation of finding the smallest index where arr[i] equals i using binary search on a sorted distinct array.

LeetCode 1063: Number of Valid Subarrays

A clear explanation of counting subarrays where the leftmost element is not larger than any other element, using a monotonic stack.

LeetCode 1062: Longest Repeating Substring

A clear explanation of finding the longest substring that appears at least twice using binary search on length with rolling hash.

LeetCode 1061: Lexicographically Smallest Equivalent String

A clear explanation of finding the lexicographically smallest equivalent string using Union-Find with canonical representatives.

LeetCode 1060: Missing Element in Sorted Array

A clear explanation of finding the k-th missing number in a sorted array using binary search on the missing count.

LeetCode 1059: All Paths from Source Lead to Destination

A clear explanation of verifying that all paths from a source node lead to a destination using DFS with cycle detection.

LeetCode 1058: Minimize Rounding Error to Meet Target

A clear explanation of minimizing total rounding error when rounding prices to meet a target sum using a greedy approach.

LeetCode 1057: Campus Bikes

A clear explanation of greedily assigning bikes to workers based on Manhattan distance, prioritizing by distance then worker then bike index.

LeetCode 1056: Confusing Number

A clear explanation of checking if a number becomes a different valid number when rotated 180 degrees.

LeetCode 1055: Shortest Way to Form String

A clear explanation of finding the minimum number of subsequences of source needed to form target using greedy two-pointer scanning.

LeetCode 1054: Distant Barcodes

A clear explanation of rearranging barcodes so no two adjacent barcodes are equal using a greedy max-heap approach.

LeetCode 1053: Previous Permutation With One Swap

A clear explanation of finding the lexicographically largest permutation smaller than the given array using at most one swap.

LeetCode 1052: Grumpy Bookstore Owner

A clear explanation of maximizing satisfied customers by choosing the best window for the owner to not be grumpy using a sliding window.

LeetCode 1051: Height Checker

A clear explanation of counting students not in the expected height order by comparing the array to its sorted version.

LeetCode 1050: Actors and Directors Who Cooperated At Least Three Times

A clear explanation of finding actor-director pairs with at least three collaborations using GROUP BY and HAVING.

LeetCode 1049: Last Stone Weight II

A clear explanation of minimizing the last stone weight by splitting stones into two groups using 0/1 knapsack dynamic programming.

LeetCode 1048: Longest String Chain

A clear explanation of finding the longest word chain where each word is formed by inserting one letter into the previous word, using dynamic programming.

LeetCode 1047: Remove All Adjacent Duplicates In String

A clear explanation of eliminating adjacent duplicate character pairs from a string using a stack.

LeetCode 1046: Last Stone Weight

A clear explanation of simulating stone smashing to find the last remaining weight using a max heap.

LeetCode 1045: Customers Who Bought All Products

A clear explanation of finding customers who purchased every product in the catalog using GROUP BY and HAVING with COUNT DISTINCT.

LeetCode 1044: Longest Duplicate Substring

A clear explanation of finding the longest duplicate substring using binary search on length combined with Rabin-Karp rolling hash.

LeetCode 1043: Partition Array for Maximum Sum

A clear explanation of maximizing array sum by partitioning into subarrays of at most k elements, each filled with their maximum value, using dynamic programming.

LeetCode 1042: Flower Planting With No Adjacent

A clear explanation of assigning 4 flower types to garden nodes with no adjacent conflicts using greedy graph coloring.

LeetCode 1041: Robot Bounded In Circle

A clear explanation of determining if a robot stays in a bounded circle by checking position and direction after one instruction cycle.

LeetCode 1040: Moving Stones Until Consecutive II

A clear explanation of finding minimum and maximum moves to make stones consecutive using a sliding window.

LeetCode 1039: Minimum Score Triangulation of Polygon

A clear explanation of minimizing the total score of triangulating a polygon using interval dynamic programming.

LeetCode 1038: Binary Search Tree to Greater Sum Tree

A clear explanation of converting a BST to a greater sum tree by accumulating values in reverse inorder traversal.

LeetCode 1037: Valid Boomerang

A clear explanation of checking if three points form a boomerang (non-collinear) using the cross product.

LeetCode 1036: Escape a Large Maze

A clear explanation of determining if a source can reach a target in a very large grid with blocked cells using BFS with a cell count limit.

LeetCode 1035: Uncrossed Lines

A clear explanation of maximizing uncrossed connecting lines between two arrays using longest common subsequence dynamic programming.

LeetCode 1034: Coloring A Border

A clear explanation of coloring the border of a connected component in a grid using BFS.

LeetCode 1033: Moving Stones Until Consecutive

A clear explanation of finding the minimum and maximum moves to make three stones consecutive by analyzing gap cases.

LeetCode 1032: Stream of Characters

A clear explanation of efficiently querying a stream of characters against a word list using an Aho-Corasick trie.

LeetCode 1031: Maximum Sum of Two Non-Overlapping Subarrays

A clear explanation of finding two non-overlapping subarrays with maximum combined sum using prefix sums and running maximums.

LeetCode 1030: Matrix Cells in Distance Order

A clear explanation of sorting matrix cells by Chebyshev distance from a given center cell using BFS.

LeetCode 1029: Two City Scheduling

A clear explanation of minimizing total travel cost for two-city scheduling using a greedy refund approach after sending everyone to city A.

LeetCode 1028: Recover a Tree From Preorder Traversal

A clear explanation of reconstructing a binary tree from a depth-encoded preorder traversal string using a stack.

LeetCode 1027: Longest Arithmetic Subsequence

A clear explanation of finding the longest arithmetic subsequence in an array using dynamic programming with difference hash maps.

LeetCode 1026: Maximum Difference Between Node and Ancestor

A clear explanation of finding the maximum ancestor-node difference in a binary tree by tracking min and max along each root-to-leaf path.

LeetCode 1025: Divisor Game

A clear explanation of why Alice wins the divisor game if and only if n is even, proven by mathematical induction.

LeetCode 1024: Video Stitching

A clear explanation of finding the minimum number of video clips to cover a time range using a greedy interval covering approach.

LeetCode 1023: Camelcase Matching

A clear explanation of checking camelCase pattern matching by verifying uppercase consistency with a two-pointer approach.

LeetCode 1022: Sum of Root To Leaf Binary Numbers

A clear explanation of summing root-to-leaf binary numbers in a binary tree using DFS with accumulated values.

LeetCode 1021: Remove Outermost Parentheses

A clear explanation of removing outermost parentheses from each primitive decomposition by tracking nesting depth.

LeetCode 1020: Number of Enclaves

A clear explanation of counting land cells unreachable from the grid border using BFS from boundary land cells.

LeetCode 1019: Next Greater Node In Linked List

A clear explanation of finding the next greater value for each node in a linked list using a monotonic stack.

LeetCode 1018: Binary Prefix Divisible By 5

A clear explanation of checking divisibility of binary prefixes by 5 using running remainder tracking.

LeetCode 1017: Convert to Base -2

A clear explanation of converting a non-negative integer to its base negative-two representation.

LeetCode 1016: Binary String With Substrings Representing 1 To N

A clear explanation of checking whether a binary string contains all binary representations of integers from 1 to n.

LeetCode 1015: Smallest Integer Divisible by K

A clear explanation of finding the smallest repunit divisible by K by tracking remainders to detect cycles.

LeetCode 1014: Best Sightseeing Pair

A clear explanation of maximizing the sightseeing score by tracking the best left value seen so far in a single pass.

LeetCode 1013: Partition Array Into Three Parts With Equal Sum

A clear explanation of checking if an array can be split into three contiguous parts with equal sum using a greedy two-pass approach.

LeetCode 1012: Numbers With Repeated Digits

A clear explanation of counting numbers up to n with at least one repeated digit using digit DP and combinatorics.

LeetCode 1011: Capacity To Ship Packages Within D Days

A clear explanation of finding the minimum ship capacity to deliver all packages within D days using binary search.

LeetCode 1010: Pairs of Songs With Total Durations Divisible by 60

A clear explanation of counting song pairs whose total duration is divisible by 60 using remainder frequency counting.

LeetCode 1009: Complement of Base 10 Integer

A clear explanation of finding the complement of a number by XORing with a bitmask of the same bit length.

LeetCode 1008: Construct Binary Search Tree from Preorder Traversal

A clear explanation of reconstructing a BST from its preorder traversal using value range bounds.

LeetCode 1007: Minimum Domino Rotations For Equal Row

A clear explanation of finding minimum rotations to make all tops or bottoms equal using a greedy candidate check.

LeetCode 1006: Clumsy Factorial

A clear explanation of computing the clumsy factorial by simulating cyclic operators with a stack.

LeetCode 1005: Maximize Sum Of Array After K Negations

A clear explanation of maximizing array sum after exactly k negations using a greedy strategy.

LeetCode 1004: Max Consecutive Ones III

A clear explanation of finding the longest subarray of ones by flipping at most k zeros using a sliding window.

LeetCode 1003: Check If Word Is Valid After Substitutions

A clear explanation of validating a string by repeatedly removing 'abc' substrings using a stack.

LeetCode 1002: Find Common Characters

A clear explanation of finding characters that appear in all words using minimum frequency counts.

LeetCode 1001: Grid Illumination

A clear explanation of simulating lamp illumination on a grid using hash maps for rows, columns, and diagonals.

Appendix D. Polynomial Algebra

LeetCode 964: Least Operators to Express Number

A clear explanation of expressing a target using the fewest operators with repeated uses of x.

LeetCode 954: Array of Doubled Pairs

A clear explanation of checking whether an array can be reordered into pairs where one number is double the other.

LeetCode 953: Verifying an Alien Dictionary

A clear explanation of checking whether words are sorted according to a custom alien alphabet order.

LeetCode 944: Delete Columns to Make Sorted

A clear explanation of solving Delete Columns to Make Sorted by checking each column independently.

LeetCode 940: Distinct Subsequences II

A clear explanation of solving Distinct Subsequences II using dynamic programming and last occurrence tracking.

LeetCode 936: Stamping The Sequence

A clear explanation of solving Stamping The Sequence using reverse simulation and BFS-style processing.

LeetCode 929: Unique Email Addresses

A clear explanation of solving Unique Email Addresses using string normalization and a hash set.

LeetCode 918: Maximum Sum Circular Subarray

A clear explanation of finding the maximum circular subarray sum using Kadane's algorithm.

LeetCode 910: Smallest Range II

A clear explanation of minimizing the array range after adding either +k or -k to every element.

LeetCode 883: Projection Area of 3D Shapes

A clear explanation of computing the projection areas of stacked cubes from top, front, and side views.

LeetCode 749: Contain Virus

Simulate virus containment by repeatedly quarantining the most dangerous infected region and spreading the remaining regions.

LeetCode 747: Largest Number At Least Twice of Others

Find whether the maximum element is at least twice every other element using a single linear scan.

LeetCode 745: Prefix and Suffix Search

Support fast prefix and suffix queries by indexing every prefix-suffix combination with the largest word index.

LeetCode 744: Find Smallest Letter Greater Than Target

Use binary search to find the smallest character strictly greater than the target with wraparound handling.

LeetCode 742: Closest Leaf in a Binary Tree

Find the nearest leaf to a target node by converting the tree into an undirected graph and running breadth-first search.

LeetCode 740: Delete and Earn

Transform the problem into House Robber dynamic programming by grouping equal values into total points.

LeetCode 731: My Calendar II

Allow double bookings but reject triple bookings using overlap interval tracking.

LeetCode 720: Longest Word in Dictionary

A clear explanation of finding the longest buildable word using sorting and a hash set.

LeetCode 695: Max Area of Island

Find the largest connected island area in a binary grid using depth-first search.

LeetCode 692: Top K Frequent Words

Find the k most frequent words using frequency counting and custom sorting by count and lexicographical order.

LeetCode 684: Redundant Connection

Find the extra edge in an undirected graph that creates a cycle using Union-Find.

LeetCode 682: Baseball Game

Simulate a baseball scoring system using a stack to process operations and compute the final score.

LeetCode 620: Not Boring Movies

A SQL guide for filtering movies with odd IDs and non-boring descriptions, then sorting by rating.

LeetCode 619: Biggest Single Number

A SQL guide for finding the largest number that appears exactly once in a table.

LeetCode 618: Students Report By Geography

A SQL guide for pivoting rows into columns using ranking and conditional aggregation.

LeetCode 617: Merge Two Binary Trees

A recursive tree traversal guide for merging two binary trees node by node.

LeetCode 612: Shortest Distance in a Plane

A SQL guide for finding the minimum Euclidean distance between any two points in a 2D plane.

LeetCode 608: Tree Node

A SQL guide for classifying binary tree nodes as Root, Inner, or Leaf based on parent-child relationships.

LeetCode 582: Kill Process

A clear graph traversal solution for finding all processes terminated when killing a target process.

LeetCode 558: Logical OR of Two Binary Grids Represented as Quad-Trees

A clear explanation of merging two quad-trees using recursive logical OR operations.

LeetCode 557: Reverse Words in a String III

A clear explanation of Reverse Words in a String III using two-pointer scanning and string reversal.

LeetCode 549: Binary Tree Longest Consecutive Sequence II

A clear explanation of finding the longest increasing or decreasing consecutive path in a binary tree using DFS.

LeetCode 548: Split Array with Equal Sum

A clear explanation of splitting an array into four equal-sum parts using prefix sums and set-based search.

LeetCode 545: Boundary of Binary Tree

A clear explanation of collecting the boundary of a binary tree using separate left boundary, leaves, and right boundary traversals.

LeetCode 524: Longest Word in Dictionary through Deleting

A clear explanation of finding the longest dictionary word obtainable as a subsequence using two pointers and sorting rules.

LeetCode 523: Continuous Subarray Sum

A clear explanation of detecting a subarray whose sum is a multiple of k using prefix sums and modular arithmetic.

LeetCode 521: Longest Uncommon Subsequence I

A clear explanation of finding the longest uncommon subsequence between two strings using simple case analysis.

LeetCode 519: Random Flip Matrix

A clear explanation of randomly flipping zero cells in a matrix without repetition using hash mapping and virtual swapping.

LeetCode 515: Find Largest Value in Each Tree Row

A clear explanation of finding the maximum value at every depth of a binary tree using level-order traversal.

LeetCode 510: Inorder Successor in BST II

A clear explanation of finding the inorder successor in a binary search tree when nodes contain parent pointers.

LeetCode 507: Perfect Number

A clear explanation of checking whether a number equals the sum of its positive divisors excluding itself.

LeetCode 505: The Maze II

A clear explanation of finding the shortest rolling distance in a maze using Dijkstra’s algorithm.

LeetCode 504: Base 7

A clear explanation of converting an integer into its base 7 string representation using repeated division.

LeetCode 434: Number of Segments in a String

Count the number of word segments in a string by detecting transitions from spaces to non-space characters.

LeetCode 431: Encode N-ary Tree to Binary Tree

Convert an N-ary tree into a binary tree and reconstruct it using the left-child right-sibling representation.

LeetCode 429: N-ary Tree Level Order Traversal

Traverse an N-ary tree level by level using breadth-first search.

LeetCode 419: Battleships in a Board

A clear explanation of counting battleships in a board using one-pass observation without modifying the grid.

LeetCode 418: Sentence Screen Fitting

A clear explanation of fitting a sentence onto a screen using cyclic string simulation and greedy row transitions.

LeetCode 413: Arithmetic Slices

A clear explanation of counting arithmetic subarrays using dynamic programming and consecutive differences.

LeetCode 399: Evaluate Division

A clear explanation of solving division equations using graph traversal and weighted edges.

LeetCode 373: Find K Pairs with Smallest Sums

A clear explanation of finding the k smallest pair sums from two sorted arrays using a min heap and best-first search.

LeetCode 372: Super Pow

A clear explanation of computing large modular exponentiation using fast power, modular arithmetic, and digit decomposition.

LeetCode 342: Power of Four

A clear explanation of Power of Four using bit manipulation and binary properties.

LeetCode 324: Wiggle Sort II

A clear explanation of Wiggle Sort II using sorting, median splitting, and virtual indexing.

LeetCode 323: Number of Connected Components in an Undirected Graph

A clear explanation of counting connected components using Union-Find and graph traversal.

LeetCode 322: Coin Change

A clear explanation of Coin Change using dynamic programming for minimum coin count.

LeetCode 307: Range Sum Query - Mutable

A clear explanation of Range Sum Query - Mutable using a Fenwick Tree for efficient updates and range sums.

LeetCode 305: Number of Islands II

A clear explanation of Number of Islands II using Union-Find to dynamically merge connected land cells.

LeetCode 304: Range Sum Query 2D - Immutable

A clear explanation of Range Sum Query 2D - Immutable using a 2D prefix sum matrix for constant-time rectangle queries.

LeetCode 284: Peeking Iterator

A wrapper iterator design that supports peeking at the next element without advancing the iterator.

LeetCode 283: Move Zeroes

A two-pointer in-place solution for moving all zeroes to the end while preserving the relative order of non-zero elements.

LeetCode 282: Expression Add Operators

A backtracking solution for inserting operators into a numeric string so the expression evaluates to a target value.

LeetCode 265: Paint House II

A clear explanation of the Paint House II problem using optimized dynamic programming with minimum and second minimum tracking.

LeetCode 260: Single Number III

A clear explanation of the Single Number III problem using XOR partitioning to isolate the two unique numbers.

LeetCode 259: 3Sum Smaller

A clear explanation of the 3Sum Smaller problem using sorting and the two-pointer technique.

LeetCode 242: Valid Anagram

A clear explanation of checking whether two strings are anagrams using character frequency counting.

LeetCode 241: Different Ways to Add Parentheses

A clear explanation of generating all possible results from different parenthesizations using divide and conquer recursion.

LeetCode 235: Lowest Common Ancestor of a Binary Search Tree

A clear explanation of finding the lowest common ancestor in a binary search tree using BST ordering properties.

LeetCode 233: Number of Digit One

A detailed explanation of counting how many times digit one appears from 0 to n using positional digit analysis.

LeetCode 232: Implement Queue using Stacks

A detailed explanation of implementing a FIFO queue using two LIFO stacks with amortized constant time operations.

LeetCode 231: Power of Two

A clear explanation of determining whether an integer is a power of two using binary properties and bit manipulation.

LeetCode 218: The Skyline Problem

A clear explanation of computing the skyline formed by buildings using sweep line and a max-heap.

LeetCode 217: Contains Duplicate

A clear explanation of detecting duplicates in an array using a hash set and sorting.

LeetCode 174: Dungeon Game

A clear explanation of computing the minimum initial health needed to survive a dungeon using reverse dynamic programming.

LeetCode 172: Factorial Trailing Zeroes

A clear explanation of counting trailing zeroes in n! by counting factors of 5 instead of computing the factorial directly.

LeetCode 171: Excel Sheet Column Number

A clear explanation of converting an Excel column title into its numeric index using base 26 accumulation.

LeetCode 150: Evaluate Reverse Polish Notation

Evaluate an arithmetic expression written in Reverse Polish Notation using a stack.

LeetCode 149: Max Points on a Line

Find the maximum number of points lying on the same straight line using slope counting and normalization.

LeetCode 146: LRU Cache

Design an LRU cache with O(1) get and put operations using a hash map and doubly linked list.

LeetCode 145: Binary Tree Postorder Traversal

Return the postorder traversal of a binary tree using recursion or an iterative stack-based approach.

LeetCode 142: Linked List Cycle II

Find the node where a linked list cycle begins using Floyd’s tortoise and hare algorithm with cycle entry mathematics.

LeetCode 141: Linked List Cycle

Detect whether a linked list contains a cycle using Floyd’s tortoise and hare two-pointer algorithm.

LeetCode 138: Copy List with Random Pointer

Create a deep copy of a linked list with next and random pointers using hash maps or interleaved node cloning.

LeetCode 137: Single Number II

Find the number that appears once when every other number appears three times using bit counting or finite-state bit manipulation.

Chapter 126. Numerical Linear Algebra

LeetCode 120: Triangle

A clear explanation of finding the minimum path sum in a triangle using bottom-up dynamic programming.

LeetCode 119: Pascal's Triangle II

A clear explanation of generating a single row of Pascal's Triangle using in-place dynamic programming.

LeetCode 118: Pascal's Triangle

A clear explanation of generating Pascal's Triangle row by row using dynamic programming.

LeetCode 117: Populating Next Right Pointers in Each Node II

A clear explanation of connecting next pointers in any binary tree using constant extra space.

LeetCode 115: Distinct Subsequences

A clear explanation of counting distinct subsequences using dynamic programming.

LeetCode 114: Flatten Binary Tree to Linked List

A clear explanation of flattening a binary tree into a linked list in preorder traversal order using recursive depth-first search.

LeetCode 113: Path Sum II

A clear explanation of finding all root-to-leaf paths whose values add up to a target sum using depth-first search and backtracking.

LeetCode 109: Convert Sorted List to Binary Search Tree

A clear explanation of converting a sorted linked list into a height-balanced binary search tree using slow and fast pointers.

LeetCode 108: Convert Sorted Array to Binary Search Tree

A clear explanation of building a height-balanced binary search tree from a sorted array using divide and conquer.

Chapter 84. Bidiagonal Form

Chapter 83. Tridiagonal Form

Chapter 73. Ramsey Theory

Chapter 72. Perfect Graphs

Chapter 71. Brooks' Theorem

Chapter 65. Dominating Sets

LeetCode 64: Minimum Path Sum

A clear guide to finding the minimum path sum in a grid using dynamic programming.

Chapter 64. Cliques

LeetCode 63: Unique Paths II

A clear guide to counting unique paths in a grid with obstacles using dynamic programming.

Chapter 63. Independent Sets

LeetCode 62: Unique Paths

A clear guide to counting unique paths in a grid using dynamic programming.

Chapter 62. Edge Covers

LeetCode 61: Rotate List

A clear guide to rotating a linked list to the right by k places using a circular list.

Chapter 61. Vertex Covers

Chapter 60. Maximum Matching Algorithms

Chapter 59. Bipartite Matching

Chapter 58. Hall's Marriage Theorem

Chapter 57. Singular Value Decomposition

Chapter 57. Perfect Matchings

Chapter 56. Hermitian and Normal Matrices

Chapter 53. Graph Separators

Euler Products

Euler products are one of the central ideas of analytic number theory. They express infinite sums over integers as infinite products over primes.

Dirichlet Series

An arithmetic function $fn$ can be encoded into an infinite series of the form

Average Orders of Arithmetic Functions

Arithmetic functions often fluctuate strongly from one integer to the next.

Chapter 44. Quotient Spaces and Quotient Operators

Chapter 44. Intersection Graphs

Möbius Inversion

Many arithmetic functions are defined through sums over divisors. For example,

Dirichlet Convolution

Arithmetic functions can be added and multiplied pointwise, but number theory has another product that is better adapted to divisibility.

Completely Multiplicative Functions

An arithmetic function is a function defined on the positive integers. Such a function

Frobenius Automorphisms

One of the deepest ideas in algebraic number theory is that prime numbers possess hidden symmetry inside field extensions.

Parity Problem

Sieve methods are extremely effective for estimating how many integers avoid small prime factors. They have produced major results about:

Appendix A.1 Sets and Functions

A set is a collection of objects called elements.

Liouville Function

The Liouville function is an arithmetic function denoted by

Decomposition and Inertia Groups

Let

Chen's Theorem

The Twin Prime Conjecture states that infinitely many primes satisfy

Future Directions in Number Theory

Modern number theory continues to evolve rapidly.

Euler Totient Function

Euler's totient function is an arithmetic function denoted by

Ramification of Primes

In the ordinary integers, every nonzero integer factors uniquely into prime numbers.

Bombieri-Vinogradov Theorem

The Prime Number Theorem for arithmetic progressions states that for

The Langlands Program

The Langlands program is one of the largest and most influential research programs in modern mathematics.

Möbius Function

The Möbius function is an arithmetic function denoted by

Local Fields

Classical number theory studies arithmetic globally over fields such as

Brun-Titchmarsh Theorem

One of the central problems of analytic number theory is understanding how primes distribute among residue classes.

The Birch and Swinnerton-Dyer Conjecture

An elliptic curve over $\mathbb{Q}$ may be written in Weierstrass form

Divisor Functions

Divisor functions measure the positive divisors of an integer. They are among the first examples of arithmetic functions, because their values depend directly on the prime...

$p$-Adic Numbers

The real numbers arise by completing the rational numbers using the ordinary absolute value. The $p$-adic numbers arise by completing the rational numbers using the $p$-adic...

Large Sieve

Classical sieve methods estimate how many integers survive congruence restrictions. The large sieve approaches these problems from a different direction.

The Riemann Hypothesis

The Riemann zeta function is one of the central objects in mathematics.

Applications to Computation

Modular arithmetic is not only a theoretical language for divisibility. It is also one of the main tools of computation with integers.

Valuations and Absolute Values

In ordinary analysis, the absolute value

Selberg Sieve

Brun's sieve introduced the idea of estimating sifted sets through truncated inclusion-exclusion. However, Brun's method often produced bounds that were technically difficult...

Fermat's Last Theorem

Fermat's Last Theorem states that there are no positive integers

Fast Modular Exponentiation

Modular arithmetic often requires computing powers such as

Dedekind Domains

Ordinary integers satisfy several remarkable properties simultaneously:

Brun Sieve

Sieve methods are techniques for counting integers that remain after removing residue classes modulo primes.

Geometric Langlands Theory

The classical Langlands program relates:

Open Problems in Number Theory

Number theory contains some of the oldest and deepest unsolved problems in mathematics.

Chinese Remainder Theorem

The Chinese remainder theorem describes when several congruence conditions can be combined into one congruence. Its cleanest form occurs when the moduli are pairwise coprime.

Principal Ideals

Let $R$ be a commutative ring. An ideal $I\subseteq R$ is called principal if there exists an element $\alpha\in R$ such that

Schnirelmann Density

In additive number theory, ordinary asymptotic density is often too weak to control additive behavior.

Shimura Varieties

Modular curves parameterize elliptic curves and connect modular forms with arithmetic geometry.

Arithmetic Statistics

Arithmetic statistics studies the distribution of arithmetic objects inside large families.

Systems of Congruences

A system of congruences asks for an integer satisfying several congruence conditions simultaneously.

Discriminants

The discriminant is one of the most important invariants of a number field. It measures how the arithmetic of the field differs from ordinary rational arithmetic.

Additive Bases

A central question in additive number theory asks whether every integer can be represented as a sum of elements from a fixed set.

Trace Formulas

Fourier analysis decomposes functions into harmonic frequencies.

Probabilistic Models for Primes

Prime numbers are deterministic objects, but many aspects of their distribution resemble random behavior.

Modular Inverses

In ordinary arithmetic, division by a nonzero number means multiplication by its reciprocal. Modular arithmetic is more delicate. A residue class may or may not have a...

Units and Dirichlet Unit Theorem

Let $K$ be a number field and let

Exponential Sums

Exponential sums are among the central tools of analytic number theory.

Automorphic $L$-Functions

The Riemann zeta function

Random Matrices and Zeta Zeros

The Riemann zeta function is defined for $\operatorname{Re}s>1$ by

Linear Congruences

A linear congruence is a congruence of the form

Class Groups

In ordinary integers, every ideal is generated by a single element:

Circle Method

Many problems in additive number theory ask whether an integer can be represented in the form

Functoriality

The Langlands program predicts that many different arithmetic objects are connected by systematic transfers.

Probabilistic Algorithms

A probabilistic algorithm uses random choices during its execution. In number theory, this is often a practical advantage rather than a weakness.

Arithmetic Modulo $n$

Arithmetic modulo $n$ is arithmetic performed on residue classes modulo $n$. Instead of distinguishing all integers separately, we identify integers that have the same...

Ideals and Prime Ideals

In ordinary integers, every number factors uniquely into primes. In many rings of algebraic integers, this property fails.

Waring's Problem

Waring's problem asks whether every sufficiently large positive integer can be written as a sum of a bounded number of fixed powers.

Galois Representations

Galois groups encode the symmetries of algebraic equations and field extensions.

Probabilistic Primality

A primality test determines whether an integer is prime.

Chapter 30. Inner Products

Residue Classes

Congruence modulo $n$ groups integers according to their remainders after division by $n$. If two integers have the same remainder, they are congruent modulo $n$.

Unique Factorization Failure

One of the central properties of the ordinary integers is unique factorization.

Goldbach Problems

Goldbach-type problems ask whether integers can be represented as sums of primes. They are among the oldest and most famous problems in additive number theory.

The Langlands Program

The Langlands program is one of the most ambitious and influential theories in modern mathematics.

Smooth Numbers

A positive integer is called $y$-smooth if all of its prime factors are at most $y$.

Congruence Relations

Ordinary equality compares integers exactly. In many arithmetic problems, however, only the remainder after division matters.

Norm and Trace

Let $K$ be a number field of degree

Sumsets

Additive number theory studies arithmetic structure through addition of integers and subsets of integers.

Automorphic Representations

Classical modular form theory begins with analytic functions satisfying symmetry conditions.

Random Integers

Number theory often studies exact statements about individual integers. For example, one may ask whether a given integer is prime, squarefree, smooth, or representable as a...

Distribution Heuristics of Primes

The infinitude of primes guarantees that primes continue indefinitely, but it says nothing about how frequently primes occur.

Ring of Integers

In ordinary arithmetic, the integers

Generalized Riemann Hypothesis

The classical Riemann Hypothesis concerns the zeros of the Riemann zeta function

Automorphic Forms

Modular forms are functions on the upper half-plane satisfying symmetry conditions under the modular group

Zero-Knowledge Proofs

A zero-knowledge proof allows one party to convince another that a statement is true without revealing why it is true.

Euler's Proof

Euclid proved that there are infinitely many primes by contradiction. Euler discovered a very different proof based on infinite series and products.

Number Fields

A number field is a finite extension of the rational numbers. Concretely, it is a field $K$ satisfying

Nonvanishing Results

A central theme in analytic number theory is determining when an $L$-function is nonzero at a particular point.

The Modularity Theorem

For centuries, elliptic curves and modular forms were studied as separate objects.

Post-Quantum Cryptography

Modern public-key cryptography relies heavily on two computational assumptions:

Euclid's Proof

Euclid's proof of the infinitude of primes is one of the earliest examples of a general argument in number theory. It does not depend on computation, experimentation, or...

Minimal Polynomials

An algebraic number is a complex number that satisfies some nonzero polynomial equation with rational coefficients. Thus $\alpha\in\mathbb{C}$ is algebraic if there exists a...

Primes in Arithmetic Progressions

An arithmetic progression is a sequence of the form

Elliptic Curves and Modularity

An elliptic curve is simultaneously:

Lattice Cryptography

Lattice cryptography is a family of cryptographic systems based on the presumed hardness of computational problems on high-dimensional lattices.

LeetCode 24: Swap Nodes in Pairs

A detailed explanation of swapping every two adjacent nodes in a linked list using pointer manipulation.

Infinitude of Primes

Prime numbers are the building blocks of the positive integers. Once unique prime factorization is known, a natural question arises: are there only finitely many primes, or do...

Algebraic Integers

The ordinary integers

Dirichlet $L$-Functions

The Riemann zeta function

Modular Curves

The modular group acts on the upper half-plane by fractional linear transformations:

Pairing-Based Cryptography

Pairing-based cryptography uses special maps defined on elliptic curve groups. A pairing is a function

LeetCode 23: Merge k Sorted Lists

A detailed explanation of merging k sorted linked lists using a min heap.

Arithmetic Functions from Factorization

An arithmetic function is a function whose domain is the positive integers. It assigns a value to each integer

Diophantine Approximation

Diophantine approximation studies how closely real numbers can be approximated by rational numbers.

Orthogonality Relations

Dirichlet characters behave analogously to exponential functions in Fourier analysis. Just as complex exponentials separate frequencies, characters separate residue classes...

Hecke Operators

Modular forms already possess symmetry under the modular group. Yet a deeper arithmetic structure emerges through another family of operators: the Hecke operators.

Elliptic Curve Cryptography

Elliptic curve cryptography is a public-key cryptographic framework based on the arithmetic of elliptic curves over finite fields.

Canonical Prime Decomposition

Unique prime factorization says that every integer $n>1$ can be written as a product of primes. The canonical prime decomposition is the ordered and exponentiated version of...

Pell Equations via Continued Fractions

Recall that a Pell equation has the form

Dirichlet Characters

The Riemann zeta function studies prime numbers globally, without distinguishing congruence classes. However, many arithmetic questions concern primes satisfying conditions such as

Cusp Forms

Modular forms satisfy strong symmetry conditions under the modular group. Among them, cusp forms form the deepest and most arithmetic subclass.

Diffie-Hellman Key Exchange

Secure communication requires two parties to share secret information. In classical symmetric cryptography, both parties must already possess the same secret key before...

Unique Prime Factorization

The fundamental theorem of arithmetic states that every integer $n>1$ can be written as a product of prime numbers, and that this product is unique up to the order of the factors.

Convergents

The convergents of a continued fraction are the rational numbers obtained by truncating the expansion at finite stages.

Connections with Prime Distribution

The Riemann zeta function was introduced through the series

Eisenstein Series

Among all modular forms, Eisenstein series are the most explicit and computationally accessible.

RSA Cryptosystem

Classical cryptography uses a shared secret key. Both sender and receiver must know the same secret information in advance.

Coprime Integers

Two integers $a$ and $b$, not both zero, are called coprime if their greatest common divisor is $1$:

Rational Approximations

Many important numbers are irrational:

Explicit Formulae

One of the deepest ideas in analytic number theory is that the zeros of the zeta function determine the distribution of prime numbers.

Modular Forms

Modular forms are among the central objects of modern number theory.

Symbolic and Numeric Computation

Modern number theory relies heavily on computation. Two broad computational paradigms dominate the subject:

Bezout Identities

Let $a$ and $b$ be integers. An integer of the form

Infinite Continued Fractions

Finite continued fractions correspond exactly to rational numbers. When the Euclidean algorithm never terminates, the continued fraction becomes infinite.

Riemann Hypothesis

The Riemann zeta function has nontrivial zeros inside the critical strip

Modular Functions

The modular group acts on the upper half-plane by fractional linear transformations:

Algorithms for Elliptic Curves

Elliptic curves occupy a central position in modern number theory, arithmetic geometry, and cryptography.

Chapter 19. Strong Connectivity

19. Parsing

CPython's PEG parser, Grammar/python.gram, the generated Parser/parser.c, and parse tree construction.

Extended Euclidean Algorithm

The Euclidean algorithm computes the greatest common divisor of two integers. The extended Euclidean algorithm does more. It also expresses the gcd as an integer linear...

Finite Continued Fractions

A finite continued fraction is an expression of the form

Zeros of the Zeta Function

The zeros of the Riemann zeta function are the complex numbers $s$ satisfying

Modular Groups

Modular forms begin with the action of certain matrix groups on the complex upper half-plane.

Algorithms for Modular Forms

Modular forms are highly structured analytic functions with deep arithmetic properties. Although their definitions involve complex analysis and group actions, modular forms...

Hints for Selected Problems

Write the two integers as

18. Tokenization

Tokenize module internals, the C tokenizer in Parser/tokenize.c, and how indentation becomes INDENT/DEDENT tokens.

Euclidean Algorithm

The greatest common divisor of two integers can be found by listing divisors, but this method becomes inefficient for large numbers. For example, finding

Euclidean Algorithm Revisited

The Euclidean algorithm is one of the oldest and most important algorithms in mathematics. It computes the greatest common divisor of two integers using repeated division.

Functional Equation

The defining series of the zeta function,

Global Class Field Theory

One of the central goals of algebraic number theory is to classify field extensions of a number field

Lattice Reduction

A lattice is a discrete additive subgroup of Euclidean space. More concretely, let

Suggested Projects and Explorations

Study empirical properties of prime numbers through computation.

Least Common Multiples

Let $a$ and $b$ be nonzero integers. An integer $m$ is called a common multiple of $a$ and $b$ if

Computational Aspects

Quadratic residue theory is not only a theoretical subject. It also plays a major role in computational number theory, cryptography, primality testing, and algorithm design.

Analytic Continuation

The defining series of the Riemann zeta function is

Local Class Field Theory

Global class field theory studies finite abelian extensions of number fields such as

Integer Factorization

Integer factorization asks for the prime decomposition of a positive integer. Given

Problem Sets

1. Prove that the sum of two even integers is even.

Important Builtins in Zig 1.16

This chapter covered the builtins you will see most often as a beginner.

Greatest Common Divisors

Let $a$ and $b$ be integers, not both zero. An integer $d$ is called a common divisor of $a$ and $b$ if

Higher Reciprocity Laws

Quadratic reciprocity describes when one prime is a square modulo another prime. A natural question is whether similar laws exist for higher powers.

Euler Product Formula

The defining series of the Riemann zeta function is

Hilbert Class Fields

One of the central discoveries of algebraic number theory is that unique factorization may fail in rings of algebraic integers.

Primality Testing

A prime number is an integer greater than $1$ whose only positive divisors are

Chronology of Number Theory

| Period | Development |

`@embedFile`

@embedFile reads a file at compile time and embeds its bytes into the final program.

Logging

Logging means recording what a program is doing.

Chapter 15. Graph Isomorphism

The Division Algorithm

The division algorithm is one of the basic structural facts about the integers. It says that any integer can be divided by a positive integer with a unique quotient and remainder.

Gauss Sums

Gauss sums arise from combining multiplicative and additive structures modulo a prime. They form one of the fundamental tools of analytic and algebraic number theory.

Definition of the Zeta Function

One of the central objects of analytic number theory is the Riemann zeta function. It connects infinite series, prime numbers, complex analysis, and arithmetic structure into...

Reciprocity Maps

One of the oldest themes in number theory is reciprocity: the phenomenon that solvability conditions for one prime are controlled by arithmetic involving another prime.

Fast Integer Arithmetic

Modern computational number theory depends fundamentally on efficient arithmetic with large integers.

Index of Definitions

| Definition | Location |

`@compileError`

@compileError stops compilation with a custom error message.

Networking APIs

Networking means communicating with another program through a network.

Chapter 14. Cofactors and Adjugates

Composite Numbers

A positive integer $n>1$ is called composite if it is not prime.

Quadratic Reciprocity

The theory of quadratic residues asks a fundamental question:

Twin Prime Heuristics

A pair of primes

Abelian Extensions

A central goal of algebraic number theory is to understand field extensions of a given base field, especially extensions of the rational numbers

Trace Formula

One of the central ideas of modern analysis is that functions may be decomposed spectrally into elementary pieces.

Index of Theorems

| Theorem | Location |

`@panic`

@panic stops the program immediately with a message.

HTTP Client

An HTTP client is code that sends a request to a web server and reads the response.

Prime Numbers

Prime numbers are the fundamental building blocks of arithmetic.

Euler Criterion

Euler criterion gives an efficient way to decide whether an integer is a square modulo an odd prime. Let $p$ be an odd prime and let $a$ be an integer not divisible by $p$....

Prime Gaps

Let

Adeles and Ideles

The rational numbers may be studied through their completions:

Functoriality

Functoriality is the unifying mechanism of the Langlands program. It predicts systematic relationships between automorphic representations attached to different algebraic groups.

Notation Index

| Symbol | Meaning |

Reserved Keywords

A keyword is a word that has special meaning in Zig.

Volatile and Atomic Memory

Most memory in Zig is ordinary memory.

`@floatCast`

@floatCast converts one floating-point value to another floating-point type.

JSON Support

JSON is a text format for storing structured data.

Conclusion

You now know the core ideas behind Zig.

Divisibility Relations

Division of integers does not always produce an integer. For example,

Jacobi Symbol

The Legendre symbol

Short Intervals

The Prime Number Theorem describes the average distribution of primes up to a large number $x$:

Local-Global Principles

A central problem in number theory is determining whether an equation possesses rational or integral solutions.

Langlands Program

The Langlands program is a broad collection of conjectures connecting number theory, representation theory, harmonic analysis, and algebraic geometry. Its central idea is that...

Glossary

A group $G$ is abelian if

Reading Zig Error Messages

Sooner or later, every Zig beginner meets the compiler.

Naming Conventions

Names are part of the program.

Zig Generics Use `comptime`

A generic function is a function that works with many types instead of only one type.

Memory Safety in Zig

Memory safety means using memory only while it is valid, only through the right type, and only inside the allowed range.

`@truncate`

@truncate converts an integer to a smaller integer type by keeping only the low bits.

Compression

Compression means making data smaller.

Build System Changes in Zig 0.16

Zig changes quickly before 1.0. That includes the build system.

Appendix J. Migrating Between Zig Versions

Zig is still before 1.0, so the language and standard library can change between releases. Code written for one Zig version may not compile on another version without edits.

Appendix A. Zig 1.16 New Features

Zig has not reached 1.0 yet. The current release line discussed in this book is Zig 0.16, not Zig 1.16.

Appendix A. Zig 1.16 New Features

As of the current public Zig release line, the version is Zig 0.16, not Zig 1.16. Zig has not reached 1.0 yet. In this appendix, read “Zig 1.16” as “Zig 0.16” unless...

Tangent Propagation

Forward mode automatic differentiation computes derivatives by propagating tangent values alongside ordinary values. The ordinary value is called the primal. The derivative...

Case Studies

This section studies reverse mode automatic differentiation through concrete examples. Each case has the same structure:

Ahead-of-Time vs Just-in-Time Differentiation

Automatic differentiation can be performed before a program runs, while it runs, or in a staged phase between the two.

Effect Systems and Mutation

Automatic differentiation is easiest to define for pure functions. A pure function behaves like a mathematical mapping: it consumes inputs, produces outputs, and has no...

Physics-Informed Models

Physics-informed models combine data fitting with equations from physics or applied mathematics. The model is trained not only to match observed samples, but also to satisfy...

Unified Differentiable Infrastructure

Automatic differentiation began as a numerical technique for computing gradients of scalar functions.

Production Deployment

A minimal automatic differentiation engine can compute correct gradients on small programs. A production system must survive long-running workloads, large tensors, distributed...

Differentiation of Large Stateful Systems

Automatic differentiation works naturally on pure mathematical functions:

Differentiation of Large Stateful Systems

Automatic differentiation works naturally on pure mathematical functions:

Historical Development of Number Systems

The idea of number arose long before formal mathematics. Early civilizations used numbers for counting objects, measuring land, recording trade, and tracking time.

Legendre Symbol

Let $p$ be an odd prime and let $a\in\mathbb{Z}$. The Legendre symbol is defined by

Error Terms

The Prime Number Theorem states that

Hensel’s Lemma

One of the central ideas of number theory is that congruences modulo powers of a prime often approximate genuine arithmetic solutions.

Adelic Methods

Number theory studies arithmetic simultaneously at two levels:

Appendix J. Historical Notes and Bibliography

Number theory is one of the oldest parts of mathematics, but modern number theory is not a single ancient subject carried forward unchanged. It is a layered discipline....

Editors, LSP, and Debuggers

You can write Zig code in any text editor.

Comments and Documentation

Comments are notes for humans who read the code.

Compile Errors as Safety Checks

A compile error means Zig refused to build your program.

What “Exported” Means

An exported function is a function made visible outside the current Zig program.

Panic and Crash Behavior

Errors are for expected failures.

Dangling Pointers

A dangling pointer is a pointer that refers to memory that is no longer valid.

Efficient Text Processing

Efficient text processing means working with text without doing unnecessary allocation, copying, or decoding.

Data-Oriented Design

Data-oriented design means you organize a program around the data it processes.

When Not to Use `comptime`

comptime is one of Zig’s strongest features, but it should not be used everywhere.

`@intCast`

@intCast converts one integer value to another integer type.

Building Allocation-Friendly APIs

An allocation-friendly API makes memory behavior clear to the caller.

Appendix I. Zig Coding Style Guide

Zig code should be explicit, simple, and easy to inspect. The goal is not cleverness. The goal is code that another programmer can read, verify, and maintain.

Start with the Operations

A data structure is never just a container.

Process Management

A process is a running program.

Packaging Applications

Packaging means preparing your program so another person can download it, install it, and run it.

Benchmarking Code

Benchmarking measures how fast code runs.

Wrapping Existing Libraries

Wrapping a C library means building a Zig layer around it.

Writing a Small Shell

A shell is a program that reads commands and runs other programs.

High Performance Concurrent Design

High performance concurrent design means using several threads or tasks without making the program slower, more fragile, or harder to reason about.

Case Study 1: Reusing a Temporary Buffer

Performance ideas become clearer when you see them inside real code.

Following Zig Development

Zig changes quickly because it is still moving toward 1.0.

Understanding Zig IR

IR means intermediate representation.

Build a Mini Git Clone

Git stores snapshots of files.

Appendix A. Zig Syntax Summary

This appendix summarizes the core syntax of Zig 0.16. It is a compact reference, not a tutorial.

Chapter 10. Trees

Summary and Synthesis

Automatic differentiation is a method for computing derivatives by transforming programs into derivative-propagating computations. It does not approximate derivatives...

Case Studies

Forward mode automatic differentiation appears in many numerical systems where directional derivatives, local sensitivities, or small parameter sets are important. This...

Reverse Mode in Deep Learning

Reverse mode automatic differentiation is the mathematical and systems basis of backpropagation. In deep learning, the objective is usually a scalar loss depending on many...

Differential Lambda Calculus

Automatic differentiation is deeply connected to functional programming and lambda calculus. Programs can be viewed as mathematical functions, and differentiation can be...

Complexity of Higher Orders

Higher-order automatic differentiation faces a fundamental problem: derivative structure grows combinatorially with order.

GPU Tensor Kernels

Modern automatic differentiation systems are fundamentally tensor compiler systems. Their performance depends less on mathematical differentiation rules than on how...

Kernel Fusion

Kernel fusion combines several small operations into one larger executable unit.

Type Systems for Differentiation

Automatic differentiation interacts deeply with type systems because differentiation changes the structure of computation. A derivative operator maps one function into another...

Reinforcement Learning

Reinforcement learning studies learning systems that act in an environment. Unlike supervised learning, the training signal is not a target label for each input. The model...

Probabilistic Programming

Probabilistic programming represents uncertainty using executable probabilistic models. A probabilistic program defines a distribution rather than only a deterministic computation.

Summary

Differentiable systems architecture extends automatic differentiation beyond isolated functions and neural network layers. The central idea is to treat larger systems as...

Distributed Gradient Computation

Distributed gradient computation appears when a differentiable program no longer fits comfortably on one device or one machine. The reason may be model size, data volume,...

Verified Differentiation

Automatic differentiation systems are usually trusted because they implement mathematically established rules such as the chain rule, product rule, and linearization of...

Differentiation as Functorial Transformation

The preceding sections described automatic differentiation through algebraic, categorical, logical, and denotational models. These viewpoints converge on one central idea:

Testing Derivatives

An automatic differentiation engine is only useful if its derivatives are correct. A small mistake in a backward rule can silently corrupt optimization, training, or...

Comparative Architecture Analysis

The systems in this chapter show that automatic differentiation is not one implementation technique. It is a family of program transformations. Each system chooses a different...

Comparative Architecture Analysis

The systems in this chapter show that automatic differentiation is not one implementation technique. It is a family of program transformations. Each system chooses a different...

Growth of Integers

The integers extend infinitely in both directions:

Squares Modulo $n$

A quadratic congruence is a congruence involving a square. The basic form is

Logarithmic Integral

The logarithmic integral is the function

Completion of Fields

The rational numbers form a field rich enough for arithmetic, yet insufficient for many limiting processes.

Automorphic Representations

Classically, number theory studied special analytic functions such as modular forms. These functions satisfy strong symmetry conditions under actions of arithmetic groups.

Appendix I. Computational Tools

Computation has become an essential part of number theory. Classical arithmetic relied mainly on symbolic reasoning and hand calculations. Modern arithmetic combines rigorous...

Project Structure

So far, we have used single-file programs.

Strings and UTF-8

A string is text.

Unreachable Code

Some parts of a program should never run.

A Mental Model

A calling convention defines how functions communicate at the machine level.

Custom Error Types

Most Zig programs start with small error sets:

Stack vs Heap

Zig programs use memory in different places. The two most important places are the stack and the heap.

Building Dynamic Strings

A dynamic string is text whose length is not fixed ahead of time.

Modeling State Machines

A state machine is a simple way to describe a program that moves between fixed states.

Type Reflection Basics

Type reflection means asking questions about a type while Zig is compiling the program.

Metaprogramming Patterns

Metaprogramming means writing code that helps create, inspect, or specialize other code.

`@memcpy`

@memcpy copies bytes from one memory region to another.

Lifetime Management

Memory lifetime means:

Appendix H. Useful Open Source Zig Projects

This appendix lists useful Zig projects to read after you know the basics.

Memory Debugging

Memory debugging means finding mistakes in how a program uses memory.

Contributing to Zig

Contributing to Zig means helping the language, compiler, standard library, documentation, tests, or tooling improve.

Start with the Rule

A collection is a type that stores many values.

Exercises

This chapter introduced the basic forms of values and declarations: names, constants, variables, integer types, floating-point types, booleans, bytes, inferred types, and...

Environment Variables

An environment variable is a named value provided to a program by the operating system.

Installing Binaries

A build does not only compile files. It can also install the results into a predictable output directory.

Working with Headers

C headers are the bridge between Zig and C.

Writing a CLI Tool

A CLI tool is a command-line program.

The Basic Idea

An abstraction is a way to hide detail behind a simpler interface.

Self-Hosted Zig Compiler

A self-hosted compiler is a compiler written in the language it compiles.

Packaging Cross-Platform Apps

Packaging means preparing your program so other people can download it, install it, run it, and trust what they are running.

Data Races

A data race happens when two threads access the same memory at the same time, at least one access writes, and there is no proper synchronization.

Build a Simple Game Engine

A game engine is a program structure for running interactive simulations.

Exercises

This section collects the exercises for Chapter 14.

Exercises

These exercises use the material from Chapters 15.1 through 15.8. Most are small. The goal is to practice reading and writing build.zig files until the structure becomes familiar.

A Parallel File Scanner

This section combines the ideas from the previous sections into one program structure.

Where to Go From Here

The programs in this chapter are small, but they have the shape of larger Zig programs.

Differentiable Subprograms

A differentiable subprogram is a program fragment that can participate in derivative propagation as a coherent unit. Instead of differentiating an entire application...

AD as Program Transformation

Automatic differentiation can be understood as a transformation from one program into another program.

Sparse Forward Methods

Many real-world Jacobians are sparse. Most derivative entries are zero because outputs depend only on small subsets of inputs.

Checkpointing

Checkpointing is a technique for reducing the memory cost of reverse mode automatic differentiation by selectively storing intermediate states and recomputing missing values...

Differential Lambda Calculus

Automatic differentiation is deeply connected to functional programming and lambda calculus. Programs can be viewed as mathematical functions, and differentiation can be...

Perturbation Confusion

Perturbation confusion is a correctness bug that appears in nested automatic differentiation, especially nested forward mode. It happens when two derivative computations...

Exception Handling and Undefined Regions

Programs do not only branch between valid computations. They also fail, stop early, raise exceptions, return sentinel values, or enter undefined numerical regions. These...

Sparse Tensor Derivatives

Most real computational problems are sparse. Large matrices and tensors often contain mostly zeros, structured blocks, or local interactions. Sparse representations reduce...

Memory Planning

Memory planning determines where values are stored, how long they remain alive, and when storage can be reused.

AD in Swift

Swift became an important experiment in language-integrated automatic differentiation because it attempted to make differentiation a core compiler feature rather than a...

Meta-Learning

Meta-learning studies systems that improve how they learn. Instead of only optimizing model parameters for one task, a meta-learning method optimizes some part of the learning...

Robotics and Control

Robotics and control systems interact with the physical world through sensing, estimation, planning, and actuation. Automatic differentiation is important because modern...

Hybrid Symbolic-Numeric Systems

A hybrid symbolic-numeric system combines discrete symbolic reasoning with continuous numerical computation. In the context of automatic differentiation, it means a pipeline...

GPU and TPU Execution

Modern automatic differentiation systems are built around accelerator hardware. GPUs and TPUs provide enormous throughput for tensor operations, making large-scale...

Differentiable Programming Languages

Automatic differentiation began as a transformation applied to numerical programs. A differentiable programming language instead treats differentiation as a native semantic...

Denotational Models

Operational semantics explains how automatic differentiation executes. Denotational semantics explains what differentiable programs mean.

Performance Benchmarking

Performance benchmarking measures whether an automatic differentiation engine is fast, memory-efficient, and scalable under realistic workloads. It also protects the engine...

Tinygrad

Tinygrad is a small deep learning framework centered around a minimal reverse-mode automatic differentiation engine. It was created by entity"people","George...

Tinygrad

Tinygrad is a small deep learning framework centered around a minimal reverse-mode automatic differentiation engine. It was created by entity"people","George...

Taylor Expansions

Differentiation describes how a function changes locally. A Taylor expansion extends this idea by approximating a function with a polynomial around a point.

Recursive Definitions

Many mathematical objects are defined recursively. A recursive definition specifies:

Geometry of Diophantine Problems

A Diophantine equation is first an arithmetic object. It asks for solutions in integers or rational numbers. But every polynomial equation also defines a geometric object.

Prime Number Theorem

The Prime Number Theorem describes the asymptotic distribution of prime numbers. It states that

Appendix H. Category Theory Basics

Category theory studies mathematical structures through objects and maps between them. Instead of looking only at what objects are made of, it studies how they relate to other...

$p$-Adic Numbers

The real numbers arise by completing the rational numbers with respect to the ordinary absolute value. This completion produces a field suited to Euclidean geometry and...

Representation Theory Background

Representation theory studies abstract algebraic objects by expressing them as linear transformations of vector spaces.

Zig Compiler as a Toolchain

When beginners hear the word “compiler,” they often think of one job:

Zero Values and Initialization

Initialization means giving a value to something when it is created.

Defer and Cleanup

Many programs need to clean something up after using it.

A Simple Function

An inline function is a function where the compiler may place the function’s code directly at the call site instead of performing a normal function call.

Designing Error APIs

An error API is the part of your function signature that tells callers how failure works.

Sentinel-Terminated Arrays

A sentinel-terminated array is an array with a special value at the end.

UTF-8 Processing

Zig string data is usually stored as UTF-8 bytes.

Union Safety

A union stores one active field at a time.

Type Coercion

Type coercion means Zig converts a value from one type to another when the conversion is safe and well-defined.

Static Dispatch

Static dispatch means the compiler decides which code to call before the program runs.

`@bitCast`

@bitCast reinterprets the bits of one value as another type.

Memory Leak Detection

A memory leak happens when a program allocates memory and then loses the ability to free it.

Appendix G. C Interop Reference

Zig is designed to work closely with C. You can call C from Zig, call Zig from C, compile C code with Zig, and link Zig programs against existing C libraries.

Why Trees Matter

A tree is a collection made of nodes.

Using GDB and LLDB

GDB and LLDB are debuggers.

Open Issues and RFCs

A programming language is never only its syntax.

Running Tests

Zig has built-in support for tests.

ABI Compatibility

ABI means Application Binary Interface.

Writing a TCP Server

A TCP server is a program that waits for clients to connect.

Benchmark the Right Thing

Benchmarking means measuring how fast code runs.

Writing a Compiler in Zig

A compiler translates one form of code into another form.

Handling Platform Differences

A cross-platform Zig program should not pretend that every operating system behaves the same way. Windows, Linux, macOS, WebAssembly, and embedded targets have different...

Explicit Casts

Zig does not perform most numeric conversions automatically.

Random Number Generation

Random numbers are used when a program needs variation.

Exercises

This section collects the exercises for the chapter. They are meant to be small programs. Each one should compile and run.

Exercises

1. Write a function increment that takes i32 and adds 1 to the pointed-to value.

Channels and Queues

A queue is a data structure for passing work from one part of a program to another.

Build a Bytecode VM

A bytecode VM is a small machine inside your program.

Exercises

These exercises close the chapter on structs, enums, and unions. They are meant to make the data model concrete.

Exercises

1. Write a function parseUpper that accepts a byte and returns the uppercase letter value. Return error.InvalidUppercase if the byte is not between 'A' and 'Z'.

Exercises

The exercises in this section are meant to make allocation habits precise. Each one should be written as a complete program unless stated otherwise.

Exercises

This section collects the exercises for the chapter.

Testing Utilities

Zig has built-in support for tests.

Cross Builds

Zig can build for a different target than the machine running the compiler.

Designing Concurrent Programs

Threads are a mechanism, not a design.

Exercises

Exercise 19-1. Write a program that overflows a u8 using +=. Run it in Debug mode and observe the panic.

demo

A program is finished only when another machine can build and run it reliably.

Applications Across Science and Engineering

Automatic differentiation became important because derivatives are required everywhere numerical models are optimized, controlled, calibrated, or analyzed. Once a system can...

Dual Spaces and Pushforwards

Forward mode and reverse mode propagate different kinds of objects.

Purity and Side Effects

A pure computation is easier to differentiate because every output is determined only by its explicit inputs. There is no hidden state, no external mutation, and no dependence...

Numerical Exactness up to Floating Point

Automatic differentiation computes derivatives exactly with respect to the executed floating point program. This distinguishes AD from numerical differentiation, which...

Efficient Seeding Strategies

Forward mode automatic differentiation computes Jacobian-vector products:

Memory-Time Tradeoffs

Reverse mode automatic differentiation is computationally efficient for scalar-output functions, but it has a major systems cost: it needs information from the forward pass...

Category-Theoretic View

Automatic differentiation can be described operationally through dual numbers and computational graphs. It can also be described abstractly using category theory.

Efficient Higher-Order Methods

Higher-order derivatives contain rich geometric information, but naïve computation quickly becomes impractical.

Differentiating Stateful Systems

A stateful system is a program whose output depends not only on its explicit inputs, but also on stored state. The state may live in variables, objects, arrays, files, random...

Singular Value Decomposition

The singular value decomposition SVD is one of the most important matrix factorizations in numerical linear algebra. It appears in dimensionality reduction, least squares,...

Staging and Partial Evaluation

Staging is the separation of a program into phases.

AD in Julia

Julia was designed for high-performance technical computing. It combines interactive syntax with a compiler capable of specializing code aggressively based on types. This...

Implicit Layers

An implicit layer defines its output as the solution of an equation, not as a fixed sequence of explicit operations. Instead of computing

Signal Processing

Signal processing studies how information is represented, transformed, filtered, compressed, reconstructed, and estimated from signals. A signal may be a time series, an...

Differentiable Operating Systems

A differentiable operating system is an execution environment whose resource-management decisions can be optimized using gradients or gradient-like feedback. Instead of...

Parallelism

Automatic differentiation is usually described as a transformation of programs or computational graphs. In real systems, it is also a parallel execution problem. Large...

Quantum Differentiation

Quantum computation introduces a computational model fundamentally different from classical programs.

Formal Verification

Automatic differentiation systems are trusted infrastructure. Scientific computing, machine learning, optimization, simulation, and control systems depend on gradients being...

Custom Gradients

A custom gradient gives the user direct control over the backward rule of an operation. The forward computation still produces an ordinary value, but the derivative no longer...

Enzyme

Enzyme is a compiler-based automatic differentiation system for LLVM and MLIR. Instead of differentiating source code directly, or recording tensor operations at runtime,...

Enzyme

Enzyme is a compiler-based automatic differentiation system for LLVM and MLIR. Instead of differentiating source code directly, or recording tensor operations at runtime,...

Strong Induction

Ordinary induction proves a statement $Pn$ by showing that truth passes from one case to the next:

Rational and Integral Points

A central problem in number theory is to study solutions of polynomial equations whose coordinates belong to a specified number system. Two important cases are:

Chebyshev Bounds

The prime counting function

Appendix G. Linear Algebra Review

A vector space over a field $F$ is a set $V$ equipped with addition and scalar multiplication satisfying the usual algebraic rules.

Absolute Values

The ordinary absolute value on the real numbers measures magnitude:

Weil Conjectures

One of the central problems in arithmetic geometry is understanding the number of solutions of polynomial equations over finite fields.

Understanding `zig build-exe`

In the previous section, we used this command:

Undefined Values

In Zig, undefined means “this value has not been initialized.”

Inline Loops

Zig has normal loops that run when the program runs.

What Anonymous Functions Usually Mean

An anonymous function is a function without a permanent name.

Propagating Errors

Propagating an error means passing it to the caller instead of handling it immediately.

Alignment

Alignment is a rule about where a value may be placed in memory.

Mutable Strings

Zig does not have a separate built-in mutable String type.

Tagged Unions

A tagged union is a type that can store one value from several possible shapes.

Error Union Internals

An error union is a value that can contain either:

Building Generic Data Structures

A generic data structure is a data structure that works with more than one element type.

`@ptrCast`

@ptrCast converts one pointer type into another pointer type.

Allocation Failure Handling

Allocation can fail.

Appendix F. Build Modes Reference

When Zig compiles a program, it can build the program in different modes.

The Core Idea

A ring buffer is a fixed-size queue that reuses its storage.

Assertions

An assertion is a check that must be true while the program runs.

LLVM Integration

LLVM is a compiler infrastructure project.

Release Modes

Zig can build the same program in different optimization modes.

Exporting Zig to C

Zig can call C, but C can also call Zig.

Network Protocols

A network protocol is a rulebook for how programs talk over a network.

Why Branch Prediction Exists

Branch prediction is a CPU optimization.

Writing a Virtual Machine

A virtual machine is a program that runs another program.

Portable APIs

A portable API is an interface that works across more than one platform.

Time and Timers

Programs often need to work with time.

Event Loops

An event loop is code that waits for events, then runs the right piece of work for each event.

Build a Programming Language Lexer

A lexer is the first stage of many programming language tools.

Type Inference

A declaration may name its type explicitly.

`defer`

defer runs a statement when control leaves the current block.

Exercises

1. Write a function max3 that returns the largest of three integers.

Lifetimes

A pointer is useful only while the value it points to still exists.

Exercises

This section closes the chapter. The exercises are small programs. Write them by hand. Compile them. Change them. Run them again.

Data Layout

A struct is not only a list of fields. It also has a layout in memory.

Designing Error Boundaries

Most functions should not decide what an error means.

Exercises

1. Write a program that computes several Fibonacci numbers with comptime. Print the results at runtime.

Ownership Rules

Allocation creates a responsibility.

Zig 0.16 I/O Changes

Zig 0.16 changes how I/O code is written in the standard library.

Process APIs

The standard library gives access to process information through std.process.

Dependencies

A Zig package may depend on another package.

Exercises

Exercise 16-1. Write a C file containing this function:

Exercises

This section collects the chapter exercises into one working set.

Semaphores

A semaphore is a counter used for synchronization.

FFI Safety

FFI means foreign function interface. It is the boundary where Zig calls code written in another language, or where another language calls Zig.

Benchmarking

A benchmark measures the cost of a program or operation. The result is useful only if the measurement is repeatable and the work being measured is clearly defined.

7. The Python Object Model

How every value in Python is a heap-allocated object, and the role of type objects in defining behavior.

LeetCode 6: Zigzag Conversion

A detailed explanation of converting a string into a zigzag pattern using row simulation.

Historical Development

Automatic differentiation developed from a simple observation: a numerical computation already contains the structure needed to compute its derivative. The program evaluates...

Linearization

Linearization is the operation of replacing a nonlinear function by its best local linear approximation at a chosen point. Automatic differentiation can be understood as a...

Memory and State

Automatic differentiation operates on computations, but computations execute inside a memory model. Variables occupy storage locations, arrays are mutated, buffers are reused,...

Computational Complexity

Automatic differentiation is fundamentally a computational technique. Its practical importance comes from the fact that derivatives can often be computed with asymptotic cost...

Higher-Dimensional Tangent Spaces

So far, forward mode has propagated a single tangent direction:

Wengert Lists

A Wengert list is a linear representation of a computation in which every intermediate result is assigned to a unique variable. It is one of the earliest and most influential...

Differential Algebras

Dual numbers and hyper-dual numbers are special cases of a broader algebraic structure called a differential algebra. This framework abstracts differentiation away from...

Taylor Mode AD

Taylor mode automatic differentiation computes derivatives by propagating truncated Taylor series through a program.

Non-Smooth Programs

A non-smooth program contains operations where the derivative is undefined, discontinuous, set-valued, or unstable under small perturbations. These programs arise naturally in...

Eigenvalue Problems

Eigenvalue problems are fundamental in numerical analysis, optimization, physics, graph methods, control theory, and machine learning. They are also among the most subtle...

Tracing Systems

Tracing is an implementation strategy where an AD system observes a program while it runs and records the operations that occur.

AD in Rust

Rust is an attractive language for automatic differentiation because it combines low-level performance with strong static guarantees. It gives the programmer control over...

Attention Mechanisms

Attention is a sequence operation that lets each position read information from other positions. Instead of compressing the whole past into one recurrent hidden state,...

Computational Finance

Computational finance uses numerical models to price contracts, measure risk, and optimize portfolios. Automatic differentiation is useful because most financial computations...

Differentiable Compilers

A differentiable compiler is a compilation system that supports gradient propagation through compilation decisions, generated programs, or execution behavior. Instead of...

Determinism and Reproducibility

Automatic differentiation systems are often assumed to be deterministic. Given identical inputs, identical parameters, and identical code, many users expect identical...

Probabilistic Automatic Differentiation

Classical automatic differentiation computes derivatives of deterministic programs.

Program Equivalence

Automatic differentiation transforms programs. A fundamental semantic question therefore arises:

Operator Libraries

An automatic differentiation engine becomes useful only after it supports a sufficiently rich set of primitive operations. The collection of these primitives is the operator...

Zygote

Zygote is a source-to-source reverse-mode automatic differentiation system for the Julia programming language. It was designed to differentiate high-level Julia code directly,...

Zygote

Zygote is a source-to-source reverse-mode automatic differentiation system for the Julia programming language. It was designed to differentiate high-level Julia code directly,...

Mathematical Induction

Many statements in number theory concern all natural numbers. For example, one may wish to prove that

Exponential Diophantine Equations

An exponential Diophantine equation is a Diophantine equation in which one or more unknowns appear as exponents. Typical examples include

Prime Counting Function

One of the oldest questions in number theory asks how prime numbers are distributed among the positive integers. Since primes become less frequent as numbers grow larger,...

Appendix F. Measure and Integration

Measure theory extends the ideas of length, area, volume, and integration to more general settings. In number theory, measure appears in probability, harmonic analysis,...

Ramification

One of the central ideas of algebraic number theory is that prime numbers may behave differently after passing to a larger field.

Étale Cohomology

Classical topology studies geometric spaces using invariants such as homology and cohomology. Over the complex numbers, algebraic varieties can often be viewed as topological...

Your First Zig Program

Now we will write and run a complete Zig program.

Type Inference

Type inference means Zig can figure out a type from the value you write.

`break` and `continue`

Loops repeat code. But sometimes you do not want a loop to finish in the normal way.

A First Example

Functions are values.

`errdefer`

errdefer is a cleanup tool.

Pointer Arithmetic

Pointer arithmetic means moving a pointer forward or backward through memory.

String Literals

A string literal is text written directly in your source code.

Enums

An enum is a type whose value must be one item from a fixed list.

`anytype`

anytype means the function parameter can accept many different types.

Reflection with `@typeInfo`

Reflection means inspecting a type as data.

`@typeInfo`

@typeInfo asks the compiler for structured information about a type.

Custom Allocators

A custom allocator is an allocator you design for a specific memory policy.

Appendix E. Memory Safety Checklist

Zig gives you direct control over memory. That control is useful, but it also means you must follow clear rules.

Why Bit Sets Matter

A bit set is a compact collection of yes-or-no values.

Stack Traces

A stack trace shows how your program reached a failure.

Code Generation

Code generation is the compiler stage that turns analyzed program meaning into target code.

Static and Dynamic Linking

Linking is the step where the compiler connects your program with the code it depends on.

Building Mixed Zig and C Projects

A mixed Zig and C project contains source files from both languages.

Endianness

Endianness means the order used to store the bytes of a multi-byte value.

Small Values Are Fine to Copy

Copying data is sometimes necessary, but unnecessary copying is one of the easiest ways to waste time and memory.

Writing a Parser

A parser reads text and turns it into structure.

Cross-Target Debugging

Cross-target debugging means debugging a program built for a different machine, operating system, or CPU architecture than the one you are sitting at.

Parsing Numbers and Text

Parsing means turning text into data.

Await and Suspension

await means: wait until an asynchronous operation has finished, then continue with its result.

Build a Small Database

A database stores data so it can be saved, searched, updated, and loaded again later.

Characters and Bytes

Zig does not have a separate character type for ordinary strings.

`break`, `continue`, and Labels

break leaves a loop.

Organizing a Small Program

A program grows gradually.

Alignment

Memory has addresses. Types also have alignment.

UTF-8 Handling

Zig strings are bytes. UTF-8 is one way to interpret those bytes as text.

Packed Structs

A normal struct is laid out for ordinary program use. The compiler may add padding between fields so that each field has a suitable address.

`defer` and `errdefer`

A program that opens a file must close it. A program that allocates memory must free it. A program that locks a mutex must unlock it.

Exercises

Exercise 9-17. Declare an optional integer.

Generating Declarations

A Zig function can return a type.

Exercises

Exercise 11-1. Write a generic min function for values that support <.

Fixed-Buffer Allocator

A fixed-buffer allocator uses memory that already exists.

Error Handling in I/O

Input and output can fail.

Filesystem APIs

The standard library gives access to files and directories through std.fs.

Examples

Examples are small programs kept inside the project.

ABI and Layout

A C program and a Zig program can share data only when both sides agree on layout.

Release Modes

Zig can build the same source code in different optimization modes.

Thread Pools

Creating a thread is expensive.

Packed Memory

A normal struct is laid out for efficient access.

Testing Strategy

Tests should be close to the code they check. Zig makes this easy with test blocks.

LeetCode 5: Longest Palindromic Substring

A detailed explanation of finding the longest palindromic substring using expand-around-center.

Accuracy, Complexity, and Stability

Derivative computation is not only a mathematical problem. It is also a numerical and systems problem. A derivative method must answer three questions simultaneously:

Computational Graphs

A computational graph represents a calculation as nodes and edges. Nodes represent operations or values. Edges represent data dependencies. Automatic differentiation uses this...

Loops and Recurrence Relations

Loops express repeated computation. Recurrence relations express the same idea mathematically: each state is computed from one or more earlier states.

Mixed-Mode Differentiation

Mixed-mode differentiation combines forward accumulation and reverse accumulation in the same derivative computation. It is used when neither pure forward mode nor pure...

Complexity Analysis

Forward mode automatic differentiation has a simple cost model. It evaluates the original program and, at the same time, evaluates the tangent program. Each primitive...

Tape-Based Systems

Most reverse mode automatic differentiation systems require a mechanism for recording the forward computation so that the reverse pass can later traverse it backward. This...

Hyper-Dual Numbers

Dual numbers compute first derivatives exactly. Truncated polynomial algebras extend this to higher-order derivatives, but practical higher-order differentiation introduces an...

Nested AD

Nested automatic differentiation means applying automatic differentiation inside another automatic differentiation computation.

Piecewise Differentiability

A piecewise differentiable function is built from several differentiable pieces joined by boundaries. Each piece has an ordinary derivative inside its region. At the...

Differentiating Factorizations

Matrix factorizations rewrite a matrix into structured factors. They are used because the factors make later computations cheaper, more stable, or easier to interpret. In...

Graph IRs

A graph intermediate representation models a program as nodes and edges.

AD in Python

Python became the dominant language for modern machine learning and differentiable computing because it combines a simple programming model with access to high-performance...

Sequence Models

Sequence models process ordered data. The input is not one independent vector, but a series:

Molecular Simulation

Molecular simulation models the behavior of atoms and molecules using physical interaction laws. Automatic differentiation is important because many molecular methods require...

Differentiable Search and Retrieval

Differentiable search and retrieval systems integrate information access into gradient-based learning. Instead of treating retrieval as an external symbolic operation, the...

Gradient Vanishing and Explosion

Gradient-based optimization relies on propagating derivative information through many layers, time steps, or computational transformations. In deep systems, these gradients...

Neural ODEs

Classical neural networks apply a finite sequence of transformations:

Lambda Calculus and AD

Automatic differentiation becomes substantially more difficult once programs contain higher-order functions.

Memory Management

Memory management is the main systems problem in reverse mode automatic differentiation. The derivative rules are usually small. The hard part is deciding which primal values,...

JAX

JAX is an automatic differentiation and array programming system for Python. It combines NumPy-like syntax with composable program transformations. Its core transformations...

JAX

JAX is an automatic differentiation and array programming system for Python. It combines NumPy-like syntax with composable program transformations. Its core transformations...

Absolute Value and Distance

The order relation distinguishes positive and negative integers, but in many situations the sign of a number is less important than its magnitude. For example, the integers

Catalan-Type Equations

A Catalan-type equation is a Diophantine equation involving powers whose values differ by a small amount. The classical example is

Abel Summation

In analytic number theory, one often studies sums of the form

Appendix E. Topology Background

Topology studies continuity, convergence, connectedness, and geometric structure in an abstract setting. In number theory, topology appears naturally in real analysis, complex...

Cyclotomic Fields

One of the most important classes of number fields arises from the solutions of the equation

Arithmetic Surfaces

Arithmetic geometry often studies families of algebraic curves varying over arithmetic bases. The most important base is

Zig Release Channels and Versioning

Before writing larger Zig programs, you need to understand an important fact:

Booleans and Comparisons

A boolean is a value that can be only one of two things:

Labels and Block Expressions

Zig has blocks.

A First Example

Recursion is a technique where a function calls itself.

`catch`

catch handles an error at the place where it happens.

Slice Lifetimes

A slice is a view into memory.

Optional Pointers

An optional pointer is a pointer that may have no value.

Anonymous Structs

An anonymous struct is a struct type without a name.

Opaque Types

An opaque type is a type whose internal structure is hidden.

Generating Code at Compile Time

Generating code at compile time means using Zig code to create specialized program behavior before the final executable is built.

`@Type`

@Type builds a type from compile-time type information.

Page Allocator

The page allocator asks the operating system for memory directly.

The Basic Difference

Queues and stacks are two simple ways to organize a collection of items.

Appendix D. Important Standard Library APIs

Zig’s standard library is imported with:

Debug Builds

A debug build is a build made for finding mistakes.

Semantic Analysis

Semantic analysis is the compiler stage that checks what a program means.

Cross Compilation

Cross compilation means building a program for a different machine than the one you are using.

Linking C Libraries

Importing a C header lets Zig understand a C API. Linking gives the final program the actual compiled code.

Binary File Formats

A binary file format stores data as bytes with a specific structure.

Why Allocations Cost Time

Allocations are one of the most common causes of slow programs.

Writing a Game Engine Core

A game engine core is the small central layer that runs the game.

ARM and Embedded Targets

ARM is a CPU architecture family used in phones, tablets, laptops, routers, Raspberry Pi boards, microcontrollers, servers, and many embedded devices. When you write Zig for...

Formatting and Printing

Formatting means turning values into text.

Async Functions

Async code lets a program start an operation now and receive the result later.

Build a Memory Allocator

A memory allocator is code that gives memory to the rest of a program.

Booleans

A boolean value is either true or false.

`for` Loops

A for loop visits the elements of an array, slice, or range.

Importing Files

Large programs are divided into smaller files. Zig uses @import to include declarations from another file.

Pointer Arithmetic

Pointer arithmetic means forming a new pointer by moving from one element to another.

Strings Are Bytes

A Zig string is a sequence of bytes.

Tagged Unions

A union is a value that may hold one of several types.

`catch`

catch handles an error union.

Optionals Versus Errors

Optionals and errors both describe a value that may not be produced.

Reflection

Reflection means inspecting a type from inside the program.

Compile-Time Dispatch

Generic functions in Zig are specialized at compile time.

Arena Allocator

An arena allocator is used when many allocations have the same lifetime.

Standard Input and Output

A program usually has three standard streams:

Formatting

Zig uses format strings to turn values into text.

Tests

Zig has tests in the language.

Calling Zig from C

C can call Zig when the Zig function is exported with a C-compatible ABI.

Static and Dynamic Linking

A program is made from object code.

Async Status in Zig 0.16

Zig once had async functions as a language feature.

Volatile Memory

Most memory in a program behaves normally.

A Static Library

A library is code meant to be used by another program. In Zig, a library can be built from the same kind of source files as an executable. The difference is in how the build...

Automatic Differentiation

Automatic differentiation computes derivatives by applying the chain rule to the operations of a program. The input is ordinary code that computes a value. The output is code,...

Chain Rule as Composition Algebra

The chain rule is the central theorem behind automatic differentiation. Every useful AD algorithm is a disciplined way of applying the chain rule to a program.

Control Flow

Control flow determines which operations a program executes. Straight-line programs have a fixed sequence of operations, but ordinary programs contain branches, loops,...

Reverse Accumulation

Reverse accumulation is the reverse-mode form of automatic differentiation. It propagates derivative information backward from outputs to inputs.

Jacobian-Vector Products

The natural output of forward mode automatic differentiation is a Jacobian-vector product. Instead of constructing the full Jacobian matrix explicitly, forward mode computes...

Reverse Accumulation Algorithms

Reverse accumulation is the operational core of reverse mode automatic differentiation. The forward pass evaluates a program and records dependency information. The reverse...

Truncated Polynomial Algebras

Dual numbers capture first-order derivatives because the infinitesimal element satisfies

Higher-Order Reverse Mode

Reverse mode is efficient for scalar-output functions because it propagates one adjoint backward through the computation and produces a full gradient. For

Dynamic Graphs

A dynamic graph is a computation graph built while the program runs. Its structure depends on ordinary runtime values: branches, loop counts, recursive calls, tensor shapes,...

Linear Algebra Primitives

Linear algebra primitives are tensor operations with algebraic structure: matrix multiplication, triangular solves, factorizations, inverses, determinants, norms, and spectral...

SSA Form

Static single assignment form, or SSA, is an intermediate representation where each variable is assigned exactly once.

AD in C and C++

C and C++ are important targets for automatic differentiation because much scientific, engineering, graphics, finance, and machine learning infrastructure is written in these...

Neural Network Training

Neural network training is the repeated application of three operations: evaluate a model, differentiate a scalar loss, and update parameters. Automatic differentiation...

Computational Fluid Dynamics

Computational fluid dynamics studies fluid motion by solving discretized forms of the governing equations. Automatic differentiation enters CFD when we want gradients of...

Differentiable Physics Engines

A differentiable physics engine computes gradients of physical simulation outputs with respect to inputs, parameters, or control signals. Instead of treating simulation as a...

Memory Explosion

Reverse-mode automatic differentiation trades computation for memory. To compute gradients efficiently, the backward pass requires access to intermediate values produced...

Continuous-Time Adjoint Methods

Many systems evolve continuously over time rather than through discrete layers. A state variable changes according to a differential equation:

Differential Categories

Cartesian differential categories model differentiation in categories with products. Differential categories generalize this idea further by shifting attention from cartesian...

Tape Design

A tape is an append-only record of the operations executed during the forward pass. Reverse mode uses the tape to replay derivative rules backward.

PyTorch Autograd

PyTorch Autograd is a dynamic reverse-mode automatic differentiation system. It records tensor operations as they execute, builds a computation graph at runtime, and then...

PyTorch Autograd

PyTorch Autograd is a dynamic reverse-mode automatic differentiation system. It records tensor operations as they execute, builds a computation graph at runtime, and then...

Order Relations

The integers are not merely a collection of numbers equipped with arithmetic operations. They also possess an order structure. Given two integers $a$ and $b$, one can...

Sums of Squares

One of the oldest questions in number theory asks which integers can be written as sums of squares. Typical examples are

Convergence Methods

Analytic number theory studies infinite sums, products, and integrals. Before such expressions can be manipulated safely, one must understand the meaning of convergence.

Appendix D. Real and Complex Analysis Review

The real numbers $\mathbb{R}$ extend the rational numbers $\mathbb{Q}$ by filling gaps such as

Finite Fields

The familiar fields

Curves over Fields

An algebraic curve is a geometric object whose dimension is one. Curves are among the oldest and most important objects in number theory and algebraic geometry.

Installing Zig

Before we write more Zig code, we need the Zig compiler.

Floating Point Numbers

Floating point numbers are numbers with fractional parts.

`for` Loops

A while loop repeats while a condition is true.

Returning a Struct

Many functions need to produce more than one piece of information.

`try`

try is the most common way to handle errors in Zig.

Slices in Detail

A slice is a view into a sequence of values.

Slices

A slice is a view into a sequence of values.

Packed Structs

A normal Zig struct is designed for ordinary data modeling.

Vectors

A vector is a fixed-size group of values of the same type.

How Parsing Works

Parsing is the part of the compiler that reads source code and turns it into structure.

Compile-Time Loops

A compile-time loop is a loop that runs while Zig is compiling your program.

`@alignOf`

@alignOf asks the Zig compiler for the required memory alignment of a type.

Fixed Buffer Allocator

A fixed buffer allocator gives memory from a buffer you already own.

Fuzz Testing

Fuzz testing means testing a program with many generated inputs.

Using C Structs

A C struct groups several fields into one value.

Why Linked Lists Exist

A linked list is a collection where each item points to the next item.

Appendix C. Common Compiler Errors

One of Zig’s strengths is compiler diagnostics. Zig tries to explain problems precisely instead of silently accepting dangerous behavior.

Terminal Programming

Terminal programming means writing programs that interact with the command line as more than simple text output.

Build Options

A build option is a value passed from the command line into build.zig.

Embedded Development

Embedded development means writing software for small computers inside devices.

Why SIMD Matters

SIMD means Single Instruction, Multiple Data.

WebAssembly

WebAssembly, often shortened to Wasm, is a portable binary instruction format. It lets you compile code once and run it inside different hosts, such as web browsers, servers,...

Directories and Paths

A file lives inside a directory.

Condition Variables

A condition variable lets one thread sleep until another thread says that something has changed.

Build a Thread Pool

A thread pool is a group of worker threads that wait for jobs.

Floating-Point Types

Zig has floating-point types for numbers with fractional parts.

`while` Loops

A while loop repeats while a condition is true.

Public Declarations

A Zig program may be split across many files. Declarations can be made visible outside a file with pub.

Slices

A slice is a pointer and a length.

Sentinel Arrays

Some arrays have a special value after the last ordinary element. This value is called a sentinel.

Enums

An enum is a type whose values come from a fixed set of names.

`try`

try is a shortcut for a common operation:

Optional Pointers

Pointers are often optional.

Inline Loops

A normal loop runs while the program runs.

Interfaces by Convention

Zig has no built-in interface keyword.

General-Purpose Allocator

The general-purpose allocator is used for ordinary heap allocation.

Buffered I/O

Reading or writing one byte at a time is expensive.

Hash Maps

A hash map stores key-value pairs.

Build Options

A build option is a value passed to build.zig from the command line.

Linking Libraries

Calling a C function is only half the job. The linker must also find the code for that function.

libc and Freestanding Builds

A Zig target may use a C library, or it may use none.

Condition Variables

A mutex protects shared data.

A Tiny HTTP Client

An HTTP client opens a network connection, sends a request, receives a response, and writes the response body.

Integer Overflow

An integer type can store only a fixed range of values.

Symbolic Differentiation

Symbolic differentiation computes derivatives by manipulating expressions. The input is a formula. The output is another formula.

Jacobians and Hessians

The gradient is enough when a function has many inputs and one scalar output. More general programs need more general derivative objects. Two of the most important are the...

Dependency Graphs

A dependency graph describes how values in a computation depend on earlier values. Automatic differentiation operates on these dependencies.

Forward Accumulation

Forward accumulation is the forward-mode form of automatic differentiation. It propagates derivative information in the same order as ordinary program evaluation. Each...

Forward Evaluation Rules

Forward mode automatic differentiation works by replacing each primitive operation with an extended operation on pairs:

Vector-Jacobian Products

Reverse mode automatic differentiation fundamentally computes vector-Jacobian products. The gradient of a scalar function is a special case of this more general operation.

Geometric Interpretation

Dual numbers provide an algebraic mechanism for differentiation, but they also have a precise geometric meaning. A dual number represents a point together with an...

Hessian-Vector Products

A Hessian-vector product computes

Recursion

Recursion is control flow where a function calls itself. In automatic differentiation, recursion behaves like a loop with a call stack. Each recursive call contributes one...

Broadcasting Semantics

Broadcasting is the rule system that allows tensor operations between arrays of different shapes without explicitly materializing expanded copies. It is one of the most...

Intermediate Representations

An intermediate representation, or IR, is the internal program form used by a compiler or AD system after parsing and before final code generation.

Differentiable Programming

Differentiable programming treats differentiation as a general programming-language feature. A program can contain numerical kernels, control flow, data structures, solvers,...

Backpropagation

Backpropagation is reverse mode automatic differentiation applied to neural networks. In most machine learning writing, the term refers to the whole training procedure: run a...

Inverse Problems

An inverse problem asks for causes from effects. A forward model predicts observations from parameters. An inverse model tries to recover parameters from observations.

Differentiable Rendering

Differentiable rendering is the process of computing derivatives of rendered images with respect to scene parameters. A renderer becomes part of the computational graph rather...

Overflow and Underflow

Floating point systems represent numbers within a finite range. When a computed value exceeds the largest representable magnitude, overflow occurs. When a value becomes too...

Differentiable Optimization Layers

An optimization layer is a program component whose output is the solution of an optimization problem. Instead of computing

Categorical Semantics

Algebraic semantics describes differentiation through derivations, tangent maps, and linear structure. Categorical semantics goes further. It studies differentiation as a...

Graph Representation

A graph representation makes the structure of a differentiated computation explicit. In reverse mode, this structure is required because the backward pass must know which...

TensorFlow Autograd

TensorFlow Autograd refers to TensorFlow’s automatic differentiation system, mainly exposed through tf.GradientTape. It is a reverse-mode AD system designed for tensor...

TensorFlow Autograd

TensorFlow Autograd refers to TensorFlow’s automatic differentiation system, mainly exposed through tf.GradientTape. It is a reverse-mode AD system designed for tensor...

Arithmetic Operations

An arithmetic operation is a rule that combines numbers to produce another number. The most basic operations on integers are addition, subtraction, multiplication, and division.

Pell Equations

A Pell equation is a Diophantine equation of the form

Euler Products

Euler products arise when an infinite series has coefficients controlled by multiplication. The simplest and most important example is the zeta series

Appendix C. Abstract Algebra Review

Abstract algebra studies sets equipped with operations. In number theory, these structures organize arithmetic behavior.

Galois Groups

A polynomial equation may possess several roots related by hidden algebraic symmetries. Consider

Morphisms and Fibers

Geometry is not only concerned with spaces themselves, but also with maps between spaces. In algebraic geometry and arithmetic geometry, these maps are called morphisms.

Why Zig Exists

Zig exists because low-level programming is still important, but the old tools have painful tradeoffs.

Integer Types and Overflow

Integers are whole numbers.

`while` Loops

Programs often need to repeat work.

The `return` Keyword

Functions often need to produce results.

Error Union Types

An error union type means:

Many Item Pointers

A many item pointer is a pointer that can move across several values of the same type.

Multidimensional Arrays

A multidimensional array is an array whose elements are also arrays.

Default Field Values

A struct field can have a default value.

Understanding Stage2

When people talk about Zig compiler internals, they often mention stage2.

Nullable Pointers

A pointer stores the address of a value in memory.

Inline Branching

Inline branching means Zig chooses a branch during compilation, not during runtime.

`@sizeOf`

@sizeOf asks the Zig compiler how many bytes a type needs in memory.

Table-Driven Tests

A table-driven test checks many input cases with one test loop.

Why StringHashMap Exists

A StringHashMap is a hash map where the key is a string.

Arena Allocator

An arena allocator is an allocator that frees many allocations at once.

Calling C Functions

Calling a C function from Zig has three parts.

Appendix B. Zig Cheat Sheet

const std = @import"std";

Working with the OS

Systems programming means working directly with the operating system.

The Basic Idea

Modern CPUs are fast, but memory is much slower.

Plugin Architectures

A plugin architecture lets a program be extended without rewriting the whole program.

Atomics

An atomic operation is a small operation that can safely happen while several threads are running.

Writing Files

Writing a file means sending bytes from your program to the operating system so they can be stored on disk.

macOS Support

macOS is one of Zig’s main desktop targets. You can use Zig on macOS to write command-line tools, development utilities, servers, libraries, and cross-platform applications.

Adding Dependencies

A Zig project can depend on other Zig packages.

Build a Static File Server

A static file server is a program that reads files from a directory and sends them to a browser over HTTP.

Integer Types

Zig has signed and unsigned integer types.

`switch` Expressions

A switch chooses one branch from several alternatives.

Passing Values

When a function is called, values are passed from the caller to the function parameters.

Many-Item Pointers

A many-item pointer points to the first item in a sequence.

Slicing Arrays

A slice is a view into an array.

Methods as Functions

Zig has no class syntax.

Returning Errors

A function returns an error the same way it returns a normal value: with return.

Unwrapping Optionals

An optional value cannot be used as the payload type until it is unwrapped.

Types as Values

In Zig, a type is a value.

Type Constraints by Use

Zig does not have a formal trait or interface system.

Page Allocator

The page allocator gets memory from the operating system.

Writing Bytes

Writing bytes is the opposite of reading them.

`std.ArrayList`

std.ArrayList is a growable array.

Build Steps

A build file describes steps.

Header Translation

@cImport does two jobs.

CPU Architectures

The architecture part of a target tells Zig what kind of processor the program will run on.

Atomics

A mutex makes one thread wait while another thread uses shared data.

Pointer Casts

A pointer has a type.

A Line Filter

A line filter reads text, changes or selects some lines, and writes the result. Many Unix programs have this shape.

Numerical Differentiation

Numerical differentiation estimates derivatives by evaluating a function at nearby input values. It treats the function as a black box. The method does not need access to the...

Multivariate Calculus

Automatic differentiation is usually applied to functions with many inputs and many outputs. The calculus needed for this setting is multivariate calculus: the study of how a...

Intermediate Variables

Intermediate variables are the named values created between program inputs and program outputs. They make automatic differentiation mechanical.

Elementary Operations

Automatic differentiation reduces differentiation to a finite collection of elementary operations. Every program, regardless of complexity, is decomposed into primitive...

Dual Numbers

Dual numbers give forward mode automatic differentiation a compact algebraic form. Instead of storing a value and a tangent as two unrelated fields, we package them into one...

Reverse Computational Graphs

Reverse mode automatic differentiation operates on a computational graph. The forward pass evaluates the graph from inputs to outputs. The reverse pass traverses the same...

Nilpotent Elements

The defining feature of dual numbers is the existence of a nonzero element whose square vanishes:

Hessian Computation

For a scalar function

forward

A loop repeats a computation until a condition fails or a fixed iteration count is reached. In automatic differentiation, loops are important because many numerical algorithms...

Tensor Operations

Tensor operations generalize scalar, vector, and matrix operations to arrays with arbitrary rank. In automatic differentiation, a tensor is usually treated as a typed array...

Operator Overloading

Operator overloading implements automatic differentiation by changing the meaning of ordinary arithmetic operations for special numeric objects.

Functional Languages

Functional programming languages provide a natural semantic foundation for automatic differentiation. Programs are expressed as compositions of functions, immutable values,...

Stochastic Optimization

Stochastic optimization studies optimization when the objective is accessed through samples, noisy estimates, or partial observations. In machine learning, this is the normal...

Sensitivity Analysis

Sensitivity analysis studies how changes in inputs affect the outputs of a system. In differential equations, optimization, simulation, and machine learning, the main object...

Differentiable Databases

A differentiable database is a data system whose operations participate in gradient-based optimization. Instead of treating storage and querying as external infrastructure,...

Stability of Reverse Mode

Reverse mode automatic differentiation computes gradients by propagating adjoint values backward through a computational graph. In exact arithmetic, the reverse accumulation...

Differentiating Through Solvers

A solver is a program that computes a value by search, iteration, or factorization. Instead of evaluating a closed-form expression, it finds a value that satisfies a condition.

Algebraic Semantics

Automatic differentiation is often introduced operationally. A program executes elementary operations, and derivative information propagates alongside the computation. This...

Minimal Reverse Mode Engine

Reverse mode automatic differentiation computes derivatives by traversing the program backward after evaluation. Unlike forward mode, which propagates tangents alongside...

Tapenade

Tapenade is a source-transformation automatic differentiation system developed at INRIA. Like ADIFOR, it takes an existing program and produces a new differentiated program....

Tapenade

Tapenade is a source-transformation automatic differentiation system developed at INRIA. Like ADIFOR, it takes an existing program and produces a new differentiated program....

The Integers

The natural numbers are sufficient for counting and addition, but they are not sufficient for subtraction. For example,

Appendix B. Proof Techniques

A mathematical proof is a logically complete argument establishing the truth of a statement from accepted assumptions, definitions, and previously proved results.

Pythagorean Triples

A Pythagorean triple is a triple of positive integers

Infinite Products

An infinite product has the form

Splitting Fields

A central problem in algebra is to determine where a polynomial factors completely into linear terms. Consider the polynomial

Schemes

Classical algebraic geometry studies varieties defined by polynomial equations. This theory works well over algebraically closed fields, especially over $\mathbb{C}$. However,...

What Is Zig

Zig is a programming language for writing programs that are fast, clear, and close to the machine.

Primitive Types

Every value in a Zig program has a type.

`switch`

An if statement is good for general conditions:

Parameter Syntax

Function parameters are the inputs of a function.

Error Sets

An error set is a group of possible error names.

Single Item Pointers

A pointer is a value that stores the address of another value.

Array Literals

An array literal is the syntax you use to write array values directly in source code.

Struct Methods

A struct method is a function that belongs to a struct.

Appendix A. Zig 0.16 New Features

Zig 0.16.0 was released on April 14, 2026. The release contains 8 months of work, with changes from 244 contributors across 1,183 commits. The largest themes are the new I/O...

Optional Unwrapping

Optional unwrapping means taking the value out of an optional.

Compile-Time Variables

In the previous section, you learned that Zig can execute code during compilation.

`@import`

One of the first Zig builtins you will learn is @import.

General Purpose Allocator

The general purpose allocator is Zig’s standard allocator for ordinary heap allocation.

The Basic Idea

A HashMap is a data structure for storing values by key.

Creating Build Steps

A Zig build is made from steps.

Writing Unit Tests

A unit test checks one small piece of code in isolation.

Reading Files

Reading a file means asking the operating system for bytes stored on disk.

`@cImport`

@cImport is Zig’s built-in way to import C declarations from header files.

Mutexes

A mutex is a lock for shared data.

System Calls

A system call is a request from your program to the operating system.

Why Profiling Matters

When a program feels slow, your first job is not optimization.

Reflection Systems

Reflection means a program can inspect information about types while the program is being compiled or running.

Linux Support

Linux is one of the most natural platforms for Zig. Many Zig programs are built, tested, and deployed on Linux because Linux is common in servers, containers, embedded...

Zig Source Tree

When you first open the Zig source code repository, it can feel overwhelming.

Build a JSON Parser

A JSON parser reads JSON text and turns it into data your program can use.

`const` and `var`

Zig has two kinds of variable declarations:

`if` Expressions

In Zig, if is an expression. It can produce a value.

Parameters and Return Values

Functions communicate through parameters and return values.

Single-Item Pointers

A single-item pointer points to one value.

Array Literals

An array literal creates an array value.

Field Access

Fields are selected with the dot operator.

Error Unions

An error union combines a normal value with an error set.

Null

null is the value used when an optional has no payload.

Compile-Time Parameters

A function parameter can be marked comptime.

Generic Structs

A generic struct is a function that returns a type.

The Allocator Interface

An allocator is a value that knows how to allocate and free memory.

Reading Bytes

A file is read as bytes.

`std.mem`

The std.mem module contains operations on memory, slices, bytes, and basic data movement. Much of Zig programming eventually passes through std.mem.

`build.zig`

The file build.zig is a Zig program.

`@cImport`

Writing every C declaration by hand is tedious. Zig can read C headers directly.

Operating Systems

The operating system part of a target tells Zig what kind of system the program will run on.

Mutexes

A mutex is a lock for shared data.

Safety Checks

Zig inserts safety checks for operations that are valid only under certain conditions. These checks are present in safe build modes. They catch mistakes at the point where the...

A File Copier

A file copier is a useful small program. It opens one file for reading, opens another file for writing, then copies bytes from the first to the second.

Chapter 1. Introduction

A derivative measures how an output changes when an input changes. That sentence is simple, but it is one of the main ideas behind numerical computing, optimization, machine...

Chapter 2. Mathematical Foundations

Automatic differentiation begins with a simple object: a function.

Chapter 3. Programs as Mathematical Objects

A straight-line program is the simplest model of computation used in automatic differentiation. It is a program with a fixed sequence of assignments, no branches, no loops,...

Chapter 4. Core Theory of Automatic Differentiation

Automatic differentiation is built on a simple observation: a complicated derivative can be computed by composing many small local derivatives. Instead of manipulating a full...

Chapter 5. Forward Mode Automatic Differentiation

Forward mode automatic differentiation computes derivatives by carrying two values through a program at the same time: the ordinary value and its tangent. The ordinary value...

Chapter 6. Reverse Mode Automatic Differentiation

Reverse mode automatic differentiation computes derivatives by propagating sensitivities backward through a computation. In forward mode, each intermediate value carries a...

Chapter 7. Dual Numbers and Algebraic Structures

Dual numbers give the cleanest algebraic model of forward mode automatic differentiation. They extend ordinary real numbers with a formal infinitesimal part. Instead of...

Chapter 8. Higher-Order Differentiation

First derivatives describe local rate of change. Second derivatives describe how that rate of change itself changes. In optimization, this is curvature. In dynamics, it is...

Chapter 9. Differentiation of Control Flow

A conditional is a program construct that chooses one computation among several possible computations. In ordinary code, this is written as if, else, switch, case, pattern...

Chapter 10. Matrix and Tensor Differentiation

Matrix calculus is the notation and rule system used to differentiate functions whose inputs, outputs, or intermediate values are vectors, matrices, or tensors. Automatic...

Chapter 11. Compiler and Runtime Design

Source transformation is an implementation strategy for automatic differentiation in which a program that computes a function is rewritten into another program that computes...

Chapter 12. AD in Modern Programming Languages

Lisp is one of the natural homes of automatic differentiation. It treats programs as data, has a simple expression syntax, and supports macro systems that can transform code...

Chapter 13. Optimization and Machine Learning

Gradient descent is the basic optimization procedure behind much of modern machine learning. It is simple enough to state in one line, but rich enough to expose many of the...

Chapter 14. Scientific Computing Applications

Differential equations are one of the main reasons automatic differentiation matters in scientific computing. Many scientific models are not written as closed-form functions....

Chapter 15. Differentiable Systems Architecture

An end-to-end differentiable pipeline is a system whose final objective can send derivative information backward through every trainable or tunable stage of computation....

Chapter 17. Numerical and Systems Concerns

Automatic differentiation computes derivatives by executing arithmetic. On a real machine, arithmetic uses finite precision. This means AD gives the derivative of the...

Chapter 18. Advanced Topics

Many programs do not compute their output by applying a fixed sequence of explicit operations. Instead, they define the output as the solution of another problem.

Chapter 19. Theory and Foundations

Automatic differentiation is often described by a simple rule:

Chapter 20. Building an AD Engine

A minimal forward mode automatic differentiation engine has one job: evaluate a program while carrying both a value and its derivative. The engine does not build a graph. It...

Chapter 21. Major AD Systems

ADIFOR, short for Automatic Differentiation of Fortran, is one of the classical source-transformation systems for automatic differentiation. It was designed for numerical...

Appendix

ADIFOR, short for Automatic Differentiation of Fortran, is one of the classical source-transformation systems for automatic differentiation. It was designed for numerical...

Chapter 16. Sparse and Structured Differentiation

Sparse and structured differentiation studies how to compute derivatives without materializing dense derivative objects. Many real systems have enormous Jacobians and...

Chapter 22. Open Problems

Automatic differentiation works naturally on pure mathematical functions:

Chapter 1. Foundations of Arithmetic

The natural numbers arise from the basic act of counting. When we count objects in a collection, we assign successive numbers:

Chapter 2. Classical Number Theory

A Diophantine equation is an equation whose solutions are required to be integers. The unknowns are not allowed to range over the real numbers or complex numbers unless...

Chapter 3. Analytic Number Theory

The harmonic series is the infinite series

Chapter 4. Algebraic Number Theory

A field is a number system in which addition, subtraction, multiplication, and division by nonzero elements are always possible. The rational numbers $\mathbb{Q}$, the real...

Chapter 5. Arithmetic Geometry and Modern Directions

Arithmetic geometry studies solutions of polynomial equations by combining algebra, geometry, and number theory. Its basic objects are spaces defined by polynomial equations....

Appendix

A set is a collection of objects, called its elements. If $x$ is an element of a set $A$, we write $x \in A$. If $x$ is not an element of $A$, we write $x \notin A$.

What Is Zig

Zig is a programming language for writing fast, small, reliable programs.

What Is Zig

Zig is a programming language for writing fast, small, reliable programs.

Variables and Constants

A program stores values so it can use them later. In Zig, you store values with two main keywords:

`if` Expressions

Programs need to make choices.

The Structure of a Function

Functions are reusable blocks of code.

Why Zig Has No Exceptions

Most programming languages need a way to handle failure.

Memory Model Basics

Memory is where a program keeps its data while it runs.

Fixed Arrays

An array is a group of values stored next to each other.

Struct Definitions

A struct is a type that groups several values together.

Optional Types

An optional type is a type that can hold either a value or no value.

What Is `comptime`

comptime means “compile time.”

Understanding `@` Builtins

Zig has special built-in functions whose names start with @.

Why Zig Uses Allocators

Memory is one of the most important ideas in Zig.

Importing ArrayList

An ArrayList is one of the most important data structures in Zig.

Tour of `std`

std is Zig’s standard library.

Introduction to `build.zig`

Zig has a built-in build system.

Zig Test Framework

Zig has a built-in test system. You do not need a separate testing library to start writing tests.

Why Zig Works Well with C

Zig works unusually well with C because it treats C as a first-class part of systems programming.

Threads in Zig

A thread is a separate path of execution inside one program.

Memory Mapped Files

A memory mapped file is a file that the operating system places into your program's address space.

What Actually Makes Programs Slow?

Performance is one of the main reasons people choose Zig.

Custom Formatting

Zig has a formatting system built into the standard library. You have already used it many times through std.debug.print.

Windows Support

Windows is one of Zig’s main supported platforms. You can write Zig programs on Windows, build Windows executables, call Windows system APIs, link with C libraries, and...

Build a CLI Calculator

In this project, we will build a small command-line calculator.

Zig Compiler Architecture

The Zig compiler is not only a compiler for the Zig language. It is also the center of the Zig toolchain.

Names and Declarations

A Zig program is made from declarations.

Blocks are Expressions

A block is a sequence of statements inside braces.

Defining Functions

A function groups statements into a single operation. Functions are the basic unit of organization in a Zig program.

Addresses and Pointer Types

A variable has a value. In Zig, a variable may also have an address.

Fixed-Size Arrays

An array is a sequence of values of the same type.

Struct Declarations

A struct is a type made from named fields.

Error Sets

Programs fail for many reasons. A file may not exist. Memory allocation may fail. Input may be malformed. A network connection may close unexpectedly.

The Optional Type

Sometimes a value may or may not exist.

What `comptime` Means

A Zig program runs in two stages.

Generic Functions

A function in Zig can take types as parameters.

Why Allocation Is Explicit

A program uses memory to store values.

Files

Most programs spend their time moving bytes.

`std.debug`

The std.debug module contains utilities for debugging programs. The most commonly used function is print, which writes formatted output to standard error.

`zig build`

Large programs are rarely built with a single compiler command.

Calling C

One of Zig's design goals is direct interoperability with C.

Target Triples

One of Zig's main design goals is cross compilation.

Threads

A thread is an independent flow of execution.

Undefined Behavior

Zig gives the programmer direct access to memory, integers, pointers, and machine operations. This makes many programs simple and efficient. It also makes some operations...

A Command-Line Parser

Many programs begin the same way: they read command-line arguments, decide what the user requested, then execute an operation.

1. What CPython Is

What CPython is, how it differs from other Python implementations, and why its internals are worth studying.

Colophon

This book describes the Zig programming language as of Zig 0.16.

Appendix J. Index

A

Appendix I. Exercise Answers

These are short answers or sketches for selected exercises from the book. Many exercises have several reasonable solutions. The important part is clarity and correctness.

Appendix H. Zig 0.16 Migration Notes

This appendix records the kinds of changes that matter when moving older Zig code to Zig 0.16. It is a practical checklist, not a full release history.

Exercises

The programs in this chapter are small. They are meant to be changed, broken, rebuilt, and studied.

Appendix G. Common Compiler Errors

Zig tries to report errors at the point where the program becomes invalid. Many messages are direct: a value has the wrong type, a variable is unused, an error was ignored, or...

A Word-Count Program

A useful program reads text and counts something.

Appendix F. C Interop Reference

One of Zig's central goals is direct interoperability with C. Zig can call C code, compile C code, link system libraries, export functions to C, and translate C headers.

Reading Command-Line Arguments

Programs often need input.

Appendix E. Build System Reference

Zig builds programs with Zig code. The build script is named:

A Small Calculator

A program can compute a value before it prints it.

Appendix D. Standard Library Map

The Zig standard library is imported as:

Printing Values

The function std.debug.print writes text.

Appendix C. Builtin Functions

Builtin functions are part of the language. Their names begin with @.

Variables and Constants

A program works with values. In Zig, values are usually stored in constants or variables.

Appendix B. Operators and Precedence

This appendix lists the common operators by use. When an expression is not obvious, use parentheses.

Build and Run

There are two common ways to run a small Zig program.

Appendix A. Zig Syntax Summary

This appendix is a quick map of Zig syntax. It is not a grammar. The full Zig grammar is part of the official language reference. Zig 0.16 also keeps the language small enough...

Hello, Zig

The first program in Zig is small.

Hello, Zig

The first program in Zig is small.

LeetCode 925: Long Pressed Name

A clear explanation of the Long Pressed Name problem using a two-pointer scan.

LeetCode 975: Odd Even Jump

A clear explanation of counting good starting indices using next-jump preprocessing and dynamic programming.

LeetCode 974: Subarray Sums Divisible by K

A clear explanation of counting subarrays whose sum is divisible by k using prefix sums and remainder frequencies.

LeetCode 973: K Closest Points to Origin

A clear explanation of returning the k closest points to the origin using squared distance and sorting.

LeetCode 972: Equal Rational Numbers

A clear explanation of comparing rational numbers written as decimal strings with optional repeating parts.

LeetCode 971: Flip Binary Tree To Match Preorder Traversal

A clear explanation of matching a binary tree preorder traversal by greedily flipping nodes.

LeetCode 970: Powerful Integers

A clear explanation of generating all powerful integers using bounded powers and a set.

LeetCode 969: Pancake Sorting

A clear explanation of sorting an array using prefix reversals by repeatedly placing the largest remaining value.

LeetCode 968: Binary Tree Cameras

A clear explanation of placing the minimum number of cameras in a binary tree using postorder DFS.

LeetCode 967: Numbers With Same Consecutive Differences

A clear explanation of generating all n-digit numbers whose adjacent digits differ by k.

LeetCode 966: Vowel Spellchecker

A clear explanation of implementing a spellchecker with exact, case-insensitive, and vowel-error matching.

LeetCode 965: Univalued Binary Tree

A clear explanation of checking whether every node in a binary tree has the same value.

LeetCode 963: Minimum Area Rectangle II

A clear explanation of finding the minimum-area rectangle from points when the rectangle may be rotated.

LeetCode 962: Maximum Width Ramp

A clear explanation of finding the maximum width ramp using a monotonic decreasing stack.

LeetCode 961: N-Repeated Element in Size 2N Array

A clear explanation of finding the element repeated N times using a hash set.

LeetCode 960: Delete Columns to Make Sorted III

A clear explanation of deleting the minimum number of columns so every remaining row is individually sorted.

LeetCode 959: Regions Cut By Slashes

A clear explanation of counting regions formed by slashes using union find over four triangles per cell.

LeetCode 958: Check Completeness of a Binary Tree

A clear explanation of checking whether a binary tree is complete using level-order traversal.

LeetCode 957: Prison Cells After N Days

A clear explanation of simulating prison cell transitions efficiently using cycle detection.

LeetCode 956: Tallest Billboard

A clear explanation of solving Tallest Billboard using dynamic programming over height differences.

LeetCode 955: Delete Columns to Make Sorted II

A clear explanation of deleting the minimum number of columns so rows become lexicographically sorted.

LeetCode 952: Largest Component Size by Common Factor

A clear explanation of solving Largest Component Size by Common Factor using prime factorization and union find.

LeetCode 951: Flip Equivalent Binary Trees

A clear explanation of checking whether two binary trees are equivalent after swapping left and right children at any number of nodes.

LeetCode 850: Rectangle Area II

A clear explanation of the Rectangle Area II problem using sweep line and merged active y-intervals.

LeetCode 849: Maximize Distance to Closest Person

A clear explanation of the Maximize Distance to Closest Person problem using gaps between occupied seats.

LeetCode 848: Shifting Letters

A clear explanation of the Shifting Letters problem using suffix sums and modulo arithmetic.

LeetCode 847: Shortest Path Visiting All Nodes

A clear explanation of the Shortest Path Visiting All Nodes problem using multi-source BFS and bitmask state compression.

LeetCode 846: Hand of Straights

A clear explanation of the Hand of Straights problem using sorting, frequency counting, and greedy grouping.

LeetCode 845: Longest Mountain in Array

A clear explanation of the Longest Mountain in Array problem using peak detection and two-pointer expansion.

LeetCode 844: Backspace String Compare

A clear explanation of the Backspace String Compare problem using stack simulation and an O(1) space two-pointer scan.

LeetCode 843: Guess the Word

A clear explanation of the Guess the Word interactive problem using candidate filtering and minimax-style guessing.

LeetCode 842: Split Array into Fibonacci Sequence

A clear explanation of the Split Array into Fibonacci Sequence problem using backtracking, leading-zero checks, and 32-bit integer limits.

LeetCode 841: Keys and Rooms

A clear explanation of the Keys and Rooms problem using graph traversal from room 0.

LeetCode 840: Magic Squares In Grid

A clear explanation of the Magic Squares In Grid problem using fixed-size subgrid validation.

LeetCode 839: Similar String Groups

A clear explanation of the Similar String Groups problem using graph connectivity and union-find.

LeetCode 838: Push Dominoes

A clear explanation of the Push Dominoes problem using force propagation and a two-pass scan.

LeetCode 837: New 21 Game

A clear explanation of the New 21 Game problem using probability dynamic programming and a sliding window sum.

LeetCode 836: Rectangle Overlap

A clear explanation of the Rectangle Overlap problem using axis projections and positive intersection area.

LeetCode 835: Image Overlap

A clear explanation of the Image Overlap problem using translation vectors and frequency counting.

LeetCode 834: Sum of Distances in Tree

A clear explanation of the Sum of Distances in Tree problem using tree DP, subtree sizes, and rerooting.

LeetCode 833: Find And Replace in String

A clear explanation of the Find And Replace in String problem using simultaneous replacement, source matching, and a replacement map.

LeetCode 832: Flipping an Image

A clear explanation of the Flipping an Image problem using row reversal, bit inversion, and an in-place two-pointer method.

LeetCode 831: Masking Personal Information

A clear explanation of the Masking Personal Information problem using string parsing and format-specific masking rules.

LeetCode 830: Positions of Large Groups

A clear explanation of the Positions of Large Groups problem using a simple two-pointer scan.

LeetCode 829: Consecutive Numbers Sum

A clear explanation of the Consecutive Numbers Sum problem using arithmetic series formulas and divisibility analysis.

LeetCode 828: Count Unique Characters of All Substrings of a Given String

A clear explanation of Count Unique Characters of All Substrings using contribution counting with previous and next occurrences.

LeetCode 827: Making A Large Island

A clear explanation of the Making A Large Island problem using connected component labeling and island size lookup.

LeetCode 826: Most Profit Assigning Work

A clear explanation of the Most Profit Assigning Work problem using sorting, greedy choice, and two pointers.

LeetCode 924: Minimize Malware Spread

A clear explanation of minimizing malware spread by analyzing connected components with Union Find.

LeetCode 923: 3Sum With Multiplicity

A clear explanation of counting index triplets with duplicate values using frequency counts and combinatorics.

LeetCode 922: Sort Array By Parity II

A clear explanation of placing even numbers at even indices and odd numbers at odd indices using two pointers.

LeetCode 921: Minimum Add to Make Parentheses Valid

A clear explanation of making a parentheses string valid using greedy counting.

LeetCode 920: Number of Music Playlists

A clear explanation of counting valid music playlists using dynamic programming over playlist length and unique songs used.

LeetCode 919: Complete Binary Tree Inserter

A clear explanation of maintaining a complete binary tree inserter using level-order indexing.

LeetCode 917: Reverse Only Letters

A clear explanation of reversing only English letters while keeping all non-letter characters fixed.

LeetCode 916: Word Subsets

A clear explanation of finding universal words by merging character frequency requirements from words2.

LeetCode 915: Partition Array into Disjoint Intervals

A clear explanation of finding the smallest left partition using prefix maximums and suffix minimums.

LeetCode 914: X of a Kind in a Deck of Cards

A clear explanation of checking whether card counts share a common group size using the greatest common divisor.

LeetCode 913: Cat and Mouse

A clear explanation of Cat and Mouse using game states, reverse BFS, and topological propagation.

LeetCode 912: Sort an Array

A clear explanation of sorting an array without built-in sorting using merge sort.

LeetCode 911: Online Election

A clear explanation of Online Election using preprocessing and binary search over vote times.

LeetCode 909: Snakes and Ladders

A clear explanation of Snakes and Ladders using breadth-first search over board squares.

LeetCode 908: Smallest Range I

A clear explanation of minimizing an array score after each value can move by at most k.

LeetCode 907: Sum of Subarray Minimums

A clear explanation of summing subarray minimums using a monotonic stack and contribution counting.

LeetCode 906: Super Palindromes

A clear explanation of counting super-palindromes by generating palindromic roots and checking their squares.

LeetCode 905: Sort Array By Parity

A clear explanation of sorting an array by parity using a two-pointer partition method.

LeetCode 904: Fruit Into Baskets

A clear explanation of Fruit Into Baskets using a sliding window with at most two distinct fruit types.

LeetCode 903: Valid Permutations for DI Sequence

A clear explanation of counting valid DI permutations using dynamic programming and prefix sums.

LeetCode 902: Numbers At Most N Given Digit Set

A clear explanation of counting numbers less than or equal to N using digit-by-digit construction and combinatorics.

LeetCode 901: Online Stock Span

A clear explanation of Online Stock Span using a monotonic decreasing stack with accumulated spans.

LeetCode 900: RLE Iterator

A clear explanation of designing an iterator over a run-length encoded sequence without expanding it.

LeetCode 899: Orderly Queue

A clear explanation of finding the lexicographically smallest string after queue operations using rotation and sorting.

LeetCode 898: Bitwise ORs of Subarrays

A clear explanation of counting distinct bitwise OR results from all non-empty subarrays using rolling sets.

LeetCode 897: Increasing Order Search Tree

A clear explanation of rearranging a binary search tree into an increasing right-only tree using inorder traversal.

LeetCode 896: Monotonic Array

A clear explanation of checking whether an array is monotonic using one pass and direction flags.

LeetCode 895: Maximum Frequency Stack

A clear explanation of designing a stack that pops the most frequent value, breaking ties by most recent insertion.

LeetCode 894: All Possible Full Binary Trees

A clear explanation of generating all full binary trees with n nodes using recursion and memoization.

LeetCode 893: Groups of Special-Equivalent Strings

A clear explanation of counting special-equivalent string groups by building canonical signatures from even and odd positions.

LeetCode 892: Surface Area of 3D Shapes

A clear explanation of computing the exposed surface area of stacked cubes by adding tower area and subtracting shared faces.

LeetCode 891: Sum of Subsequence Widths

A clear explanation of summing subsequence widths by sorting and counting each element as a maximum and minimum.

LeetCode 890: Find and Replace Pattern

A clear explanation of finding words that match a pattern using bijective character mapping.

LeetCode 889: Construct Binary Tree from Preorder and Postorder Traversal

A clear explanation of reconstructing a binary tree from preorder and postorder traversals using recursion and index ranges.

LeetCode 888: Fair Candy Swap

A clear explanation of finding one candy box swap that makes Alice and Bob have equal total candies.

LeetCode 887: Super Egg Drop

A clear explanation of finding the minimum worst-case number of moves using dynamic programming over eggs and moves.

LeetCode 886: Possible Bipartition

A clear explanation of checking whether people can be split into two groups using graph coloring and bipartite graph detection.

LeetCode 885: Spiral Matrix III

A clear explanation of generating grid coordinates in an outward clockwise spiral using simulation.

LeetCode 884: Uncommon Words from Two Sentences

A clear explanation of finding uncommon words by counting word frequencies across both sentences.

LeetCode 882: Reachable Nodes In Subdivided Graph

A clear explanation of counting reachable original and subdivided nodes using Dijkstra's shortest path algorithm.

LeetCode 881: Boats to Save People

A clear explanation of minimizing rescue boats using sorting, greedy choice, and two pointers.

LeetCode 880: Decoded String at Index

A clear explanation of finding the kth character in a decoded string without building the full decoded string.

LeetCode 879: Profitable Schemes

A clear explanation of counting profitable crime schemes using 0/1 knapsack dynamic programming with members and profit states.

LeetCode 878: Nth Magical Number

A clear explanation of finding the nth magical number using binary search, greatest common divisor, least common multiple, and inclusion-exclusion.

LeetCode 877: Stone Game

A clear explanation of the Stone Game problem using game theory and interval dynamic programming.

LeetCode 876: Middle of the Linked List

A clear explanation of finding the middle node of a singly linked list using slow and fast pointers.

LeetCode 625: Minimum Factorization

A clear explanation of Minimum Factorization using greedy digit factors from 9 down to 2.

LeetCode 624: Maximum Distance in Arrays

A clear explanation of Maximum Distance in Arrays using sorted endpoints and a greedy scan.

LeetCode 623: Add One Row to Tree

A clear explanation of Add One Row to Tree using tree traversal and careful subtree reconnection.

LeetCode 622: Design Circular Queue

A clear explanation of Design Circular Queue using a fixed array, a front pointer, and a size counter.

LeetCode 621: Task Scheduler

A clear explanation of Task Scheduler using frequency counting and the greedy block formula.

LeetCode 250: Count Univalue Subtrees

A clear explanation of counting uni-value subtrees using post-order DFS.

LeetCode 249: Group Shifted Strings

A clear explanation of grouping strings by their shifting sequence using normalized hash keys.

LeetCode 248: Strobogrammatic Number III

A clear explanation of counting strobogrammatic numbers in a string range using recursive generation and range filtering.

LeetCode 247: Strobogrammatic Number II

A clear explanation of generating all strobogrammatic numbers of length n using recursion from the inside out.

LeetCode 246: Strobogrammatic Number

A clear explanation of the Strobogrammatic Number problem using digit rotation rules and two pointers.

LeetCode 245: Shortest Word Distance III

A clear explanation of the Shortest Word Distance III problem, including the special case where both target words are the same.

LeetCode 244: Shortest Word Distance II

A clear explanation of the Shortest Word Distance II problem using preprocessing and two pointers.

LeetCode 243: Shortest Word Distance

A clear explanation of the Shortest Word Distance problem using one pass and the latest seen indices of both words.

LeetCode 1000: Minimum Cost to Merge Stones

A clear explanation of merging consecutive stone piles with minimum cost using interval dynamic programming.

LeetCode 999: Available Captures for Rook

A clear explanation of counting how many pawns a rook can capture by scanning four directions on a chessboard.

LeetCode 998: Maximum Binary Tree II

A clear explanation of inserting a value into a maximum binary tree by following the right spine.

LeetCode 997: Find the Town Judge

A clear explanation of identifying the town judge using trust indegree and outdegree counts.

LeetCode 996: Number of Squareful Arrays

A clear explanation of counting unique permutations where every adjacent pair sums to a perfect square using backtracking.

LeetCode 995: Minimum Number of K Consecutive Bit Flips

A clear explanation of making all bits equal to 1 using greedy left-to-right flips and a sliding window flip parity.

LeetCode 994: Rotting Oranges

A clear explanation of finding the minimum time for all oranges to rot using multi-source BFS.

LeetCode 993: Cousins in Binary Tree

A clear explanation of checking whether two binary tree nodes are cousins using BFS with parent tracking.

LeetCode 992: Subarrays with K Different Integers

A clear explanation of counting subarrays with exactly k distinct integers using the at-most-k sliding window trick.

LeetCode 991: Broken Calculator

A clear explanation of finding the minimum operations by working backward from target to startValue.

LeetCode 990: Satisfiability of Equality Equations

A clear explanation of checking equality and inequality constraints using union-find.

LeetCode 989: Add to Array-Form of Integer

A clear explanation of adding an integer to an array-form number using digit-by-digit simulation.

LeetCode 988: Smallest String Starting From Leaf

A clear explanation of finding the lexicographically smallest leaf-to-root string in a binary tree using DFS.

LeetCode 987: Vertical Order Traversal of a Binary Tree

A clear explanation of vertical tree traversal using coordinates, DFS, sorting, and column grouping.

LeetCode 986: Interval List Intersections

A clear explanation of finding intersections between two sorted disjoint interval lists using two pointers.

LeetCode 985: Sum of Even Numbers After Queries

A clear explanation of maintaining the sum of even numbers after each array update.

LeetCode 984: String Without AAA or BBB

A clear explanation of constructing a string with exact counts of a and b while avoiding three equal consecutive characters.

LeetCode 983: Minimum Cost For Tickets

A clear explanation of finding the cheapest way to cover all travel days using dynamic programming.

LeetCode 982: Triples with Bitwise AND Equal To Zero

A clear explanation of counting ordered triples whose bitwise AND is zero using pairwise AND counts.

LeetCode 981: Time Based Key-Value Store

A clear explanation of designing a time-based key-value store using a hash map and binary search.

LeetCode 980: Unique Paths III

A clear explanation of counting all paths from start to end that visit every non-obstacle square exactly once using backtracking.

LeetCode 979: Distribute Coins in Binary Tree

A clear explanation of balancing coins in a binary tree using postorder DFS and subtree coin balance.

LeetCode 978: Longest Turbulent Subarray

A clear explanation of finding the longest subarray whose adjacent comparisons alternate between greater-than and less-than.

LeetCode 977: Squares of a Sorted Array

A clear explanation of sorting squared values from a sorted array using two pointers.

LeetCode 976: Largest Perimeter Triangle

A clear explanation of finding the largest valid triangle perimeter using sorting and a greedy scan.

LeetCode 875: Koko Eating Bananas

A clear explanation of finding the minimum banana-eating speed using binary search on the answer.

LeetCode 874: Walking Robot Simulation

A clear explanation of simulating robot movement on an infinite grid using direction vectors and obstacle lookup.

LeetCode 873: Length of Longest Fibonacci Subsequence

A clear explanation of finding the longest Fibonacci-like subsequence using dynamic programming and value-to-index lookup.

LeetCode 872: Leaf-Similar Trees

A clear explanation of comparing two binary trees by collecting their leaf value sequences with DFS.

LeetCode 871: Minimum Number of Refueling Stops

A clear explanation of minimizing refueling stops using a greedy max heap over reachable stations.

LeetCode 870: Advantage Shuffle

A clear explanation of maximizing the advantage of one array over another using sorting, greedy matching, and two pointers.

LeetCode 869: Reordered Power of 2

A clear explanation of checking whether the digits of a number can be reordered to form a power of two using digit frequency signatures.

LeetCode 868: Binary Gap

A clear explanation of finding the maximum distance between adjacent set bits in a binary representation.

LeetCode 867: Transpose Matrix

A clear explanation of transposing a matrix by swapping row and column indices.

LeetCode 866: Prime Palindrome

A clear explanation of finding the smallest prime palindrome greater than or equal to n by generating odd-length palindromes and testing primality.

LeetCode 865: Smallest Subtree with all the Deepest Nodes

A clear explanation of finding the smallest subtree that contains all deepest nodes using bottom-up DFS.

LeetCode 864: Shortest Path to Get All Keys

A clear explanation of finding the minimum moves to collect all keys in a grid using BFS with key bitmasks.

LeetCode 863: All Nodes Distance K in Binary Tree

A clear explanation of finding all binary tree nodes at distance k from a target node by treating the tree as an undirected graph.

LeetCode 862: Shortest Subarray with Sum at Least K

A clear explanation of finding the shortest non-empty subarray with sum at least k using prefix sums and a monotonic deque.

LeetCode 861: Score After Flipping Matrix

A clear explanation of maximizing a binary matrix score using greedy row and column flips.

LeetCode 860: Lemonade Change

A clear explanation of Lemonade Change using greedy simulation and bill counting.

LeetCode 859: Buddy Strings

A clear explanation of checking whether one swap in a string can make it equal to another string.

LeetCode 858: Mirror Reflection

A clear explanation of Mirror Reflection using room unfolding, least common multiples, and parity.

LeetCode 857: Minimum Cost to Hire K Workers

A clear explanation of hiring exactly k workers with minimum total cost using wage-to-quality ratios, sorting, and a max heap.

LeetCode 856: Score of Parentheses

A clear explanation of scoring a balanced parentheses string using depth counting.

LeetCode 855: Exam Room

A clear explanation of simulating an exam room by maintaining occupied seats in sorted order.

LeetCode 854: K-Similar Strings

A clear explanation of finding the minimum number of swaps needed to transform one anagram string into another using BFS.

LeetCode 853: Car Fleet

A clear explanation of counting car fleets by sorting cars by position and tracking arrival times.

LeetCode 852: Peak Index in a Mountain Array

A clear explanation of finding the peak index in a mountain array using binary search.

LeetCode 851: Loud and Rich

A clear explanation of Loud and Rich using graph traversal, DFS, and memoization.

LeetCode 950: Reveal Cards In Increasing Order

A clear explanation of solving Reveal Cards In Increasing Order using sorting and queue simulation over indices.

LeetCode 949: Largest Time for Given Digits

A clear explanation of solving Largest Time for Given Digits by checking all permutations of four digits.

LeetCode 948: Bag of Tokens

A clear explanation of solving Bag of Tokens using sorting, greedy choices, and two pointers.

LeetCode 947: Most Stones Removed with Same Row or Column

A clear explanation of solving Most Stones Removed with Same Row or Column using connected components and union-find.

LeetCode 946: Validate Stack Sequences

A clear explanation of solving Validate Stack Sequences by simulating stack push and pop operations.

LeetCode 945: Minimum Increment to Make Array Unique

A clear explanation of solving Minimum Increment to Make Array Unique by sorting and greedily assigning the next available value.

LeetCode 943: Find the Shortest Superstring

A clear explanation of solving Find the Shortest Superstring using pairwise overlaps and bitmask dynamic programming.

LeetCode 942: DI String Match

A clear explanation of solving DI String Match using a greedy two-pointer construction.

LeetCode 941: Valid Mountain Array

A clear explanation of solving Valid Mountain Array by walking up the increasing slope and then down the decreasing slope.

LeetCode 939: Minimum Area Rectangle

A clear explanation of solving Minimum Area Rectangle using diagonal point pairs and constant-time point lookup.

LeetCode 938: Range Sum of BST

A clear explanation of solving Range Sum of BST using DFS with binary search tree pruning.

LeetCode 937: Reorder Data in Log Files

A clear explanation of solving Reorder Data in Log Files using custom sorting and stable handling of digit logs.

LeetCode 935: Knight Dialer

A clear explanation of solving Knight Dialer using dynamic programming over the phone keypad graph.

LeetCode 934: Shortest Bridge

A clear explanation of solving Shortest Bridge using DFS to mark one island and BFS to expand toward the other island.

LeetCode 933: Number of Recent Calls

A clear explanation of solving Number of Recent Calls using a queue as a sliding time window.

LeetCode 932: Beautiful Array

A clear explanation of solving Beautiful Array using divide and conquer with odd and even transformations.

LeetCode 931: Minimum Falling Path Sum

A clear explanation of solving Minimum Falling Path Sum using dynamic programming over matrix rows.

LeetCode 930: Binary Subarrays With Sum

A clear explanation of solving Binary Subarrays With Sum using prefix sums and a frequency map.

LeetCode 928: Minimize Malware Spread II

A clear explanation of solving Minimize Malware Spread II by removing each infected node and simulating the final malware spread.

LeetCode 927: Three Equal Parts

A clear explanation of solving Three Equal Parts by counting ones, locating the three binary patterns, and comparing them in one pass.

LeetCode 926: Flip String to Monotone Increasing

A clear explanation of solving Flip String to Monotone Increasing with a one-pass dynamic programming approach.

LeetCode 825: Friends Of Appropriate Ages

A counting solution for computing how many directed friend requests are allowed by age rules.

LeetCode 824: Goat Latin

A string simulation solution for converting each word in a sentence into Goat Latin.

LeetCode 823: Binary Trees With Factors

A dynamic programming solution for counting binary trees where every non-leaf node is the product of its children.

LeetCode 822: Card Flipping Game

A hash set solution for finding the smallest number that can be hidden from all front-facing cards.

LeetCode 821: Shortest Distance to a Character

A two-pass solution for computing the shortest distance from each index to the nearest occurrence of a target character.

LeetCode 820: Short Encoding of Words

A suffix-removal solution for finding the shortest reference string that can encode every word.

LeetCode 819: Most Common Word

A hash map and string parsing solution for finding the most frequent non-banned word in a paragraph.

LeetCode 818: Race Car

A dynamic programming solution for finding the shortest instruction sequence that drives a race car to the target position.

LeetCode 817: Linked List Components

A hash set and linked list traversal solution for counting consecutive components whose values appear in nums.

LeetCode 816: Ambiguous Coordinates

An enumeration solution for reconstructing all valid coordinate pairs after commas, spaces, and decimal points were removed.

LeetCode 815: Bus Routes

A BFS solution for finding the minimum number of buses needed to travel from a source stop to a target stop.

LeetCode 814: Binary Tree Pruning

A postorder DFS solution for removing every binary tree subtree that does not contain a 1.

LeetCode 813: Largest Sum of Averages

A dynamic programming and prefix sum solution for partitioning an array into adjacent groups with maximum total average.

LeetCode 812: Largest Triangle Area

A geometry solution for finding the largest triangle area by checking every triplet of points with the cross product formula.

LeetCode 811: Subdomain Visit Count

A hash map solution for accumulating visit counts across domains and all of their parent subdomains.

LeetCode 810: Chalkboard XOR Game

A math and bit manipulation solution for deciding whether Alice wins the XOR removal game.

LeetCode 809: Expressive Words

A two-pointer group comparison solution for counting how many words can be stretched to match a target string.

LeetCode 808: Soup Servings

A probability dynamic programming solution for computing whether soup A empties before soup B, with an early return for large input.

LeetCode 807: Max Increase to Keep City Skyline

A greedy solution for increasing building heights as much as possible while preserving every skyline view.

LeetCode 806: Number of Lines To Write String

A simple simulation solution for counting how many 100-pixel lines are needed to write a string.

LeetCode 805: Split Array With Same Average

A dynamic programming solution for deciding whether an array can be split into two non-empty groups with the same average.

LeetCode 804: Unique Morse Code Words

A set-based solution for counting how many different Morse code transformations appear among a list of words.

LeetCode 803: Bricks Falling When Hit

A reverse simulation and union-find solution for counting how many bricks fall after each hit.

LeetCode 802: Find Eventual Safe States

A graph traversal solution for finding all nodes that cannot reach a directed cycle.

LeetCode 801: Minimum Swaps To Make Sequences Increasing

A dynamic programming solution for finding the minimum number of same-index swaps needed to make two arrays strictly increasing.

LeetCode 800: Similar RGB Color

A clear explanation of finding the closest shorthand RGB color by rounding each color channel to the nearest repeated hexadecimal pair.

LeetCode 799: Champagne Tower

A clear explanation of simulating overflow in a champagne glass pyramid using dynamic programming.

LeetCode 798: Smallest Rotation with Highest Score

A clear explanation of finding the smallest rotation with maximum score using a difference array.

LeetCode 797: All Paths From Source to Target

A clear explanation of finding every path from node 0 to node n - 1 in a directed acyclic graph using DFS and backtracking.

LeetCode 796: Rotate String

A clear explanation of checking whether one string can become another by repeated left rotations.

LeetCode 795: Number of Subarrays with Bounded Maximum

A clear explanation of counting contiguous subarrays whose maximum value lies inside a given inclusive range.

LeetCode 794: Valid Tic-Tac-Toe State

A clear explanation of validating whether a Tic-Tac-Toe board can occur in a legal game.

LeetCode 793: Preimage Size of Factorial Zeroes Function

A clear explanation of finding how many integers have exactly k trailing zeroes in their factorial.

LeetCode 792: Number of Matching Subsequences

A clear explanation of counting how many words are subsequences of a string using waiting queues.

LeetCode 791: Custom Sort String

A clear explanation of rearranging a string so that selected characters follow a custom order.

LeetCode 790: Domino and Tromino Tiling

A clear explanation of counting tilings of a 2 x n board using dominoes and L-shaped trominoes with dynamic programming.

LeetCode 789: Escape The Ghosts

A clear explanation of deciding whether escape is possible by comparing Manhattan distances to the target.

LeetCode 788: Rotated Digits

A clear explanation of counting good numbers after rotating every digit by 180 degrees.

LeetCode 787: Cheapest Flights Within K Stops

A clear explanation of finding the cheapest flight route with at most k stops using bounded Bellman-Ford relaxation.

LeetCode 786: K-th Smallest Prime Fraction

A clear explanation of finding the kth smallest fraction from a sorted array using a min-heap.

LeetCode 785: Is Graph Bipartite?

A clear explanation of checking whether an undirected graph can be split into two independent sets using graph coloring.

LeetCode 784: Letter Case Permutation

A clear explanation of generating all strings formed by independently changing each letter to lowercase or uppercase.

LeetCode 783: Minimum Distance Between BST Nodes

A clear explanation of finding the minimum difference between any two nodes in a BST using inorder traversal.

LeetCode 782: Transform to Chessboard

A clear explanation of transforming a binary board into a chessboard using feasibility checks and minimum row and column swaps.

LeetCode 781: Rabbits in Forest

A clear explanation of finding the minimum possible number of rabbits using counting and greedy grouping.

LeetCode 780: Reaching Points

A clear explanation of checking whether one point can reach another by working backward with modulo.

LeetCode 779: K-th Symbol in Grammar

A clear explanation of finding the kth symbol in the grammar sequence using recursion and the parent-child relationship.

LeetCode 778: Swim in Rising Water

A clear explanation of finding the minimum time to reach the bottom-right cell using a priority queue and minimax path reasoning.

LeetCode 777: Swap Adjacent in LR String

A clear explanation of validating string transformation using two pointers and movement constraints.

LeetCode 776: Split BST

A clear explanation of splitting a binary search tree into two BSTs using recursion and pointer rewiring.

LeetCode 775: Global and Local Inversions

A clear explanation of checking whether every global inversion is also a local inversion using distance constraints.

LeetCode 774: Minimize Max Distance to Gas Station

A clear explanation of minimizing the largest adjacent gas-station distance using binary search on the answer.

LeetCode 773: Sliding Puzzle

A clear explanation of solving the 2 x 3 sliding puzzle using breadth-first search over board states.

LeetCode 772: Basic Calculator III

A clear explanation of evaluating arithmetic expressions with parentheses, precedence, and integer division.

LeetCode 771: Jewels and Stones

A clear explanation of counting how many stones are jewels using a hash set for fast membership checks.

LeetCode 770: Basic Calculator IV

A clear explanation of simplifying algebraic expressions by parsing, substituting variables, and combining polynomial terms.

LeetCode 769: Max Chunks To Make Sorted

A clear explanation of splitting a permutation into the maximum number of chunks using prefix maximums.

LeetCode 768: Max Chunks To Make Sorted II

A clear explanation of splitting an array into the maximum number of chunks so sorting each chunk gives the fully sorted array.

LeetCode 767: Reorganize String

A clear explanation of rearranging characters so no two adjacent characters are equal using a greedy max heap.

LeetCode 766: Toeplitz Matrix

A clear explanation of checking whether every top-left to bottom-right diagonal in a matrix has the same value.

LeetCode 765: Couples Holding Hands

A clear explanation of minimizing swaps so every couple sits together using greedy position tracking.

LeetCode 764: Largest Plus Sign

A clear explanation of finding the largest plus sign in a mined grid using four directional dynamic programming scans.

LeetCode 763: Partition Labels

A clear explanation of partitioning a string into the maximum number of parts so each character appears in at most one part.

LeetCode 762: Prime Number of Set Bits in Binary Representation

A clear explanation of counting numbers whose binary representation has a prime number of set bits.

LeetCode 761: Special Binary String

A clear explanation of making a special binary string lexicographically largest using recursive decomposition and sorting.

LeetCode 760: Find Anagram Mappings

A clear explanation of mapping each element in one array to a matching index in its anagram using a hash map.

LeetCode 759: Employee Free Time

A clear explanation of finding common free time by merging all employee busy intervals and returning the gaps.

LeetCode 758: Bold Words in String

A clear explanation of marking matching substrings and merging overlapping bold ranges.

LeetCode 757: Set Intersection Size At Least Two

A clear explanation of solving interval intersection constraints using greedy sorting and minimal point selection.

LeetCode 756: Pyramid Transition Matrix

A clear explanation of solving Pyramid Transition Matrix using backtracking and memoization over pyramid rows.

LeetCode 755: Pour Water

A clear explanation of simulating water droplets over an elevation map by checking left first, then right.

LeetCode 754: Reach a Number

A clear explanation of reaching a target on a number line using cumulative sums and parity.

LeetCode 753: Cracking the Safe

A clear explanation of Cracking the Safe using a de Bruijn sequence and depth-first search over password states.

LeetCode 752: Open the Lock

A clear explanation of solving Open the Lock using breadth-first search over lock states.

LeetCode 751: IP to CIDR

A clear explanation of converting a range of IPv4 addresses into the shortest list of CIDR blocks using greedy bit manipulation.

LeetCode 725: Split Linked List in Parts

A clear explanation of splitting a linked list into k consecutive parts with sizes as equal as possible.

LeetCode 724: Find Pivot Index

A clear explanation of finding the leftmost pivot index using prefix sums and a running left sum.

LeetCode 723: Candy Crush

A clear explanation of restoring a Candy Crush board to a stable state using repeated marking, crushing, and gravity simulation.

LeetCode 722: Remove Comments

A clear explanation of removing line comments and block comments from source code using a state machine.

LeetCode 721: Accounts Merge

A clear explanation of merging accounts that share emails using union find and sorted email groups.

LeetCode 719: Find K-th Smallest Pair Distance

A clear explanation of finding the kth smallest pair distance using sorting, binary search on the answer, and a two-pointer count.

LeetCode 718: Maximum Length of Repeated Subarray

A clear explanation of finding the longest common contiguous subarray using dynamic programming.

LeetCode 717: 1-bit and 2-bit Characters

A clear explanation of determining whether the last character must be a one-bit character using greedy parsing.

LeetCode 716: Max Stack

A clear explanation of designing a stack that supports push, pop, top, peekMax, and popMax.

LeetCode 715: Range Module

A clear explanation of designing a range module that can add, query, and remove half-open intervals.

LeetCode 714: Best Time to Buy and Sell Stock with Transaction Fee

A clear explanation of maximizing stock trading profit with unlimited transactions and a fixed transaction fee using dynamic programming.

LeetCode 713: Subarray Product Less Than K

A clear explanation of counting contiguous subarrays whose product is less than k using a sliding window.

LeetCode 712: Minimum ASCII Delete Sum for Two Strings

A clear explanation of using dynamic programming to minimize the ASCII cost of deletions needed to make two strings equal.

LeetCode 711: Number of Distinct Islands II

A clear explanation of counting distinct island shapes under rotation and reflection using normalization and geometric transformations.

LeetCode 710: Random Pick with Blacklist

A clear explanation of selecting a uniformly random integer while excluding blacklisted values using remapping and hashing.

LeetCode 709: To Lower Case

A clear explanation of converting uppercase ASCII letters to lowercase by scanning the string once.

LeetCode 708: Insert into a Sorted Circular Linked List

A clear explanation of inserting a value into a sorted circular linked list while preserving the circular sorted order.

LeetCode 707: Design Linked List

A clear explanation of implementing a linked list from scratch using nodes, a dummy head, and a size counter.

LeetCode 706: Design HashMap

A clear explanation of designing a hash map without using built-in hash table libraries.

LeetCode 705: Design HashSet

A clear explanation of designing a hash set without using built-in hash table libraries.

LeetCode 704: Binary Search

A clear explanation of searching for a target in a sorted array using binary search.

LeetCode 703: Kth Largest Element in a Stream

A clear explanation of maintaining the kth largest element in a stream using a fixed-size min heap.

LeetCode 702: Search in a Sorted Array of Unknown Size

A clear explanation of searching in a sorted array when the array length is hidden behind an ArrayReader interface.

LeetCode 701: Insert into a Binary Search Tree

A clear explanation of inserting a value into a binary search tree using recursive and iterative traversal.

LeetCode 750: Number Of Corner Rectangles

Count axis-aligned rectangles whose four corners are 1 using column-pair frequency counting.

LeetCode 748: Shortest Completing Word

Find the shortest word that contains all required license plate letters using frequency counting.

LeetCode 746: Min Cost Climbing Stairs

Find the minimum cost to reach the top of the staircase using dynamic programming.

LeetCode 743: Network Delay Time

Find the time needed for a signal to reach all nodes in a directed weighted graph using Dijkstra's algorithm.

LeetCode 741: Cherry Pickup

Maximize cherries collected on a round trip by converting the problem into two simultaneous forward paths and solving with dynamic programming.

LeetCode 739: Daily Temperatures

Find how many days each temperature must wait for a warmer future day using a monotonic stack.

LeetCode 738: Monotone Increasing Digits

Find the largest number less than or equal to n whose digits are monotone increasing using a greedy digit adjustment.

LeetCode 737: Sentence Similarity II

Check sentence similarity with transitive word relationships using union-find.

LeetCode 736: Parse Lisp Expression

Evaluate a Lisp-like expression with integers, variables, let bindings, addition, multiplication, and lexical scope.

LeetCode 735: Asteroid Collision

Simulate asteroid collisions using a stack that keeps the surviving asteroids in order.

LeetCode 734: Sentence Similarity

Check whether two word arrays are sentence-similar using a hash set of symmetric similar word pairs.

LeetCode 733: Flood Fill

Recolor the connected component containing the starting pixel using depth-first search.

LeetCode 732: My Calendar III

Track the maximum number of overlapping calendar events using a sweep line difference map.

LeetCode 730: Count Different Palindromic Subsequences

Count distinct non-empty palindromic subsequences using interval dynamic programming and duplicate handling.

LeetCode 729: My Calendar I

Implement a calendar that accepts a booking only when it does not overlap with any existing booking.

LeetCode 728: Self Dividing Numbers

Check each number in a range by extracting its digits and testing whether every digit divides the original number.

LeetCode 727: Minimum Window Subsequence

Find the shortest substring of s1 that contains s2 as a subsequence using dynamic programming.

LeetCode 726: Number of Atoms

Parse a chemical formula with nested parentheses, atom names, and multipliers using recursive descent.

LeetCode 197: Rising Temperature

A clear explanation of the Rising Temperature SQL problem using a self join and date comparison.

LeetCode 196: Delete Duplicate Emails

A clear explanation of the Delete Duplicate Emails SQL problem using DELETE with a self join.

LeetCode 195: Tenth Line

A clear explanation of the Tenth Line shell problem using awk, sed, head, and tail.

LeetCode 194: Transpose File

A clear explanation of the Transpose File shell problem using awk to transform rows into columns.

LeetCode 193: Valid Phone Numbers

A clear explanation of the Valid Phone Numbers shell problem using grep and regular expressions.

LeetCode 192: Word Frequency

A clear explanation of the Word Frequency shell problem using Unix text-processing tools.

LeetCode 699: Falling Squares

Simulate falling squares on a number line and track the maximum stack height after each placement.

LeetCode 698: Partition to K Equal Sum Subsets

Decide whether an array can be divided into k non-empty subsets with equal sums using backtracking and pruning.

LeetCode 697: Degree of an Array

Find the shortest contiguous subarray with the same degree as the whole array using frequency counts and first occurrence indices.

LeetCode 696: Count Binary Substrings

Count substrings with equal consecutive groups of 0s and 1s using run lengths.

LeetCode 694: Number of Distinct Islands

Count unique island shapes in a binary grid using DFS and relative coordinates.

LeetCode 693: Binary Number with Alternating Bits

Check whether every adjacent bit in a positive integer's binary representation is different.

LeetCode 691: Stickers to Spell Word

Find the minimum number of stickers needed to form a target string using top-down dynamic programming with memoization.

LeetCode 690: Employee Importance

Compute the total importance of an employee and all direct and indirect subordinates using a hash map and depth-first search.

LeetCode 689: Maximum Sum of 3 Non-Overlapping Subarrays

Find three non-overlapping subarrays of length k with maximum total sum and return the lexicographically smallest starting indices.

LeetCode 688: Knight Probability in Chessboard

Compute the probability that a knight remains on an n x n chessboard after exactly k random moves using dynamic programming.

LeetCode 686: Repeated String Match

Find the minimum number of times one string must be repeated so another string becomes a substring.

LeetCode 685: Redundant Connection II

Find the directed edge to remove so a graph becomes a rooted tree again, handling both cycles and nodes with two parents.

LeetCode 683: K Empty Slots

Find the earliest day when two turned-on bulbs have exactly k turned-off bulbs between them using a sliding window over bloom days.

LeetCode 681: Next Closest Time

Find the next valid 24-hour time using only the digits from the current time.

LeetCode 680: Valid Palindrome II

Check whether a string can become a palindrome after deleting at most one character using two pointers.

LeetCode 679: 24 Game

Determine whether four numbers can be combined with arithmetic operations and parentheses to produce 24.

LeetCode 678: Valid Parenthesis String

Check whether a string containing parentheses and wildcard stars can be made valid using a greedy range of possible open counts.

LeetCode 677: Map Sum Pairs

Design a map that supports key-value insertion and prefix-sum queries using a hash map and trie.

LeetCode 676: Implement Magic Dictionary

Design a dictionary that can check whether a word can match a stored word after changing exactly one character.

LeetCode 675: Cut Off Trees for Golf Event

A clear explanation of cutting trees in increasing height order using repeated BFS on a grid.

LeetCode 674: Longest Continuous Increasing Subsequence

A clear explanation of finding the longest strictly increasing contiguous subarray using a single scan.

LeetCode 673: Number of Longest Increasing Subsequence

A clear explanation of counting how many longest strictly increasing subsequences exist using dynamic programming.

LeetCode 672: Bulb Switcher II

A clear explanation of counting possible bulb states after pressing four toggle buttons exactly presses times.

LeetCode 671: Second Minimum Node In a Binary Tree

A clear explanation of finding the second minimum value in a special binary tree using DFS.

LeetCode 670: Maximum Swap

A clear explanation of maximizing an integer by swapping at most two digits once.

LeetCode 669: Trim a Binary Search Tree

A clear explanation of trimming a BST so that all remaining node values lie inside a given inclusive range.

LeetCode 668: Kth Smallest Number in Multiplication Table

A clear explanation of finding the kth smallest value in an m by n multiplication table using binary search on answer.

LeetCode 667: Beautiful Arrangement II

A clear explanation of constructing an array with exactly k distinct adjacent differences using a greedy pattern.

LeetCode 666: Path Sum IV

A clear explanation of computing all root-to-leaf path sums from a compact three-digit binary tree encoding.

LeetCode 665: Non-decreasing Array

A clear explanation of checking whether an array can become non-decreasing by modifying at most one element.

LeetCode 664: Strange Printer

A clear explanation of minimizing printer turns using interval dynamic programming.

LeetCode 663: Equal Tree Partition

A clear explanation of checking whether a binary tree can be split into two equal-sum trees by removing one edge.

LeetCode 662: Maximum Width of Binary Tree

A clear explanation of computing the maximum width of a binary tree using level-order traversal and complete-tree indices.

LeetCode 661: Image Smoother

A clear explanation of averaging neighboring pixels in a matrix using direct simulation.

LeetCode 659: Split Array into Consecutive Subsequences

A clear explanation of deciding whether a sorted array can be split into consecutive subsequences of length at least three.

LeetCode 658: Find K Closest Elements

A clear explanation of finding the k closest elements to a target using binary search and a sliding window.

LeetCode 657: Robot Return to Origin

A clear explanation of determining whether a robot returns to the origin after executing movement instructions.

LeetCode 656: Coin Path

A clear explanation of finding the minimum-cost path with bounded jumps, blocked cells, and lexicographic tie-breaking.

LeetCode 655: Print Binary Tree

A clear explanation of formatting a binary tree into a 2D string matrix using tree height and recursive placement.

LeetCode 654: Maximum Binary Tree

A clear explanation of constructing a maximum binary tree recursively using divide and conquer.

LeetCode 653: Two Sum IV - Input is a BST

A clear explanation of finding whether two different nodes in a binary search tree sum to a target value.

LeetCode 652: Find Duplicate Subtrees

A clear explanation of finding duplicate binary tree subtrees using postorder traversal, serialization, and a hash map.

LeetCode 651: 4 Keys Keyboard

A dynamic programming solution for maximizing the number of A characters printed with a limited number of keyboard operations.

LeetCode 650: 2 Keys Keyboard

A dynamic programming and prime factorization solution for finding the minimum operations needed to produce n characters.

LeetCode 649: Dota2 Senate

A queue-based simulation for predicting which party wins after senators ban opponents in turn order.

LeetCode 648: Replace Words

A trie-based solution for replacing each derivative word with the shortest matching root.

LeetCode 647: Palindromic Substrings

A center expansion solution for counting every palindromic substring in a string.

LeetCode 646: Maximum Length of Pair Chain

A greedy interval scheduling solution for finding the longest chain of valid pairs.

LeetCode 645: Set Mismatch

A counting and math solution for finding the duplicated number and the missing number in a corrupted set.

LeetCode 644: Maximum Average Subarray II

A binary search solution for finding the maximum average of any contiguous subarray with length at least k.

LeetCode 643: Maximum Average Subarray I

A sliding window solution for finding the maximum average among all contiguous subarrays of fixed length k.

LeetCode 642: Design Search Autocomplete System

A trie-based design for returning the top three historical sentences for a typed prefix.

LeetCode 641: Design Circular Deque

An array-based circular buffer solution for implementing a fixed-size double-ended queue.

LeetCode 640: Solve the Equation

A string parsing solution for reducing a linear equation into coefficient and constant terms.

LeetCode 639: Decode Ways II

A dynamic programming solution for counting decodings of a digit string with wildcard characters.

LeetCode 638: Shopping Offers

A DFS and memoization solution for finding the minimum cost to satisfy item needs using individual prices and reusable special offers.

LeetCode 637: Average of Levels in Binary Tree

A breadth-first search solution for computing the average value of nodes at each level of a binary tree.

LeetCode 636: Exclusive Time of Functions

A stack-based solution for computing exclusive execution time from nested start and end logs.

LeetCode 635: Design Log Storage System

A design solution for storing timestamped logs and retrieving IDs by inclusive time range at a chosen granularity.

LeetCode 634: Find the Derangement of An Array

A dynamic programming and combinatorics solution for counting permutations with no fixed positions.

LeetCode 633: Sum of Square Numbers

A two-pointer and number theory solution for checking whether an integer can be written as the sum of two square numbers.

LeetCode 632: Smallest Range Covering Elements from K Lists

A heap-based solution for finding the smallest range that contains at least one number from each sorted list.

LeetCode 631: Design Excel Sum Formula

A design solution for a small Excel-like spreadsheet that supports set, get, and dynamic sum formulas.

LeetCode 630: Course Schedule III

A greedy heap solution for taking the maximum number of courses before their deadlines.

LeetCode 629: K Inverse Pairs Array

A dynamic programming solution for counting permutations of 1 to n with exactly k inverse pairs.

LeetCode 628: Maximum Product of Three Numbers

A clear explanation of finding the largest product of three numbers using sorting or constant-space tracking.

LeetCode 616: Add Bold Tag in String

A string-marking guide for adding bold tags around all matched words while merging overlapping and adjacent bold regions.

LeetCode 611: Valid Triangle Number

A two-pointer guide for counting triplets that can form valid triangles after sorting the side lengths.

LeetCode 609: Find Duplicate File in System

A hash map guide for grouping file paths by identical file content and returning only duplicate groups.

LeetCode 606: Construct String from Binary Tree

A recursive guide for converting a binary tree into a preorder parenthesized string while preserving the one-to-one mapping between the tree and the string.

LeetCode 605: Can Place Flowers

A greedy guide for determining whether a given number of flowers can be planted without violating the no-adjacent-flowers rule.

LeetCode 604: Design Compressed String Iterator

A guide to implementing a lazy iterator over a run-length encoded string without fully decompressing it.

LeetCode 240: Search a 2D Matrix II

A clear explanation of searching a row-sorted and column-sorted matrix using the top-right corner elimination method.

LeetCode 239: Sliding Window Maximum

A clear explanation of finding the maximum value in every sliding window using a monotonic deque.

LeetCode 238: Product of Array Except Self

A clear explanation of computing each product except self using prefix and suffix products without division.

LeetCode 237: Delete Node in a Linked List

A clear explanation of deleting a node from a singly linked list when only that node is given.

LeetCode 236: Lowest Common Ancestor of a Binary Tree

A clear explanation of finding the lowest common ancestor in a normal binary tree using recursive depth-first search.

LeetCode 234: Palindrome Linked List

A clear explanation of checking whether a singly linked list is a palindrome using fast and slow pointers plus in-place reversal.

LeetCode 230: Kth Smallest Element in a BST

A clear explanation of finding the kth smallest value in a binary search tree using inorder traversal.

LeetCode 229: Majority Element II

A clear explanation of finding all elements that appear more than n/3 times using the extended Boyer-Moore voting algorithm.

LeetCode 228: Summary Ranges

A clear explanation of summarizing a sorted unique integer array into compact consecutive ranges.

LeetCode 227: Basic Calculator II

A detailed explanation of evaluating arithmetic expressions with stack-based parsing and operator precedence.

LeetCode 226: Invert Binary Tree

A clear explanation of inverting a binary tree using recursive depth-first traversal.

LeetCode 175: Combine Two Tables

A clear SQL guide for solving Combine Two Tables using LEFT JOIN.

LeetCode 50: Pow(x, n)

A clear explanation of Pow(x, n) using binary exponentiation to compute powers in logarithmic time.

LeetCode 49: Group Anagrams

A clear explanation of Group Anagrams using a hash map keyed by each word's sorted character signature.

LeetCode 48: Rotate Image

A clear explanation of Rotate Image using in-place matrix transpose and row reversal.

LeetCode 47: Permutations II

A clear explanation of Permutations II using sorting, depth-first search, and duplicate-skipping backtracking.

LeetCode 46: Permutations

A clear explanation of Permutations using depth-first search and backtracking.

LeetCode 45: Jump Game II

A clear explanation of Jump Game II using a greedy range expansion approach to find the minimum number of jumps.

LeetCode 44: Wildcard Matching

A clear explanation of Wildcard Matching using dynamic programming over string and pattern prefixes.

LeetCode 43: Multiply Strings

A clear explanation of Multiply Strings using grade-school multiplication with digit arrays.

LeetCode 42: Trapping Rain Water

A clear explanation of the Trapping Rain Water problem using left and right boundaries, then an optimized two-pointer solution.

LeetCode 41: First Missing Positive

A clear explanation of the First Missing Positive problem using in-place index placement to achieve O(n) time and O(1) extra space.

LeetCode 700: Search in a Binary Search Tree

Search for a target value in a binary search tree and return the subtree rooted at the matching node.

LeetCode 687: Longest Univalue Path

Find the longest path in a binary tree where every node on the path has the same value using depth-first search.

LeetCode 627: Swap Salary

A SQL update solution for swapping all m and f values in the Salary table using a single statement.

LeetCode 626: Exchange Seats

A SQL solution for swapping every pair of adjacent student seats while leaving the final seat unchanged when the row count is odd.

LeetCode 660: Remove 9

A clear explanation of finding the nth positive integer that does not contain the digit 9 using base-9 conversion.

LeetCode 615: Average Salary: Departments VS Company

A SQL guide for comparing each department's monthly average salary against the company's monthly average salary.

LeetCode 614: Second Degree Follower

A SQL guide for finding users who both follow someone and have followers, then counting how many followers they have.

LeetCode 613: Shortest Distance in a Line

A SQL guide for finding the minimum distance between any two unique points on the X-axis.

LeetCode 610: Triangle Judgement

A SQL guide for checking whether three side lengths can form a valid triangle using the triangle inequality.

LeetCode 607: Sales Person

A SQL guide for finding salespeople who never had an order related to the company named RED.

LeetCode 603: Consecutive Available Seats

A SQL guide for finding all cinema seats that are free and adjacent to at least one other free seat.

LeetCode 602: Friend Requests II: Who Has the Most Friends

A SQL guide for counting friendships from both requester and accepter sides, then returning the user with the most friends.

LeetCode 601: Human Traffic of Stadium

A SQL guide for finding stadium records that belong to runs of at least three consecutive ids where each row has at least 100 people.

LeetCode 600: Non-negative Integers without Consecutive Ones

A clear digit dynamic programming solution for counting numbers whose binary representation does not contain consecutive ones.

LeetCode 599: Minimum Index Sum of Two Lists

A clear hash map solution for finding common strings with the smallest index sum.

LeetCode 598: Range Addition II

A clear math solution for counting the maximum values after repeated top-left matrix increment operations.

LeetCode 594: Longest Harmonious Subsequence

A clear hash map solution for finding the longest subsequence whose maximum and minimum differ by exactly one.

LeetCode 593: Valid Square

A clear geometry solution for checking whether four unordered points form a valid square.

LeetCode 592: Fraction Addition and Subtraction

A clear parsing and math solution for evaluating fraction addition and subtraction expressions.

LeetCode 591: Tag Validator

A clear stack-based parser for validating nested XML-like tags with CDATA sections.

LeetCode 590: N-ary Tree Postorder Traversal

A clear DFS solution for returning the postorder traversal of an N-ary tree.

LeetCode 589: N-ary Tree Preorder Traversal

A clear DFS solution for returning the preorder traversal of an N-ary tree.

LeetCode 588: Design In-Memory File System

A clear design guide for implementing an in-memory file system with directory listing, directory creation, file append, and file read operations.

LeetCode 587: Erect the Fence

A clear convex hull solution for returning all trees that lie on the fence boundary.

LeetCode 583: Delete Operation for Two Strings

A clear dynamic programming solution for finding the minimum deletions needed to make two strings equal.

LeetCode 581: Shortest Unsorted Continuous Subarray

A clear linear-time solution for finding the shortest subarray that must be sorted to make the whole array sorted.

LeetCode 576: Out of Boundary Paths

A clear dynamic programming solution for counting paths that move a ball out of a grid boundary.

LeetCode 575: Distribute Candies

A clear explanation of Distribute Candies using a set to count candy types and a simple limit argument.

LeetCode 573: Squirrel Simulation

A clear explanation of Squirrel Simulation using Manhattan distance and the special first trip.

LeetCode 572: Subtree of Another Tree

A clear explanation of Subtree of Another Tree using recursive tree matching and DFS.

LeetCode 568: Maximum Vacation Days

A clear explanation of Maximum Vacation Days using dynamic programming over weeks and cities.

LeetCode 567: Permutation in String

A clear explanation of Permutation in String using a fixed-size sliding window and character frequency counts.

LeetCode 566: Reshape the Matrix

A clear explanation of Reshape the Matrix using index mapping from the original matrix to the reshaped matrix.

LeetCode 565: Array Nesting

A clear explanation of Array Nesting using cycle detection over a permutation.

LeetCode 564: Find the Closest Palindrome

A clear explanation of Find the Closest Palindrome using prefix mirroring and a small candidate set.

LeetCode 563: Binary Tree Tilt

A clear explanation of Binary Tree Tilt using postorder DFS to compute subtree sums and accumulate tilt.

LeetCode 562: Longest Line of Consecutive One in Matrix

A clear explanation of Longest Line of Consecutive One in Matrix using dynamic programming over four directions.

LeetCode 561: Array Partition

A clear explanation of Array Partition using sorting and adjacent pairing to maximize the sum of pair minimums.

LeetCode 560: Subarray Sum Equals K

A clear explanation of Subarray Sum Equals K using prefix sums and a hash map to count matching subarrays in linear time.

LeetCode 559: Maximum Depth of N-ary Tree

A clear explanation of Maximum Depth of N-ary Tree using recursive depth-first search.

LeetCode 556: Next Greater Element III

A clear explanation of Next Greater Element III using the next permutation algorithm on the digits of an integer.

LeetCode 555: Split Concatenated Strings

A clear explanation of Split Concatenated Strings using string reversal choices and enumeration of every possible cut point.

LeetCode 554: Brick Wall

A clear explanation of Brick Wall using prefix sums and a hash map to find the best vertical cut position.

LeetCode 553: Optimal Division

A clear explanation of Optimal Division using the structure of division expressions to build the maximum-value expression.

LeetCode 552: Student Attendance Record II

A clear explanation of Student Attendance Record II using dynamic programming over absence count and late streak.

LeetCode 551: Student Attendance Record I

A clear explanation of Student Attendance Record I using simple string checks and a one-pass counter solution.

LeetCode 547: Number of Provinces

A clear explanation of counting connected components in an undirected graph represented by an adjacency matrix.

LeetCode 546: Remove Boxes

A clear explanation of maximizing remove-box scores using interval dynamic programming with memoization.

LeetCode 544: Output Contest Matches

A clear explanation of building the final tournament bracket by repeatedly pairing strongest and weakest teams.

LeetCode 543: Diameter of Binary Tree

A clear explanation of finding the longest path between any two nodes in a binary tree using DFS height computation.

LeetCode 542: 01 Matrix

A clear explanation of computing the distance to the nearest zero in a binary matrix using multi-source BFS.

LeetCode 541: Reverse String II

A clear explanation of reversing the first k characters in every 2k block of a string.

LeetCode 540: Single Element in a Sorted Array

A clear explanation of finding the only non-duplicate element in a sorted array using binary search.

LeetCode 539: Minimum Time Difference

A clear explanation of finding the minimum difference between 24-hour clock times using minute conversion and sorting.

LeetCode 538: Convert BST to Greater Tree

A clear explanation of converting a BST into a greater tree using reverse inorder traversal and a running sum.

LeetCode 537: Complex Number Multiplication

A clear explanation of multiplying complex numbers represented as strings using algebraic expansion.

LeetCode 536: Construct Binary Tree from String

A clear explanation of parsing a parenthesized string recursively to construct a binary tree.

LeetCode 535: Encode and Decode TinyURL

A clear explanation of designing a simple URL encoder and decoder using a hash map and generated keys.

LeetCode 533: Lonely Pixel II

A clear explanation of counting black lonely pixels using row counts, column counts, and duplicate row patterns.

LeetCode 532: K-diff Pairs in an Array

A clear explanation of counting unique pairs whose absolute difference is k using frequency counting.

LeetCode 531: Lonely Pixel I

A clear explanation of counting black pixels that are alone in both their row and column.

LeetCode 530: Minimum Absolute Difference in BST

A clear explanation of finding the minimum difference between two BST node values using inorder traversal.

LeetCode 529: Minesweeper

A clear explanation of updating a Minesweeper board using DFS flood fill and adjacent mine counting.

LeetCode 528: Random Pick with Weight

A clear explanation of weighted random sampling using prefix sums and binary search.

LeetCode 527: Word Abbreviation

A clear explanation of generating minimal unique word abbreviations using grouping and trie prefixes.

LeetCode 526: Beautiful Arrangement

A clear explanation of counting beautiful arrangements using backtracking and divisibility pruning.

LeetCode 525: Contiguous Array

A clear explanation of finding the longest contiguous subarray with equal numbers of 0 and 1 using prefix sums and a hash map.

LeetCode 522: Longest Uncommon Subsequence II

A clear explanation of finding the longest uncommon subsequence among many strings using subsequence checks.

LeetCode 518: Coin Change II

A clear explanation of counting coin-change combinations using dynamic programming.

LeetCode 517: Super Washing Machines

A clear explanation of balancing dresses across washing machines using greedy prefix flow.

LeetCode 514: Freedom Trail

A clear explanation of finding the minimum steps to spell a key on a circular ring using dynamic programming and memoized DFS.

LeetCode 513: Find Bottom Left Tree Value

A clear explanation of finding the leftmost value in the deepest row of a binary tree using level-order traversal.

LeetCode 508: Most Frequent Subtree Sum

A clear explanation of finding the most frequent subtree sum in a binary tree using postorder DFS and a frequency map.

LeetCode 506: Relative Ranks

A clear explanation of assigning athlete ranks from scores using sorting while preserving original indices.

LeetCode 503: Next Greater Element II

A clear explanation of finding the next greater element in a circular array using a monotonic stack.

LeetCode 502: IPO

A clear explanation of maximizing capital by selecting at most k projects using sorting and a max heap.

LeetCode 501: Find Mode in Binary Search Tree

A clear explanation of finding the most frequent value or values in a binary search tree using inorder traversal.

LeetCode 520: Detect Capital

A clear explanation of checking whether a word uses capital letters correctly by counting uppercase letters.

LeetCode 516: Longest Palindromic Subsequence

A clear explanation of finding the length of the longest palindromic subsequence using interval dynamic programming.

LeetCode 512: Game Play Analysis II

A clear explanation of finding the first device used by each player using SQL aggregation and a join.

LeetCode 511: Game Play Analysis I

A clear explanation of finding each player's first login date using SQL aggregation.

LeetCode 509: Fibonacci Number

A clear explanation of computing Fibonacci numbers using dynamic programming and iterative state transitions.

LeetCode 597: Friend Requests I: Overall Acceptance Rate

A clear SQL guide for computing the overall friend request acceptance rate with duplicate pairs counted once.

LeetCode 596: Classes With at Least 5 Students

A clear SQL guide for finding classes that have at least five students.

LeetCode 595: Big Countries

A clear SQL guide for finding countries with either large area or large population.

LeetCode 586: Customer Placing the Largest Number of Orders

A clear SQL guide for finding the customer who placed the most orders.

LeetCode 585: Investments in 2016

A clear SQL guide for summing 2016 investments for policies with repeated 2015 investment values and unique locations.

LeetCode 584: Find Customer Referee

A clear SQL guide for selecting customers who were not referred by customer 2, including customers with no referee.

LeetCode 580: Count Student Number in Departments

A clear SQL guide for counting students in every department, including departments with zero students.

LeetCode 579: Find Cumulative Salary of an Employee

A clear SQL guide for computing each employee's 3-month cumulative salary while excluding their most recent month.

LeetCode 578: Get Highest Answer Rate Question

A clear SQL guide for finding the question with the highest answer rate from survey logs.

LeetCode 577: Employee Bonus

A clear SQL guide for finding employees whose bonus is less than 1000 or missing.

LeetCode 574: Winning Candidate

A clear explanation of Winning Candidate using SQL aggregation to count votes and return the candidate with the most votes.

LeetCode 571: Find Median Given Frequency of Numbers

A clear explanation of Find Median Given Frequency of Numbers using cumulative frequency and SQL window functions.

LeetCode 570: Managers with at Least 5 Direct Reports

A clear explanation of Managers with at Least 5 Direct Reports using grouping and a self join.

LeetCode 569: Median Employee Salary

A clear explanation of Median Employee Salary using SQL window functions to rank employees inside each company.

LeetCode 550: Game Play Analysis IV

A clear explanation of calculating the fraction of players who logged in again the day after their first login.

LeetCode 534: Game Play Analysis III

A clear explanation of computing cumulative games played per player and date using SQL window functions.

LeetCode 500: Keyboard Row

A clear explanation of filtering words that can be typed using only one row of an American keyboard.

LeetCode 499: The Maze III

A clear explanation of finding the shortest rolling-ball path to the hole using Dijkstra with lexicographic tie-breaking.

LeetCode 498: Diagonal Traverse

A clear explanation of returning matrix elements in diagonal zigzag order by grouping cells with the same row plus column index.

LeetCode 497: Random Point in Non-overlapping Rectangles

A clear explanation of uniformly picking an integer point from non-overlapping rectangles using prefix sums and binary search.

LeetCode 496: Next Greater Element I

A clear explanation of finding the next greater element using a monotonic decreasing stack and hash map.

LeetCode 495: Teemo Attacking

A clear explanation of calculating total poisoned duration by merging overlapping attack intervals.

LeetCode 494: Target Sum

A clear explanation of counting sign assignments that reach a target using recursion first, then subset-sum dynamic programming.

LeetCode 493: Reverse Pairs

A clear explanation of counting pairs where nums[i] is greater than twice nums[j] using merge sort.

LeetCode 492: Construct the Rectangle

A clear explanation of finding rectangle dimensions with a fixed area and the smallest length-width difference.

LeetCode 491: Non-decreasing Subsequences

A clear explanation of generating all distinct non-decreasing subsequences using DFS, backtracking, and per-level duplicate control.

LeetCode 490: The Maze

A clear explanation of deciding whether a rolling ball can stop at the destination using BFS or DFS over stopping cells.

LeetCode 489: Robot Room Cleaner

A clear explanation of cleaning an unknown grid using DFS, relative coordinates, and physical backtracking.

LeetCode 488: Zuma Game

A clear explanation of solving Zuma Game with DFS, memoization, and chain-removal simulation.

LeetCode 487: Max Consecutive Ones II

A clear explanation of finding the longest run of 1s after flipping at most one 0 using a sliding window.

LeetCode 486: Predict the Winner

A clear explanation of predicting whether Player 1 can win using minimax dynamic programming over score difference.

LeetCode 485: Max Consecutive Ones

A clear explanation of finding the longest streak of 1s in a binary array with a single pass.

LeetCode 484: Find Permutation

A clear explanation of constructing the lexicographically smallest permutation that matches an I and D pattern.

LeetCode 483: Smallest Good Base

A clear explanation of finding the smallest base where n is written as all ones using geometric series and binary search.

LeetCode 482: License Key Formatting

A clear explanation of reformatting a license key by removing dashes, uppercasing characters, and grouping from the right.

LeetCode 481: Magical String

A clear explanation of constructing the magical string by using the string itself as run-length instructions.

LeetCode 480: Sliding Window Median

A clear explanation of maintaining the median of each fixed-size window using two heaps and lazy deletion.

LeetCode 479: Largest Palindrome Product

A clear explanation of finding the largest palindrome made from the product of two n-digit numbers by generating palindrome candidates directly.

LeetCode 478: Generate Random Point in a Circle

A clear explanation of generating uniformly random points inside a circle using polar coordinates.

LeetCode 477: Total Hamming Distance

A clear explanation of computing the total Hamming distance across all pairs by counting different bits column by column.

LeetCode 476: Number Complement

A clear explanation of finding the bitwise complement of a positive integer using a binary mask.

LeetCode 475: Heaters

A clear explanation of finding the minimum heater radius by sorting positions and matching each house to its nearest heater.

LeetCode 474: Ones and Zeroes

A clear explanation of solving the largest subset problem as a two-dimensional 0/1 knapsack over zero and one counts.

LeetCode 473: Matchsticks to Square

A clear explanation of deciding whether matchsticks can form a square using backtracking, sorting, and pruning.

LeetCode 472: Concatenated Words

A clear explanation of finding all words that can be formed by concatenating at least two shorter words from the same list.

LeetCode 471: Encode String with Shortest Length

A clear explanation of interval dynamic programming for encoding a string into the shortest k[encoded_string] form.

LeetCode 470: Implement Rand10() Using Rand7()

A clear explanation of generating a uniform random integer from 1 to 10 using only rand7 and rejection sampling.

LeetCode 469: Convex Polygon

A clear explanation of checking whether ordered points form a convex polygon using cross products.

LeetCode 468: Validate IP Address

A clear explanation of validating IPv4 and IPv6 addresses by checking segment count, length, characters, range, and leading-zero rules.

LeetCode 467: Unique Substrings in Wraparound String

A clear explanation of counting unique substrings that appear in the infinite alphabet wraparound string using dynamic programming by ending character.

LeetCode 466: Count The Repetitions

A clear explanation of counting how many repeated copies of one string can be obtained as a subsequence of another repeated string.

LeetCode 465: Optimal Account Balancing

A clear explanation of minimizing debt-settlement transactions using net balances, backtracking, and memoization-style pruning.

LeetCode 464: Can I Win

A clear explanation of solving the Can I Win game using minimax recursion, bitmask state compression, and memoization.

LeetCode 463: Island Perimeter

A clear explanation of counting the perimeter of an island in a grid by adding land-cell edges and subtracting shared edges.

LeetCode 462: Minimum Moves to Equal Array Elements II

A clear explanation of why the median minimizes the number of moves needed to make all array elements equal.

LeetCode 461: Hamming Distance

A clear explanation of computing the Hamming distance between two integers using XOR and bit counting.

LeetCode 460: LFU Cache

A clear explanation of designing an LFU cache with O(1) average get and put operations.

LeetCode 459: Repeated Substring Pattern

A clear explanation of checking whether a string can be built by repeating one of its proper substrings.

LeetCode 458: Poor Pigs

A clear explanation of the combinatorics behind finding the minimum number of pigs needed to identify the poisonous bucket.

LeetCode 457: Circular Array Loop

A clear explanation of detecting a valid cycle in a circular array using fast and slow pointers.

LeetCode 456: 132 Pattern

A clear explanation of detecting a 132 pattern using reverse traversal and a monotonic stack.

LeetCode 455: Assign Cookies

A clear explanation of the greedy two-pointer solution for maximizing the number of content children.

LeetCode 454: 4Sum II

A clear explanation of counting zero-sum tuples across four arrays using pair sums and a hash map.

LeetCode 453: Minimum Moves to Equal Array Elements

A clear explanation of the math behind making all array elements equal by incrementing n - 1 elements at a time.

LeetCode 452: Minimum Number of Arrows to Burst Balloons

A clear explanation of the greedy interval solution for finding the minimum number of arrows needed to burst all balloons.

LeetCode 451: Sort Characters By Frequency

A clear explanation of sorting characters by decreasing frequency using a hash map and sorting.

LeetCode 450: Delete Node in a BST

Delete a node from a binary search tree while preserving the BST property using recursive search and inorder successor replacement.

LeetCode 449: Serialize and Deserialize BST

Serialize a binary search tree compactly with preorder traversal and rebuild it using BST value bounds.

LeetCode 448: Find All Numbers Disappeared in an Array

Find all missing numbers from 1 to n in O(n) time using in-place index marking.

LeetCode 447: Number of Boomerangs

Count ordered boomerang tuples by fixing each point as the center and grouping other points by squared distance.

LeetCode 446: Arithmetic Slices II - Subsequence

Count arithmetic subsequences of length at least three using dynamic programming with one hash map per ending index.

LeetCode 445: Add Two Numbers II

Add two numbers stored in forward-order linked lists using stacks and carry propagation.

LeetCode 444: Sequence Reconstruction

Check whether nums is the unique shortest supersequence of given subsequences using topological sorting.

LeetCode 443: String Compression

Compress a character array in-place using two pointers and grouped character counting.

LeetCode 442: Find All Duplicates in an Array

Find all duplicated numbers in an array in O(n) time and O(1) extra space using index marking.

LeetCode 441: Arranging Coins

Find the maximum number of complete staircase rows that can be formed using binary search and triangular numbers.

LeetCode 440: K-th Smallest in Lexicographical Order

Find the k-th integer in lexicographical order without generating all numbers, using prefix counting over a conceptual trie.

LeetCode 439: Ternary Expression Parser

Evaluate a nested ternary expression using a right-to-left stack parser.

LeetCode 438: Find All Anagrams in a String

Find all starting indices where an anagram of p appears in s using a fixed-size sliding window.

LeetCode 437: Path Sum III

Count downward paths in a binary tree whose values sum to targetSum using DFS and prefix sums.

LeetCode 436: Find Right Interval

Find, for each interval, the interval with the smallest start point greater than or equal to its end point using sorting and binary search.

LeetCode 435: Non-overlapping Intervals

Remove the minimum number of intervals so the remaining intervals do not overlap, using greedy sorting by end time.

LeetCode 433: Minimum Genetic Mutation

Find the minimum number of valid one-character gene mutations using breadth-first search.

LeetCode 432: All O'one Data Structure

Design a data structure that supports increment, decrement, get minimum key, and get maximum key in average O(1) time.

LeetCode 430: Flatten a Multilevel Doubly Linked List

Flatten a multilevel doubly linked list in-place using depth-first traversal and pointer splicing.

LeetCode 428: Serialize and Deserialize N-ary Tree

Serialize an N-ary tree into a string and reconstruct the same tree using preorder traversal with child counts.

LeetCode 427: Construct Quad Tree

Build a quad tree from a binary square grid using recursive divide and conquer.

LeetCode 426: Convert Binary Search Tree to Sorted Doubly Linked List

Convert a BST into a sorted circular doubly linked list in-place using inorder traversal.

LeetCode 425: Word Squares

A clear explanation of building all word squares using backtracking with prefix pruning.

LeetCode 424: Longest Repeating Character Replacement

A clear explanation of finding the longest substring that can become all one letter using a sliding window.

LeetCode 423: Reconstruct Original Digits from English

A clear explanation of reconstructing digits from shuffled English words using character frequency counts and unique identifying letters.

LeetCode 422: Valid Word Square

A clear explanation of checking whether rows and columns read the same using direct index comparison.

LeetCode 421: Maximum XOR of Two Numbers in an Array

A clear explanation of finding the maximum XOR of two numbers using greedy bit prefixes.

LeetCode 417: Pacific Atlantic Water Flow

A clear explanation of finding cells that can flow to both oceans using reverse graph traversal from the borders.

LeetCode 416: Partition Equal Subset Sum

A clear explanation of deciding whether an array can be split into two equal-sum subsets using 0/1 knapsack dynamic programming.

LeetCode 415: Add Strings

A clear explanation of adding two non-negative integer strings using manual digit-by-digit simulation.

LeetCode 414: Third Maximum Number

A clear explanation of finding the third distinct maximum number using one pass and constant space.

LeetCode 412: Fizz Buzz

A clear explanation of the Fizz Buzz problem using direct simulation and divisibility checks.

LeetCode 411: Minimum Unique Word Abbreviation

A clear explanation of finding the shortest abbreviation that does not conflict with any dictionary word using bit masks.

LeetCode 409: Longest Palindrome

A clear explanation of finding the longest palindrome length that can be built from given letters using character counts.

LeetCode 407: Trapping Rain Water II

A clear explanation of trapping rain water in a 2D elevation map using a min heap and boundary expansion.

LeetCode 404: Sum of Left Leaves

A clear explanation of the Sum of Left Leaves problem using depth-first traversal of a binary tree.

LeetCode 403: Frog Jump

A clear explanation of the Frog Jump problem using dynamic programming with reachable jump sizes.

LeetCode 420: Strong Password Checker

A clear explanation of checking the minimum edits needed to make a password strong using greedy handling of length, missing character types, and repeated runs.

LeetCode 410: Split Array Largest Sum

A clear explanation of minimizing the largest subarray sum using binary search on the answer and greedy validation.

LeetCode 408: Valid Word Abbreviation

A clear explanation of validating a word abbreviation using two pointers and number parsing.

LeetCode 406: Queue Reconstruction by Height

A clear explanation of reconstructing a queue using greedy sorting and indexed insertion.

LeetCode 405: Convert a Number to Hexadecimal

A clear explanation of converting integers to hexadecimal using bit manipulation and two's complement representation.

LeetCode 402: Remove K Digits

A clear explanation of the Remove K Digits problem using a greedy monotonic stack.

LeetCode 401: Binary Watch

A clear explanation of the Binary Watch problem using bit counting over all valid times.

LeetCode 400: Nth Digit

A clear explanation of finding the nth digit in the infinite integer sequence using digit groups and arithmetic.

LeetCode 398: Random Pick Index

A clear explanation of picking a uniformly random index for a target value using reservoir sampling, with an alternative hash map approach.

LeetCode 397: Integer Replacement

A clear explanation of reducing an integer to 1 with the fewest operations using greedy bit decisions.

LeetCode 396: Rotate Function

A clear explanation of maximizing the rotation function using a recurrence instead of simulating every rotation.

LeetCode 395: Longest Substring with At Least K Repeating Characters

A clear explanation of finding the longest substring where every character appears at least k times using divide and conquer.

LeetCode 394: Decode String

A clear explanation of decoding nested repeat expressions using a stack.

LeetCode 393: UTF-8 Validation

A clear explanation of validating a byte sequence as UTF-8 using bit masks and a continuation-byte counter.

LeetCode 392: Is Subsequence

A clear explanation of checking whether one string is a subsequence of another using two pointers.

LeetCode 391: Perfect Rectangle

A clear explanation of checking whether many small axis-aligned rectangles form one exact rectangular cover using area and corner parity.

LeetCode 390: Elimination Game

A clear explanation of finding the last remaining number after alternating left-to-right and right-to-left eliminations.

LeetCode 389: Find the Difference

A clear explanation of finding the extra character added to a shuffled string using counting and XOR.

LeetCode 388: Longest Absolute File Path

A clear explanation of computing the longest absolute path to a file from a serialized file system string using path lengths by depth.

LeetCode 387: First Unique Character in a String

A clear explanation of finding the first non-repeating character in a string using character frequency counting.

LeetCode 386: Lexicographical Numbers

A clear explanation of generating numbers from 1 to n in lexicographical order using an iterative DFS-style traversal.

LeetCode 385: Mini Parser

A clear explanation of parsing a serialized nested integer string using a stack.

LeetCode 384: Shuffle an Array

A clear explanation of shuffling an array uniformly using the Fisher-Yates algorithm while supporting reset.

LeetCode 383: Ransom Note

A clear explanation of checking whether one string can be constructed from another using character frequency counting.

LeetCode 382: Linked List Random Node

A clear explanation of selecting a random linked list node with equal probability using reservoir sampling.

LeetCode 381: Insert Delete GetRandom O(1) - Duplicates Allowed

A clear explanation of designing a randomized multiset with average O(1) insert, remove, and getRandom operations.

LeetCode 380: Insert Delete GetRandom O(1)

A clear explanation of designing a randomized set with average O(1) insert, remove, and getRandom operations.

LeetCode 379: Design Phone Directory

A clear explanation of designing a phone directory that can allocate, check, and release numbers efficiently.

LeetCode 378: Kth Smallest Element in a Sorted Matrix

A clear explanation of finding the kth smallest value in a row-sorted and column-sorted matrix using binary search on values.

LeetCode 377: Combination Sum IV

A clear explanation of Combination Sum IV using dynamic programming to count ordered combinations that sum to a target.

LeetCode 376: Wiggle Subsequence

A clear explanation of the Wiggle Subsequence problem using dynamic programming intuition and an optimized greedy solution.

LeetCode 375: Guess Number Higher or Lower II

A clear explanation of finding the minimum guaranteed cost using interval dynamic programming.

LeetCode 374: Guess Number Higher or Lower

A clear explanation of finding the picked number using binary search and the guess API.

LeetCode 371: Sum of Two Integers

A clear explanation of adding two integers without using plus or minus by using XOR, AND, carry, and a 32-bit mask.

LeetCode 370: Range Addition

A clear explanation of applying many range updates efficiently using a difference array and prefix sums.

LeetCode 369: Plus One Linked List

A clear explanation of adding one to a number stored as a linked list using the rightmost non-nine digit.

LeetCode 368: Largest Divisible Subset

A clear explanation of finding the largest subset where every pair is divisible using sorting, dynamic programming, and parent reconstruction.

LeetCode 367: Valid Perfect Square

A clear explanation of checking whether an integer is a perfect square using binary search without sqrt.

LeetCode 366: Find Leaves of Binary Tree

A clear explanation of grouping binary tree nodes by the round in which they become leaves using postorder DFS.

LeetCode 365: Water and Jug Problem

A clear explanation of solving the Water and Jug Problem using Bézout's identity and greatest common divisor.

LeetCode 364: Nested List Weight Sum II

A clear explanation of computing inverse depth weighted sum using level-order traversal.

LeetCode 363: Max Sum of Rectangle No Larger Than K

A clear explanation of reducing a 2D rectangle problem to a 1D prefix-sum problem with binary search.

LeetCode 362: Design Hit Counter

A clear explanation of designing a hit counter for the last 5 minutes using a queue with compressed timestamps.

LeetCode 361: Bomb Enemy

A clear explanation of finding the best bomb placement in a grid using cached row and column segment counts.

LeetCode 360: Sort Transformed Array

A clear explanation of sorting values after applying a quadratic function using two pointers.

LeetCode 359: Logger Rate Limiter

A clear explanation of designing a logger that prints each message at most once every 10 seconds using a hash map.

LeetCode 358: Rearrange String k Distance Apart

A clear explanation of rearranging a string so equal characters are at least k positions apart using a heap and cooldown queue.

LeetCode 357: Count Numbers with Unique Digits

A clear explanation of counting numbers with unique digits using combinatorics.

LeetCode 356: Line Reflection

A clear explanation of checking whether 2D points are symmetric around a vertical line using min and max x-coordinates.

LeetCode 355: Design Twitter

A clear explanation of implementing a simplified Twitter using hash maps, sets, timestamps, and a heap.

LeetCode 354: Russian Doll Envelopes

A clear explanation of solving Russian Doll Envelopes using sorting and longest increasing subsequence.

LeetCode 353: Design Snake Game

A clear explanation of implementing Snake Game with a deque for body order and a set for constant-time collision checks.

LeetCode 352: Data Stream as Disjoint Intervals

A clear explanation of maintaining disjoint sorted intervals from a stream using insertion and merging.

LeetCode 351: Android Unlock Patterns

A clear explanation of Android Unlock Patterns using backtracking, a jump table, and symmetry optimization.

LeetCode 350: Intersection of Two Arrays II

A clear explanation of Intersection of Two Arrays II using frequency counting.

LeetCode 349: Intersection of Two Arrays

A clear explanation of Intersection of Two Arrays using hash sets for uniqueness and fast lookup.

LeetCode 348: Design Tic-Tac-Toe

A clear explanation of Design Tic-Tac-Toe using row, column, and diagonal counters for constant-time winner checks.

LeetCode 347: Top K Frequent Elements

A clear explanation of Top K Frequent Elements using frequency counting and bucket sort.

LeetCode 346: Moving Average from Data Stream

A clear explanation of Moving Average from Data Stream using a queue and rolling sum.

LeetCode 345: Reverse Vowels of a String

A clear explanation of Reverse Vowels of a String using two pointers and selective swaps.

LeetCode 344: Reverse String

A clear explanation of Reverse String using two pointers and in-place swaps.

LeetCode 343: Integer Break

A clear explanation of Integer Break using dynamic programming, with a note on the greedy math solution.

LeetCode 341: Flatten Nested List Iterator

A clear explanation of Flatten Nested List Iterator using lazy stack-based flattening.

LeetCode 340: Longest Substring with At Most K Distinct Characters

A clear explanation of Longest Substring with At Most K Distinct Characters using a sliding window and character counts.

LeetCode 339: Nested List Weight Sum

A clear explanation of Nested List Weight Sum using depth-first search over a nested structure.

LeetCode 338: Counting Bits

A clear explanation of Counting Bits using dynamic programming and bit manipulation.

LeetCode 337: House Robber III

A clear explanation of House Robber III using tree dynamic programming with rob and skip states.

LeetCode 336: Palindrome Pairs

A clear explanation of Palindrome Pairs using reversed-word lookup and palindrome split checks.

LeetCode 335: Self Crossing

A clear explanation of Self Crossing using constant-space checks for the only possible crossing patterns.

LeetCode 334: Increasing Triplet Subsequence

A clear explanation of Increasing Triplet Subsequence using greedy tracking of two minimum values.

LeetCode 333: Largest BST Subtree

A clear explanation of Largest BST Subtree using postorder traversal and subtree state propagation.

LeetCode 332: Reconstruct Itinerary

A clear explanation of Reconstruct Itinerary using a directed graph and Hierholzer's algorithm.

LeetCode 331: Verify Preorder Serialization of a Binary Tree

A clear explanation of verifying preorder serialization using slot counting without reconstructing the tree.

LeetCode 330: Patching Array

A clear explanation of Patching Array using a greedy smallest-missing-sum invariant.

LeetCode 329: Longest Increasing Path in a Matrix

A clear explanation of Longest Increasing Path in a Matrix using DFS with memoization.

LeetCode 328: Odd Even Linked List

A clear explanation of Odd Even Linked List using in-place pointer rewiring.

LeetCode 327: Count of Range Sum

A clear explanation of Count of Range Sum using prefix sums and merge sort counting.

LeetCode 326: Power of Three

A clear explanation of the Power of Three problem using repeated division and integer arithmetic.

LeetCode 325: Maximum Size Subarray Sum Equals k

A clear explanation of Maximum Size Subarray Sum Equals k using prefix sums and earliest-index hashing.

LeetCode 321: Create Maximum Number

A clear explanation of Create Maximum Number using monotonic stacks for subsequences and greedy merging.

LeetCode 320: Generalized Abbreviation

A clear explanation of Generalized Abbreviation using backtracking to choose whether each character is kept or abbreviated.

LeetCode 319: Bulb Switcher

A clear explanation of Bulb Switcher using divisor parity and perfect squares.

LeetCode 318: Maximum Product of Word Lengths

A clear explanation of Maximum Product of Word Lengths using bit masks to test disjoint character sets efficiently.

LeetCode 317: Shortest Distance from All Buildings

A clear explanation of Shortest Distance from All Buildings using BFS from each building with distance and reach accumulation.

LeetCode 316: Remove Duplicate Letters

A clear explanation of Remove Duplicate Letters using a greedy monotonic stack.

LeetCode 315: Count of Smaller Numbers After Self

A clear explanation of Count of Smaller Numbers After Self using coordinate compression and a Fenwick Tree.

LeetCode 314: Binary Tree Vertical Order Traversal

A clear explanation of Binary Tree Vertical Order Traversal using BFS with column indices.

LeetCode 313: Super Ugly Number

A clear explanation of Super Ugly Number using dynamic programming with one pointer per prime.

LeetCode 312: Burst Balloons

A clear explanation of Burst Balloons using interval dynamic programming and the last-burst idea.

LeetCode 311: Sparse Matrix Multiplication

A clear explanation of Sparse Matrix Multiplication using non-zero entries to avoid wasted work.

LeetCode 310: Minimum Height Trees

A clear explanation of Minimum Height Trees using leaf trimming to find the center of a tree.

LeetCode 309: Best Time to Buy and Sell Stock with Cooldown

A clear explanation of Best Time to Buy and Sell Stock with Cooldown using dynamic programming states.

LeetCode 308: Range Sum Query 2D - Mutable

A clear explanation of Range Sum Query 2D - Mutable using a 2D Fenwick Tree for efficient updates and rectangle sum queries.

LeetCode 306: Additive Number

A clear explanation of Additive Number using split enumeration and deterministic checking.

LeetCode 303: Range Sum Query - Immutable

A clear explanation of Range Sum Query - Immutable using prefix sums for constant-time range queries.

LeetCode 302: Smallest Rectangle Enclosing Black Pixels

A clear explanation of Smallest Rectangle Enclosing Black Pixels using binary search on rows and columns.

LeetCode 301: Remove Invalid Parentheses

A clear explanation of Remove Invalid Parentheses using BFS to guarantee the minimum number of removals.

LeetCode 300: Longest Increasing Subsequence

A dynamic programming and patience sorting solution for finding the longest strictly increasing subsequence in an array.

LeetCode 299: Bulls and Cows

A counting solution for producing the Bulls and Cows hint while handling duplicate digits correctly.

LeetCode 298: Binary Tree Longest Consecutive Sequence

A DFS solution for finding the longest parent-to-child path where each node value increases by exactly one.

LeetCode 297: Serialize and Deserialize Binary Tree

A preorder DFS codec for converting a binary tree to a string and reconstructing the same tree from that string.

LeetCode 296: Best Meeting Point

A median-based solution for minimizing total Manhattan distance in a grid.

LeetCode 295: Find Median from Data Stream

A two-heap data structure for adding numbers from a stream and returning the current median in constant time.

LeetCode 294: Flip Game II

A recursive game theory solution with memoization for deciding whether the starting player can force a win.

LeetCode 293: Flip Game

A simple string scanning solution for generating every possible next state after flipping one consecutive ++ pair into --.

LeetCode 292: Nim Game

A game theory solution for deciding whether the first player can win by using the losing-position pattern of multiples of four.

LeetCode 291: Word Pattern II

A backtracking solution for matching a pattern string to a target string using a bijective character-to-substring mapping.

LeetCode 290: Word Pattern

A hash map solution for checking whether a pattern string and a space-separated word string form a bijection.

LeetCode 289: Game of Life

An in-place matrix simulation for computing the next state of Conway's Game of Life using temporary encoded states.

LeetCode 288: Unique Word Abbreviation

A hash map design for checking whether a word's abbreviation is unique in a dictionary.

LeetCode 287: Find the Duplicate Number

A Floyd cycle detection solution for finding the repeated number without modifying the array and using constant extra space.

LeetCode 286: Walls and Gates

A multi-source BFS solution for filling each empty room with its shortest distance to the nearest gate.

LeetCode 285: Inorder Successor in BST

A binary-search-style solution for finding the smallest node greater than p in a binary search tree.

LeetCode 281: Zigzag Iterator

A queue-based iterator design for returning elements from two vectors in alternating order, with a clean extension to k vectors.

LeetCode 280: Wiggle Sort

A greedy in-place solution for rearranging an array into a non-strict wiggle pattern.

LeetCode 279: Perfect Squares

A dynamic programming solution for finding the least number of perfect square numbers that sum to n.

LeetCode 278: First Bad Version

A binary search solution for finding the first bad version while minimizing calls to the isBadVersion API.

LeetCode 277: Find the Celebrity

A two-pass solution for finding a celebrity using the knows API with O(n) calls and O(1) extra space.

LeetCode 276: Paint Fence

A dynamic programming solution for counting ways to paint fence posts with no more than two adjacent posts sharing the same color.

LeetCode 275: H-Index II

A clear explanation of the H-Index II problem using binary search on a sorted citations array.

LeetCode 274: H-Index

A clear explanation of the H-Index problem using sorting, then an optimized counting approach.

LeetCode 273: Integer to English Words

A clear explanation of the Integer to English Words problem using three-digit chunks and scale words.

LeetCode 272: Closest Binary Search Tree Value II

A clear explanation of the Closest Binary Search Tree Value II problem using inorder traversal and a fixed-size sliding window.

LeetCode 271: Encode and Decode Strings

A clear explanation of the Encode and Decode Strings problem using length-prefix encoding.

LeetCode 270: Closest Binary Search Tree Value

A clear explanation of the Closest Binary Search Tree Value problem using the BST property to walk toward the target.

LeetCode 269: Alien Dictionary

A clear explanation of the Alien Dictionary problem using graph construction and topological sorting.

LeetCode 268: Missing Number

A clear explanation of the Missing Number problem using sum formula and XOR.

LeetCode 267: Palindrome Permutation II

A clear explanation of the Palindrome Permutation II problem using character counts and backtracking over half of the palindrome.

LeetCode 266: Palindrome Permutation

A clear explanation of the Palindrome Permutation problem using character parity counting.

LeetCode 264: Ugly Number II

A clear explanation of the Ugly Number II problem using dynamic programming with three pointers.

LeetCode 263: Ugly Number

A clear explanation of the Ugly Number problem using repeated division by the only allowed prime factors.

LeetCode 261: Graph Valid Tree

A clear explanation of the Graph Valid Tree problem using Union Find to detect cycles and verify connectivity.

LeetCode 258: Add Digits

A clear explanation of the Add Digits problem using repeated digit sums first, then the digital root formula.

LeetCode 257: Binary Tree Paths

A clear explanation of the Binary Tree Paths problem using DFS backtracking to collect every root-to-leaf path.

LeetCode 256: Paint House

A clear explanation of the Paint House problem using dynamic programming with constant space.

LeetCode 255: Verify Preorder Sequence in Binary Search Tree

A clear explanation of the Verify Preorder Sequence in Binary Search Tree problem using a monotonic stack and lower bound tracking.

LeetCode 254: Factor Combinations

A clear explanation of the Factor Combinations problem using DFS backtracking with non-decreasing factors.

LeetCode 253: Meeting Rooms II

A clear explanation of the Meeting Rooms II problem using a min heap to track active meeting end times.

LeetCode 252: Meeting Rooms

A clear explanation of the Meeting Rooms problem using interval sorting to detect overlaps.

LeetCode 251: Flatten 2D Vector

A clear explanation of the Flatten 2D Vector problem using row and column pointers to implement an iterator.

LeetCode 225: Implement Stack using Queues

A clear explanation of implementing a LIFO stack using only FIFO queue operations.

LeetCode 224: Basic Calculator

A clear explanation of evaluating an expression with plus, minus, spaces, and parentheses using a stack.

LeetCode 223: Rectangle Area

A clear explanation of computing the total covered area of two axis-aligned rectangles by subtracting their overlap.

LeetCode 222: Count Complete Tree Nodes

A clear explanation of counting nodes in a complete binary tree faster than visiting every node.

LeetCode 221: Maximal Square

A clear explanation of finding the largest square of 1s in a binary matrix using dynamic programming.

LeetCode 220: Contains Duplicate III

A clear explanation of checking nearby indices with nearby values using a sliding window and bucket hashing.

LeetCode 219: Contains Duplicate II

A clear explanation of detecting whether equal values appear within distance k using a hash map or sliding window set.

LeetCode 216: Combination Sum III

A clear explanation of finding k distinct numbers from 1 to 9 that sum to n using backtracking.

LeetCode 215: Kth Largest Element in an Array

A clear explanation of finding the kth largest element using sorting, a min-heap, and Quickselect.

LeetCode 214: Shortest Palindrome

A clear explanation of building the shortest palindrome by finding the longest palindromic prefix using KMP.

LeetCode 213: House Robber II

A clear explanation of maximizing robbed money from circularly arranged houses using dynamic programming.

LeetCode 212: Word Search II

A clear explanation of finding multiple words in a character board using a Trie and DFS backtracking.

LeetCode 211: Design Add and Search Words Data Structure

A clear explanation of designing a word dictionary with addWord and wildcard search using a Trie and DFS.

LeetCode 210: Course Schedule II

A clear explanation of finding a valid course ordering using topological sorting and cycle detection.

LeetCode 209: Minimum Size Subarray Sum

A clear explanation of finding the shortest contiguous subarray whose sum is at least target using a sliding window.

LeetCode 208: Implement Trie Prefix Tree

A clear explanation of implementing a Trie with insert, search, and startsWith operations.

LeetCode 207: Course Schedule

A clear explanation of detecting cycles in a prerequisite graph using topological sorting and DFS.

LeetCode 206: Reverse Linked List

A clear explanation of reversing a singly linked list using iterative and recursive approaches.

LeetCode 205: Isomorphic Strings

A clear explanation of checking whether two strings follow the same character mapping pattern.

LeetCode 204: Count Primes

A clear explanation of counting prime numbers less than n using the Sieve of Eratosthenes.

LeetCode 203: Remove Linked List Elements

A clear explanation of removing all linked list nodes with a target value using iteration and a dummy node.

LeetCode 202: Happy Number

A clear explanation of detecting whether repeated digit-square sums eventually reach 1.

LeetCode 201: Bitwise AND of Numbers Range

A clear explanation of finding the bitwise AND of every number in an inclusive range using the common binary prefix.

LeetCode 100: Same Tree

A detailed guide to solving Same Tree with recursive DFS and structural comparison.

LeetCode 99: Recover Binary Search Tree

A detailed guide to solving Recover Binary Search Tree with inorder traversal and two misplaced nodes.

LeetCode 98: Validate Binary Search Tree

A detailed guide to solving Validate Binary Search Tree with recursive lower and upper bounds.

LeetCode 97: Interleaving String

A detailed guide to solving Interleaving String with two-dimensional dynamic programming.

LeetCode 96: Unique Binary Search Trees

A detailed guide to solving Unique Binary Search Trees with dynamic programming and the Catalan recurrence.

LeetCode 95: Unique Binary Search Trees II

A detailed guide to solving Unique Binary Search Trees II with recursive tree generation over value ranges.

LeetCode 94: Binary Tree Inorder Traversal

A detailed guide to solving Binary Tree Inorder Traversal with recursion and an iterative stack.

LeetCode 93: Restore IP Addresses

A detailed guide to solving Restore IP Addresses with backtracking over four valid IP segments.

LeetCode 92: Reverse Linked List II

A detailed guide to solving Reverse Linked List II with a dummy node and in-place sublist reversal.

LeetCode 91: Decode Ways

A detailed guide to solving Decode Ways with dynamic programming and careful handling of zeroes.

LeetCode 90: Subsets II

A detailed guide to solving Subsets II with sorting, backtracking, and duplicate skipping.

LeetCode 89: Gray Code

A detailed guide to solving Gray Code using the binary-to-Gray-code formula.

LeetCode 88: Merge Sorted Array

A detailed guide to solving Merge Sorted Array in-place by merging from the back with three pointers.

LeetCode 87: Scramble String

A detailed guide to solving Scramble String with recursive dynamic programming and memoization.

LeetCode 86: Partition List

A detailed guide to solving Partition List with two dummy lists while preserving relative order.

LeetCode 85: Maximal Rectangle

A detailed guide to solving Maximal Rectangle by converting each matrix row into a histogram and applying a monotonic stack.

LeetCode 84: Largest Rectangle in Histogram

A detailed guide to solving Largest Rectangle in Histogram with a monotonic increasing stack.

LeetCode 83: Remove Duplicates from Sorted List

A detailed guide to solving Remove Duplicates from Sorted List with one pointer and in-place linked list rewiring.

LeetCode 82: Remove Duplicates from Sorted List II

A detailed guide to solving Remove Duplicates from Sorted List II with a dummy node and pointer rewiring.

LeetCode 81: Search in Rotated Sorted Array II

A detailed guide to solving Search in Rotated Sorted Array II with modified binary search and duplicate handling.

LeetCode 80: Remove Duplicates from Sorted Array II

A detailed guide to solving Remove Duplicates from Sorted Array II with an in-place two-pointer method.

LeetCode 79: Word Search

A detailed guide to solving Word Search with depth-first search and backtracking on a grid.

LeetCode 78: Subsets

A detailed guide to solving Subsets with backtracking and the include-or-skip recursion idea.

LeetCode 77: Combinations

A detailed guide to solving Combinations with backtracking and pruning.

LeetCode 76: Minimum Window Substring

A detailed guide to solving Minimum Window Substring with a sliding window and frequency counters.

LeetCode 262: Trips and Users

A clear explanation of the Trips and Users SQL problem using joins, filtering, grouping, and conditional aggregation.

LeetCode 200: Number of Islands

A clear explanation of counting connected groups of land cells in a grid using DFS or BFS.

LeetCode 199: Binary Tree Right Side View

A clear explanation of returning the visible nodes from the right side of a binary tree using level-order traversal.

LeetCode 198: House Robber

A clear explanation of maximizing robbery profit without robbing adjacent houses using dynamic programming.

LeetCode 191: Number of 1 Bits

A clear explanation of counting set bits in an integer using bit manipulation and Brian Kernighan's algorithm.

LeetCode 190: Reverse Bits

A clear explanation of reversing the bits of a 32-bit integer using bit manipulation.

LeetCode 189: Rotate Array

A clear explanation of rotating an array to the right by k steps using in-place reversal.

LeetCode 188: Best Time to Buy and Sell Stock IV

A clear explanation of maximizing stock trading profit with at most k transactions using dynamic programming.

LeetCode 187: Repeated DNA Sequences

A clear explanation of finding repeated 10-letter DNA substrings using a fixed-size sliding window and hash sets.

LeetCode 186: Reverse Words in a String II

A clear explanation of reversing the order of words in a character array in-place using two reversals.

LeetCode 179: Largest Number

A clear explanation of arranging non-negative integers to form the largest possible concatenated number using a custom sort order.

LeetCode 173: Binary Search Tree Iterator

A clear explanation of designing an iterator over a BST using controlled inorder traversal with a stack.

LeetCode 170: Two Sum III - Data Structure Design

A clear explanation of designing a data structure that supports add and find operations for pair sums.

LeetCode 169: Majority Element

A clear explanation of finding the element that appears more than half the time using Boyer-Moore voting.

LeetCode 168: Excel Sheet Column Title

A clear explanation of converting a positive integer into an Excel column title using bijective base 26.

LeetCode 167: Two Sum II - Input Array Is Sorted

A clear explanation of finding two numbers in a sorted array using two pointers and constant extra space.

LeetCode 166: Fraction to Recurring Decimal

A clear explanation of converting a fraction into decimal form and detecting repeating fractional parts with a hash map.

LeetCode 165: Compare Version Numbers

A clear explanation of comparing version strings revision by revision while ignoring leading zeros.

LeetCode 164: Maximum Gap

A clear explanation of finding the maximum adjacent gap in sorted order using buckets and the pigeonhole principle.