Collections

Twenty-five problems covering the patterns that show up most in ML and software interviews: two pointers, dynamic programming, heaps, graphs, and the core metrics.

From dot products to Gram-Schmidt. Eighteen problems through the linear algebra every ML engineer should be able to code by hand.

One Easy problem a day for a month, two from each of the fifteen categories. A gentle way to build a daily practice habit across the whole catalog.

Activations, MLPs, normalization, and attention, with the text preprocessing and optimizer updates that feed them. Twenty problems from a single neuron to a backward pass.

Descriptive statistics, distributions, Bayes, and hypothesis tests. The probability toolkit behind evaluation, experimentation, and model diagnostics.

Sorting, searching, dynamic programming, and the data structures that make them fast. A quick warm-up set for interview season or a refresher on fundamentals.

Images as numbers: geometry, filters, pooling, and the classical CV primitives behind detection. Fifteen problems that build the intuition under modern vision models.

Traverse networks, then teach agents to act in them. Fifteen problems pairing graph algorithms (BFS, Dijkstra, SCCs) with the core reinforcement learning updates (returns, TD, SARSA, REINFORCE).

Attention from the ground up: scaling, softmax weights, weighted sums, multi-head splits, and the encoder block that stacks it all. Twelve problems that walk from a single attention head to a full transformer forward pass.

The backward pass, one layer at a time. Activation gradients, linear and embedding layer gradients, softmax cross-entropy, and a numeric gradient check to keep everything honest.

SGD, momentum, AdaGrad, RMSProp, Adam, and AdamW, implemented update by update. Covers weight decay, bias correction, and the optimizer state memory costs that decide what fits on a GPU.

Vectors, linear combinations, and matrices as transformations, in the spirit of the 3Blue1Brown series. Dot and cross products, determinants, inverses, rank, and a first look at null spaces.

Residual connections and the convolutional blocks that carry them. Skip and bottleneck shapes, depthwise convolutions, batch-norm folding, and the parameter counts behind ResNet-style architectures.

From float32 down to int8 and int4. Quantization scales, per-channel calibration, packing, memory savings, and the latency and accuracy tradeoffs that show up when you serve a model.

The full path from raw text to generated tokens: tokenization, embeddings, positional encodings, attention, sampling, and perplexity evaluation. A compact tour of the stack behind a modern language model.

MDPs, value iteration, and the temporal-difference family. Policy evaluation, returns, TD updates, SARSA, Q-learning, and the bandit basics every RL interview assumes.

From REINFORCE to proximal policy optimization. Policy gradients, baselines, advantage estimation, GAE, importance ratios, and the clipped objective that makes PPO stable.

Preference data, reward models, and the algorithms that fine-tune on top of them: DPO, GRPO, PPO-RLHF, and KL control against a reference model. Covers Bradley-Terry likelihood, best-of-N selection, and reward-model evaluation.

Confidence intervals, t-tests, correlation, power, and multiple-testing corrections. The hypothesis-testing toolkit that shows up in A/B tests, offline evaluation, and model diagnostics.

Monty Hall, the boy-girl paradox, birthday collisions, coupon collectors, and two envelopes. A dozen classic puzzles whose answers you should be able to compute, not just recall.

Log-sum-exp, stable softmax, gradient clipping, and mixed-precision loss scaling. The tricks that keep exponentials from overflowing and gradients from exploding in real training runs.

Traversals, shortest paths, minimum spanning trees, and connectivity, coded from scratch. BFS, DFS, Dijkstra, Bellman-Ford, Prim, Kosaraju, bridges, and max flow.

Baselines first, then exponential smoothing, ARMA, GARCH, and VAR. Twelve problems covering the classical forecasting models you should be able to implement without a library.

Kernels, tiles, occupancy, and the roofline model. Covers launch overhead, shared-memory bank conflicts, async pipelines, FLOPs and memory estimates, and MFU so you can reason about GPU performance on paper.