Coding & DSA

Labs reach for this practical screen often, since it probes concurrency, time handling, and judgment inside 20 lines. The pitfall is a background thread that burns CPU. Below is the lazy-refill approach interviewers expect, along with the follow-ups.

A recurring ML-coding screen. The loop itself is easy; what interviewers watch for is k-means++ init, a genuine convergence criterion, and awareness of the failure modes. Here is the compact implementation plus the follow-ups interviewers reliably ask.

A deceptively easy ML-coding ask. Writing exp/sum is trivial; the signal is the max-subtraction trick and the log-sum-exp form that stop it overflowing. Here is the stable implementation and the reason the naive version breaks.

The single most-asked design-coding question, and a common warm-up at the labs ahead of the ML follow-ups. The signal is the hashmap-plus-doubly-linked-list for genuine O(1), then handling the TTL and concurrency follow-ups cleanly. Here is that build.

A classic that pays off the two-heap insight. A sorted list costs O(n) per insert; two balanced heaps give O(log n) insert and O(1) median. Here is the implementation and the rebalancing detail people get wrong.

The from-scratch implementation that frontier labs and NVIDIA really do ask. Writing it shows you grasp shapes, the scale factor, the causal mask, and how heads split and recombine. Here is a correct, readable implementation plus the follow-ups.

Beam search is the decoding algorithm everyone cites and few can code correctly. The signal is keeping k hypotheses by cumulative log-prob, adding logs (not multiplying probs), and handling completed sequences and length. Here is a correct implementation and the tradeoffs.

A from-scratch ML-coding staple that tests whether you really know the math you rely on. The signal is the clean gradient (it reduces to Xᵀ(ŷ - y)/n), numerical stability, and vectorization. Here is the implementation and the details interviewers push on.

Autocomplete is the canonical trie question, and it checks whether you reach for the right structure rather than scanning a word list. The signal is O(prefix) lookup, the DFS to gather completions, and the follow-ups (ranking, memory). Here is the build.

The core operation beneath every embedding/RAG retrieval, posed as a coding exercise. The signal is vectorizing the similarity, normalizing correctly, and using a partial selection (argpartition) rather than a full sort. Here is the efficient implementation and the scaling follow-up.

A classic that checks whether you reach past sorting for the right structure. The signal is the heap solution (O(n log k)), the bucket-sort O(n) trick, and how it shifts for an unbounded stream. Here is the answer.

Sliding window is one of the highest-yield coding patterns, and this is its canonical problem. The real signal is spotting when a window collapses an O(n squared) scan into one linear pass, and holding the invariant cleanly.

Graph traversal sits beneath a large family of interview problems. What matters is knowing the BFS-vs-DFS tradeoff (shortest path vs memory shape) and applying it cleanly, then getting the directed-vs-undirected cycle gotcha that trips up most candidates.

DP feels like pattern-matching magic until you have a method. The signal is a repeatable drill: spot overlapping subproblems and optimal substructure, define the state and recurrence, then memoize or tabulate. Here is that method applied to a worked example.

A common ML-coding check that confirms you actually understand the metrics you quote. The signal is getting TP/FP/FN/TN right and knowing macro vs micro averaging for multiclass, not reaching for sklearn.

Data loading is where training pipelines quietly bottleneck. The signal is a correct shuffle-then-batch iterator plus knowing why prefetching and parallel loading keep the GPU fed.

BPE powers GPT-style tokenizers, and coding it shows you grasp how subword vocabularies get constructed rather than just knowing they exist. What interviewers watch for is the repeated merge of the most common adjacent pair.

Merging intervals is a staple that probes the sort-then-sweep idea. The tell is sorting by start and merging in a single pass, O(n log n). Below is the pattern along with the family of problems it opens up.

k-NN is quick to code and a solid check of vectorization and the lazy-learner tradeoff. Interviewers look for a tidy vectorized distance calculation plus knowing why naive prediction is O(n) and how to accelerate it. The implementation follows.

Coding conv2d shows you understand what a CNN layer really computes rather than just being able to name it. Interviewers watch for correct output-shape math, tidy stride and padding handling, and awareness of the im2col trick frameworks actually rely on.

LayerNorm appears in every transformer, and coding it verifies you know what it normalizes over and why. Interviewers look for normalization across the feature dimension per token, the learnable scale and shift, and the RMSNorm simplification modern LLMs took up.

Coding the KV cache shows you understand why decode is efficient: you append the new token's K/V and reuse the rest rather than recomputing. Interviewers look for the append-and-attend-over-cache logic. The implementation follows.

Binary search is simple to explain and notoriously easy to botch (off-by-one, infinite loops). Interviewers look for a correct template plus the variants (boundaries, rotated arrays) that show up constantly. The answer follows.

Backtracking underlies permutations, subsets, N-queens, and constraint problems. Interviewers look for the choose/explore/un-choose template plus pruning, and knowing exactly which knob distinguishes permutations from combinations.

A warm-up that tests for the stack instinct. Interviewers look for recognizing that last-opened-first-closed maps onto a stack, plus handling the edge cases (leftover opens, early close). The pattern follows.

Merging k sorted sources is the textbook min-heap problem and a genuine data-engineering pattern (merging sorted shards/streams). Interviewers look for the heap of k heads yielding O(N log k). The answer follows.

A classic that pays off the two-pointer insight over brute force. Interviewers look for realizing that water at each position is capped by the min of the max walls on each side, then computing it in a single pass. The answer follows.

Coding BatchNorm verifies you know the train/inference difference, the part everyone forgets. Interviewers look for normalizing over the batch with running stats kept for inference. The implementation follows.

The textbook warm-up that tests for the hash-map instinct: swap space for time to turn O(n squared) into O(n). Interviewers look for the one-pass complement lookup. The pattern follows.

Topological sort arranges a DAG so dependencies come first, the backbone of build systems, schedulers, and ML/data pipeline DAGs. Interviewers look for Kahn's algorithm (or DFS) plus cycle detection. The answer follows.

Union-Find answers 'are these in the same group?' almost instantly and drives connected-components, cycle detection, and clustering. Interviewers look for path compression plus union by rank for near-O(1) operations. The answer follows.

A staple grid-traversal problem probing BFS/DFS flood fill and disciplined visited-marking. What interviewers watch for: viewing the grid as a graph and tallying connected components. Here is the answer.

Edit distance is the archetypal 2D string DP, powering spell-check, diff, and fuzzy matching. What interviewers watch for: naming the subproblem and the insert/delete/replace recurrence. Here is the answer.

Drawing a uniform sample from a stream too large for memory (or whose length stays unknown) is a genuine data-engineering problem. What interviewers watch for: the replace-with-decreasing-probability trick and a telescoping proof. Here is the answer.

Reversing a linked list is the archetypal pointer-handling screen. What interviewers watch for: the three-pointer walk executed without ever dropping the tail of the list, plus why the iterative version wins over recursion in production. Here is the answer.

Turning a tree into a string and reconstructing it faithfully rests on one choice most candidates overlook. Skip it and the structure turns ambiguous. Here is the answer and the interview-grade reasoning.

LCA is the recursion staple that probes how you carry information upward from subtrees in one pass. What interviewers watch for: the post-order 'found in left, found in right' logic. Here is the answer plus the BST shortcut.

Maximum subarray is the entry-point 1D DP problem, and Kadane's is the O(n) one-liner. What interviewers watch for: the 'extend or restart' call at each element and the all-negative edge case most people fumble. Here is the answer.

Word Break is the classic 1D string DP that snags people who reach for greedy or naive recursion. What interviewers watch for: the dp[i] = 'is the prefix of length i segmentable' recurrence, plus why a locally valid split can doom the rest. Here is the answer.

Rotating a matrix in place probes index manipulation and the transpose-then-reverse trick. What interviewers watch for: splitting the rotation into two simple passes instead of juggling four-way swaps. Here is the answer.

Bit-manipulation problems screen for fluency with binary and the O(1)-space tricks most candidates fumble. The tell is whether you reach for XOR's self-canceling property and the n & (n-1) idiom by reflex. Here is the toolkit.

K-th largest has three textbook solutions, and what interviewers watch for is knowing Quickselect's average O(n) beats sorting's O(n log n), why its worst case is O(n²), and when a heap is genuinely the better call. Here is the answer.

TF-IDF is the classic text-vectorization scheme and a quick test of whether you truly grasp term-frequency times inverse-document-frequency, or merely recite it. What interviewers watch for: explaining why IDF kills common words. Here is the implementation.

The DP that reveals why greedy quietly fails on non-standard denominations, and how a single bottom-up table fixes it. What interviewers watch for: the dp[amount] recurrence and the unbounded-reuse insight.

LCS is the template 2D-sequence DP behind diff tools and bioinformatics. Interviewers look for rebuilding the match/mismatch recurrence from memory and not mixing up subsequence (gaps allowed) with substring (contiguous). The answer follows.

Gas Station pays off spotting a greedy invariant that turns O(n²) into O(n). Two facts carry the whole solution: total feasibility, and that a failed prefix lets you skip every start within it.

Jump Game pays off spotting that a greedy reachability scan beats DP. Interviewers look for tracking the farthest reachable index in one pass, and catching the exact moment you fall behind it.

LIS has an obvious O(n²) DP and a clever O(n log n) solution that catches people off guard. Interviewers look for the patience-sorting/binary-search approach that maintains 'tails'. Both appear below.

Minimum Window Substring is the hard sliding-window problem that probes expand-and-contract with a character-count map. Interviewers look for the grow-to-valid then shrink-to-minimal pattern, verified in O(1) per step.

House Robber is the tidiest choose-with-a-constraint 1D DP, and it reduces to O(1) space. Interviewers look for the take-this-or-skip recurrence and the two-variable rolling optimization.

Group Anagrams probes the 'compute a canonical key and bucket by it' pattern. Interviewers look for choosing a key that anagrams share without comparing every pair. The answer follows.

Building a PR/ROC curve from scratch shows you understand thresholds and the precision/recall tradeoff. What interviewers really want is sweeping the threshold in one sorted pass and integrating the area. The implementation follows.

This problem outlaws the obvious division trick, forcing the prefix/suffix-product insight. Interviewers look for computing left and right products in two passes with O(1) extra space. The answer follows.

Sorting an array of three values in one pass probes the three-pointer partition (Dutch National Flag). Interviewers look for the low/mid/high invariant and knowing when not to advance mid. The answer follows.

Spiral traversal probes careful boundary management more than algorithmic insight. Interviewers look for shrinking four boundaries layer by layer without double-visiting a row or column. The answer follows.

The textbook grid DP where each cell depends on three neighbors at once. What interviewers want is the min-of-three recurrence, plus the reason it has to be min. The answer follows.

This notoriously hard problem demands better than the O(m+n) merge: an O(log) binary search on the partition. Interviewers look for binary-searching the split point so the left halves stay below the right halves. The answer follows.

Decode Ways is a 1D DP whose difficulty sits entirely in the edge cases: zeros and the valid 1-26 range. Interviewers look for the take-one-digit-or-two recurrence plus disciplined validity checks. The answer follows.

This classic has a tidy O(n^2) expand-around-center solution that outdoes the naive O(n^3). Interviewers look for expanding from every center and handling odd and even lengths separately. The answer follows.

Coding Adam shows you know what .step() actually does: momentum combined with per-parameter adaptive rates and bias correction. What interviewers watch for is the two moments plus the bias-correction step.

Single-head attention shows up often; multi-head layers on the split-into-heads, attend-per-head, concatenate pattern. What gets scored is the reshape into heads plus a sharp explanation of why several heads help. Here is the implementation.

Computing the max of each size-k window the obvious way costs O(n*k). The move that cuts it to O(n) is a monotonic deque of indices, and why it stays linear catches most candidates off guard.

The fewest meeting rooms you need equals the highest number of meetings active simultaneously. That reframing is the entire interview; two O(n log n) solutions drop out of it, and the tie-handling catches careless candidates.

This one rewards knowing that an in-order walk of a BST produces sorted order. The signal is halting at the kth element instead of walking the entire tree.

A row- and column-sorted matrix rewards a single insight: begin at a corner and drop a whole row or column each step. That converts an O(m*n) scan into O(m+n), and which corner you pick is not arbitrary.

Dropout takes five lines, yet most candidates fumble two of them: turning it off at inference and rescaling the survivors so the expected activation holds constant. Inverted dropout is the convention they want to see.

Finding the longest run of consecutive integers without sorting divides candidates who reach for O(n log n) from those who spot the hash-set trick. The signal is one loop invariant that eliminates redundant work. Here is the answer.

Validating a BST trips up people who only check parent-child pairs and miss violations buried deep in a subtree. The signal is propagating min/max bounds or relying on in-order monotonicity. Here is the answer.

Course Schedule collapses to a single question: is the prerequisite graph a DAG? The signal is seeing the graph framing and applying topological sort or DFS to detect a cycle. Here is the answer.

Comparing all pairs across a million documents is a trillion comparisons. MinHash estimates Jaccard similarity from a tiny signature, and LSH converts dedup into a near-linear scan. Here is the implementation.

Every chat model's 'temperature' and 'top_p' knobs come down to a few lines of logit surgery. Implementing them proves you understand decoding rather than just calling it. Here is the from-scratch version.

RoPE is why modern LLMs extrapolate to longer contexts, and it works by rotation, not addition. Coding it shows you truly understand how position enters attention. Here is the implementation.

A bad split silently inflates every metric you'll ever report, and the bugs are subtle: leaked groups, shuffled time, preprocessing fit on everything. Here is the split done right.

Many state-of-the-art training runs hold a shadow copy of the weights that averages the trajectory, then serve that rather than the final step. It's a few lines and a genuine accuracy gain. Here it is.

Nearly every modern training run relies on warmup-then-cosine, and getting it wrong destabilizes early training or squanders the tail. It's a closed-form function of the step. Here is the implementation and the why.

Ahead of transformers, this was the language model, and it remains the clearest way to prove you grasp what perplexity truly measures. Smoothing is where people slip up. Here is the implementation.

The textbook variance formula suffers catastrophic precision loss on streaming data and cannot update incrementally. Welford's one-pass update is the norm for online feature normalization. Here it is.

Negative sampling in word2vec and recommendation pulls millions of weighted samples; running each at O(log n) becomes a bottleneck. The alias method turns each draw into O(1) after an O(n) setup. Here it is.

When you shard a vector index or route requests across model replicas, naive 'hash mod N' reshuffles everything the moment N changes. Consistent hashing moves only a small fraction. Here is the implementation.

A Bloom filter answers 'have I seen this?' with a few bits per item rather than storing the key, swapping a rare false positive for a large memory saving. Here is the build, the sizing math, and where it pays off in dedup and serving.

Floyd's tortoise and hare finds a cycle in O(1) space, but what sets strong candidates apart is the second phase: a brief distance argument that identifies exactly where the loop starts. Here is the answer and the math.

Two lists that share a tail have to intersect at a single node, but aligning their lengths without counting is the elegant move interviewers look for. Here is the two-pointer trick that cancels the lengths out, plus the answer.

The two-pass length-then-delete solution works, but the interview asks for a single pass: a gap of N between two pointers, plus a dummy head that makes deleting the real head come out for free. Here is the clean answer.

The diameter is not the tree's height, and the path does not have to pass through the root. The clean solution derives height and best path in one DFS, updating a global max at every node. Here is the answer and the subtlety candidates miss.

Preorder names the root; inorder divides the rest into left and right subtrees. The naive version is O(n squared); the strong answer uses a value-to-index map and a moving preorder pointer for O(n). Here is the answer and why both orders are required.

Negative subtrees, a path that bends through any node, and a return value distinct from the answer you track: this problem stuffs three traps into one DFS. Here is the clean O(n) solution and the reasoning that holds up under follow-ups.

The brute force runs O(n squared) nested scans. A monotonic stack solves it in one O(n) pass by holding only the candidates that can still become a future answer. Here is the pattern and why each element is pushed and popped exactly once.

The naive triple loop runs O(n cubed). Sort first, then fix one element and converge two pointers for O(n squared). The real test is deduplication: returning unique triplets without a set. Here is the clean template.

Merging intervals is the entry point to the whole interval family. The trick is sorting by start so overlaps end up next to each other, then collapsing them in one linear sweep. Here is the pattern and the sweep-line generalization behind it.

Generating then filtering costs O(2^(2n)) and wastes effort. Backtracking with two counters builds only valid strings by applying the balance rule at every step. Here is the template and why the pruning conditions are exactly right.

The words encode a partial order among characters. Convert each adjacent pair into a directed edge, then topologically sort. The traps are the prefix edge case and spotting contradictions. Here is the full solution with cycle handling.

Treat each word as a node and one-letter edits as edges: the shortest ladder becomes a shortest path in an unweighted graph, which means BFS. The detail that decides pass or fail is producing neighbors in O(26 * L) without scanning the entire dictionary. Here is the pattern.

Testing every subarray costs O(n squared). Prefix sums with a remainder-frequency map solve it in a single O(n) pass: two prefixes sharing a remainder mod k enclose a divisible subarray. The pitfall is negative remainders. Here is the clean answer.

Working out arithmetic with precedence and nested parentheses is a parsing task, and a single stack manages both neatly. The traps are operator precedence, multi-digit numbers, and the sign of truncated division. Here is a one-pass solution.

The classic multi-round build screen: a plain key-value store that gains new requirements at each stage (TTL, transactions, scans). The signal is not stage 1, it is whether your code takes on stage 4 without a rewrite. Here is how to design for it.

OpenAI's signature build screen: a credit ledger that issues GPU-hours, spends them, and lets unused grants lapse in issue order. The trap is charging against the right grant first. Here is the FIFO-by-expiry design that holds up through every follow-up.

A classic build screen: a key-value store whose writes inside a transaction can be committed or discarded, with transactions that nest. The trap is mutating the base store directly. Here is the overlay-stack design that keeps rollback O(1).

A practical build screen: transform a stream of sampled call stacks into a flame tree, then report self-time against total-time per function. The trap is mixing up the two times. Here is how to aggregate the tree and rank the hot functions.

A grounded systems-coding screen: locate files with identical content across a tree. The naive all-pairs hash wastes work. The signal is the size prefilter plus a cheap-hash gate ahead of the full hash. Here is the layered approach.

Most candidates start rewriting. The interviewer is grading whether you isolate pure logic from side effects before you touch a line, because that is the difference between a safe refactor and a silent behavior change.

The rotting-oranges family of build screens: a state expands outward one step per tick across a grid, with the spec adding rules each round. The signal is multi-source BFS processed by layers, not per-cell loops. Here is the design that absorbs each new test case.

Plain multi-head attention is rarely the whole exercise: the usual extension is to chain it into KV-cached decoding and GQA in one sitting. The locked answer walks the NumPy implementation, the equivalence check that proves your cache is correct, and the reshape bugs that silently corrupt attention.

Sierra's signature build screen: cells hold values or formulas that reference other cells, and editing one has to recompute its dependents without infinite loops. The signal is the dependency graph plus cycle detection. Here is the topological-eval design.

Google's 'vibe coding' screen: the spec is intentionally vague and shifts mid-interview. The signal isn't the algorithm, it's whether you clarify before coding, structure for change, and keep tests green as the requirements move. Here is how to run that loop.

A Fenwick tree serves prefix-sum queries and point updates in O(log n) using one flat array and a single bit trick. The signal is the lowbit operation and why it wins over a plain prefix array when values change. Here is the answer.

A segment tree serves any associative range query (sum, min, max, gcd) with point or range updates in O(log n). The signal is the recursive split into covered, disjoint, and partial nodes, plus lazy propagation for range updates. Here is the answer.

Dijkstra computes single-source shortest paths in O((V+E) log V) with a min-heap, the backbone of routing and network latency problems. The signal is why it requires non-negative weights and how lazy deletion keeps the heap simple. Here is the answer.

Bellman-Ford copes with negative edge weights that break Dijkstra and detects negative cycles, the foundation of currency-arbitrage problems. The signal is the V-1 relaxation rounds plus the extra Vth round that flags a negative cycle. Here is the answer.

Floyd-Warshall computes shortest paths between every pair of nodes in O(V cubed) with a compact three-line triple loop. The signal is the intermediate-node DP order and why k has to be the outer loop. Here is the answer.

Kruskal builds a minimum spanning tree by sorting edges and adding the cheapest one that does not form a cycle, using union-find for the cycle check. The signal is the greedy cut property and why disjoint-set is the right tool. Here is the answer.

KMP matches a pattern in linear time by precomputing a failure function that skips redundant comparisons rather than backtracking the text. The signal is what the prefix function actually holds and why the text pointer never moves backward. Here is the answer.

Rabin-Karp slides a fixed-width hash across the text so each window costs O(1) to update, which makes it ideal for matching many patterns at once. The signal is the polynomial rolling hash, modular arithmetic, and why you still verify on a hash hit. Here is the answer.

Binary search on the answer cracks minimize-the-maximum and capacity problems by guessing the result and testing feasibility with a monotone predicate. The signal is spotting monotonicity and writing a clean feasibility function. Here is the answer.

Sieving primes, fast modular power, and Euclid's gcd are the number-theory primitives that quietly drive crypto, hashing, and combinatorics problems. The signal is the O(n log log n) sieve and O(log e) binary exponentiation. Here is the answer.

Matrix exponentiation evaluates linear recurrences like Fibonacci at index n in O(log n) by raising a transition matrix to the nth power through binary exponentiation. The signal is building the transition matrix and squaring it. Here is the answer.

A time-based key-value store logs versioned writes and answers 'what was the value at time t' via binary search over per-key timestamps. The signal is the append-only design and the floor (largest timestamp <= t) lookup. Here is the answer.

A from-scratch classic that checks recursion plus the split criterion math. The signal is computing impurity correctly, picking the best threshold by information gain, and knowing the stopping rules. Here is a clean recursive implementation.

A from-scratch staple that checks whether you grasp the conditional-independence assumption and why you work in log space. The signal is fitting per-class means and variances, summing log-likelihoods, and adding the log prior. Here is the implementation.

A from-scratch favorite that probes linear algebra fluency. The signal is centering first, using SVD instead of forming the covariance matrix, and reading variance off the singular values. Here is the implementation and the details interviewers push on.

A build-it-yourself check on the EM algorithm and soft clustering. What matters is the pair of alternating steps (responsibilities, then weighted re-estimation), log-sum-exp for numerical stability, and seeing how GMM extends k-means. The code follows.

A build-it-yourself check on the least-squares closed form and the numerical traps hiding in it. What matters is deriving the normal equations, understanding why you never invert explicitly, and reaching for lstsq or the SVD instead. The code follows.

A build-it-yourself check on recurrent forward passes and backprop through time. What matters is the shared-weight recurrence, summing gradients over timesteps, and articulating the vanishing-gradient problem. The code follows.

A build-it-yourself check on gated recurrence. What matters is wiring the forget/input/output gates and candidate correctly, keeping cell state distinct from hidden state, and explaining why the additive cell path cures vanishing gradients. The code follows.

A build-it-yourself check on modern optimizers. What matters is the moment estimates, bias correction, and the single change that counts: AdamW decouples weight decay from the gradient rather than folding it into the loss. The code follows, plus why it wins.

A build-it-yourself check on how learning-rate schedules are actually computed. What matters is correct closed-form formulas, knowing when each schedule shines, and why decaying the rate aids convergence. Below is the implementation of the common ones.

A build-it-yourself check on how PyTorch actually works under the hood. What matters is assembling a computation graph during the forward pass, local derivatives per op, and a topological-order backward pass that accumulates gradients. Below is a minimal engine.

A build-it-yourself check on subword tokenization. What matters is greedy longest-match encoding against a fixed vocabulary, the continuation-prefix convention, and how WordPiece diverges from BPE. The code follows.

A build-it-yourself check on distributed input pipelines. What matters is partitioning data across workers with no overlap and no gaps, epoch-consistent shuffling with a shared seed, and handling the uneven-last-batch problem. The code follows.

The classic recursive-descent exercise with an applied-AI twist: the JSON your model streams stays truncated mid-token for the whole generation. What matters is a clean strict parser plus a small repair layer, not a second parser. The code follows.

The most job-shaped coding screen in AI, ML, and GenAI engineering: fan out N LLM calls without melting the rate limit or losing the batch to one bad request. What matters is the retry policy, not the async syntax. Below is the version that passes.

The most-asked hands-on LLM exercise: a chat history that outgrows the context window. What gets scored is not the sliding window, it is the region eviction is never allowed to touch. Below is the version that passes.

Every RAG system packs a prompt, and the packing bug is always the same one: the input fits the window exactly, so the model has nowhere left to answer. The arithmetic here is what separates a candidate who has shipped from one who has read about it.

The lookup is three lines of linear algebra. What separates a cache from an incident is where the similarity threshold came from, and the one-token queries ('2023' vs '2024', 'not') that no threshold can catch because the embedding barely moves.

Asking a model which answer is better is one line of code. Getting a number you would let block a deploy takes position-bias control, a confidence interval, and a human-labeled set the judge is measured against. Here is the harness.

Every agent is a loop around this function. The candidates who fail it raise an exception on a bad tool call; the ones who pass hand the error back to the model as a tool result and let it fix itself on the next turn.

Every RAG system starts here, and most candidates ship the same bug: they size the chunk in characters and call it tokens. Below is running code for all four strategies, plus the infinite loop in the overlap arithmetic and the one in the recursion.

Writing the regexes takes ten minutes. The half of the question that separates candidates is the evaluation: a detector that blocks 'ignore the noise in the data' has shipped a bug to every analyst using your product. Here is the layered detector and the harness that proves it works.

This code runs on every single response, so it sits on the critical path and a heavyweight check here doubles your p95. The signal is in the ordering, the fail-open decision when the guardrail times out, and the fact that you cannot un-send a token you already streamed.

Anyone can call a rerank endpoint. The word doing the work in this question is 'prove': you have to implement DCG, ideal DCG, and nDCG@k from graded labels and report the before-and-after. Plus the ceiling nobody mentions until it bites them in production.

The naive version splits on newlines and works right up until a TCP chunk lands mid-line. Then there is the error that arrives after a 200 OK, the user who closes the tab while you keep paying for tokens, and JSON you cannot parse until it closes.

Asking a model 'is this answer hallucinated?' barely beats a coin flip. This is the build: claim extraction, a judge forbidden from using world knowledge, a denominator that excludes hedges, and one model call per claim, which decides where the check can run at all.

Everyone can write the happy path. The screen is decided by the two branches most candidates skip: what the system does when retrieval finds nothing good, and what it does when the model cites a chunk you never sent.

A prompt is code, but most teams edit it in a dashboard with no history and then cannot explain last Tuesday's quality drop. This is the small piece of infrastructure that makes prompts reviewable, pinnable, and instantly reversible.

Most RAG projects do not die at the retriever, they die at ingestion. Naive PDF extraction interleaves columns into nonsense, shreds tables, and stamps the footer into all 4,000 chunks. Here is the parser that survives real documents.