Vibe Engines
YouTube
CHALLENGES · SOLVE, DON'T SCROLL

Code you write, not read.

76 interview-style problems you solve in the browser — in Python or TypeScript, with hidden tests that check your answer the moment you hit Run. They are arranged as ladders: each one is an ordered path, so there is always a next problem rather than a wall of them.

76Challenges
10Ladders
2Languages
100%Free · no sign-up
76 challenges

The screen

What a technical screen asks before it asks anything else.

Interview classics

The ten problems screens keep asking. Clear these and the warm-up round is covered.

0 / 10 solved
  1. Fizz Buzz Start here The famous screening question.MathEasy
  2. Two SumThe classic warm-up: find the two numbers that add up to a target.ArraysEasy
  3. Valid ParenthesesThe canonical stack problem: decide whether every bracket is closed by the right type, in the right order.StackEasy
  4. Min StackA stack that also returns its minimum in O(1) — no scanning.StackEasy
  5. 3SumThe rite of passage: every unique zero-sum triplet, no duplicates, no O(n³).Two PointersMedium
  6. Merge IntervalsCalendar apps and memory allocators run on this: sort by start, sweep once, grow or close the current block.SortingMedium
  7. Top-K Frequent ElementsCount, then rank — the two-step pattern behind trending topics and hot-key detection.Hash MapMedium
  8. Number of IslandsThe canonical connected-components question.GraphsMedium
  9. Course Schedule (Cycle Detection)Can you finish every course given its prerequisites? The classic "is this dependency graph acyclic?" check a build system runs.GraphsMedium
  10. Word LadderTransform one word into another one letter at a time, every step a real word — a shortest path in a hidden graph, so a job for BFS.GraphsHard

Structures you build

Stop importing them. Write the structure itself, including the probabilistic ones.

0 / 7 solved
  1. Union-Find (Connected Components) Start here The disjoint-set behind Kruskal’s MST and network connectivity: answer "are these connected?" in near-constant time with union by…GraphsMedium
  2. Implement a TrieThe prefix tree behind autocomplete and spell-check: insert, search, and startsWith in time proportional to word length.TrieMedium
  3. Bloom FilterA tiny bit-array that answers "have I seen this?" in a fraction of a set’s memory — with occasional false positives but never a f…ProbabilisticMedium
  4. Streaming MedianLatency dashboards do this every second: maintain the median of a stream without re-sorting per event.HeapsMedium
  5. Reservoir SamplingPick k items uniformly at random from a stream of unknown length — one pass, O(k) memory.SamplingMedium
  6. HyperLogLog Cardinality EstimatorCount how many distinct items a stream held — billions of them — using a few kilobytes, not a giant set.ProbabilisticHard
  7. Skip List Insert & SearchO(log n) search and insert from nothing but linked lists and express lanes — the structure behind Redis sorted sets.Linked ListHard

Graphs, strings & parsers

Shortest paths, string matching, and two real parsers — recursion you can defend.

0 / 8 solved
  1. Dijkstra’s Shortest Paths Start here The algorithm every routing table and map app leans on: single-source shortest paths with non-negative weights.GraphsMedium
  2. A* Pathfinding on a GridThe pathfinder inside games and robots: A* expands nodes by "cost so far + estimated cost to go", so the heuristic focuses the se…GraphsMedium
  3. Matrix ExponentiationRaise a matrix to the n-th power in O(log n) multiplies instead of n — the trick that computes the billionth Fibonacci number alm…MathMedium
  4. KMP Failure TableThe precomputation that makes KMP string search run in O(n): for every prefix, the longest proper prefix that is also a suffix.StringsMedium
  5. Longest Common SubsequenceThe DP behind "git diff" and DNA alignment: the longest subsequence common to two strings (order kept, gaps allowed).Dynamic ProgrammingMedium
  6. Expression CalculatorEvaluate an arithmetic string with precedence and parentheses, the way an interpreter does.ParsingMedium
  7. JSON Parser (Recursive Descent)Write the parser behind every API and config file: turn a JSON string into native objects, arrays, numbers, strings, booleans and…ParsingHard
  8. Mini Regex Matcher (. and *)Implement regex matching with "." and "*" — the classic hard interview problem.Dynamic ProgrammingHard

AI engineering

The primitives behind an LLM product, implemented by hand.

Model internals

Softmax to attention: the maths inside the model, in about twenty lines each.

0 / 6 solved
  1. Softmax Start here The function at the end of every classifier and language model: turn raw scores (logits) into a probability distribution.LLMEasy
  2. Cross-Entropy LossThe loss that trains almost every classifier and language model.Deep LearningEasy
  3. Layer NormalizationThe stabilizer wrapped around every Transformer sub-layer: re-center and re-scale a vector to mean 0 and variance 1, then let lea…TransformersEasy
  4. K-Nearest NeighborsThe simplest classifier there is: to label a new point, look at the k closest labeled points and let them vote.Machine LearningMedium
  5. BPE Merge StepOne step of how every tokenizer vocabulary is built: count adjacent symbol pairs across the corpus, pick the most frequent (ties…TokenizationMedium
  6. Single-Head AttentionThe operation at the heart of every Transformer: scaled dot-product attention.TransformersMedium

Inference & decoding

How tokens actually come out: temperature, constraints, beams, speculation, KV cache.

0 / 5 solved
  1. Softmax with Temperature Start here The dial that controls how "creative" a language model is: temperature scales the logits before the softmax — low sharpens toward…SamplingEasy
  2. Constrained Decoding (Logit Masking)How do you force an LLM to emit only valid JSON or a token your grammar allows? Mask the logits: set every disallowed token to −∞…Structured OutputEasy
  3. Beam Search DecoderGreedy decoding takes the best next token and never looks back — straight into garden paths.DecodingMedium
  4. Speculative Decoding: Accept StepSpeculative decoding speeds up LLM inference: a small draft model proposes tokens, the big target model verifies them in one pass.InferenceMedium
  5. KV-Cache Eviction (Attention Sinks)An LLM’s KV cache grows every token, so long chats must drop old entries without wrecking quality.InferenceMedium

RAG & retrieval

Chunk, embed, score, rank, then measure it. The whole retrieval path, implemented.

0 / 7 solved
  1. Cosine Similarity Start here The measure behind every embedding search and RAG system: how aligned are two vectors, ignoring their length? Dot product over th…EmbeddingsEasy
  2. Semantic Chunker (Token Budget)Before you embed a document for retrieval, split it into chunks that fit a token budget — without slicing a sentence.RAGEasy
  3. TF-IDFThe scoring that ran search for decades — and still seeds hybrid retrieval today.NLPMedium
  4. BM25 ScoringThe keyword-ranking function every fancy retriever still has to beat.RetrievalMedium
  5. Top-K RetrievalThe core of the "R" in RAG: given a query embedding and a set of document embeddings, return the indices of the k most similar do…RAGMedium
  6. MMR RerankingTop-k by similarity returns five copies of the same paragraph.RetrievalMedium
  7. Token-Level F1The metric behind QA evaluation (SQuAD and friends): how well does a predicted answer overlap a reference as a bag of words? Comp…EvalsMedium

Agents & loop engineering

Budget, retry, parse a tool call, close the loop — then review the code an AI wrote.

0 / 9 solved
  1. Trim History to a Token Budget Start here Every agent turn re-sends the whole conversation, so history must fit the context budget.AgentsEasy
  2. Retry with Exponential BackoffTools time out and APIs rate-limit — a production agent retries without hammering.AgentsEasy
  3. Parse a Tool CallWhen a model wants to act, it emits a call like search(query=cats, limit=5).AgentsMedium
  4. Run the Goal LoopThe engine of loop engineering: attempt the front task, let an independent verifier judge it, retry failures with state untouched…AgentsMedium
  5. Build Your Own Agent LoopStrip an "AI agent" of its mystique and what’s left is a loop: read the model’s next move — tool call or final answer — run the t…AgentsMedium
  6. Write a VerifierIn RL from verifiable rewards, the verifier IS the reward — and a gameable one is worse than none, because every false positive i…RLVRMedium
  7. Spot the Bug in AI CodeAn assistant wrote a chat-history trimmer that looks right, passes the obvious case, and silently drops the system prompt the mom…Code ReviewEasy
  8. Read the Codebase, Fix the BugThe skill an AI can’t fake for you: drop into unfamiliar code, trace how the pieces call each other, and fix the one that’s wrong…Code ReviewMedium
  9. Ship or StopA self-improvement loop finished another round and every number on the dashboard went up.AgentsMedium

Production & field work

The code that survives real traffic, real data and real customers.

Systems, limits & distribution

Caches, rate limits, breakers, hash rings, and the three distributed-systems primitives.

0 / 9 solved
  1. LRU Cache Start here The eviction policy behind every size-limited cache: when you run out of room, throw out whatever was used least recently.CachingMedium
  2. LFU CacheThe cache that evicts what you use least often — and, on ties, least recently.DesignHard
  3. Token Bucket Rate LimiterThe algorithm inside most production rate limiters — and it never runs a timer.Rate LimitingMedium
  4. Sliding-Window Rate LimiterAllow at most N requests per rolling window — the rate limiter that guards real APIs.Rate LimitingMedium
  5. Circuit BreakerStop one failing dependency from taking down the fleet: trip after consecutive failures, fail fast while open, probe once after t…ReliabilityMedium
  6. Consistent Hashing RingHow distributed caches decide which node owns a key — with tiny churn when nodes join or leave.Distributed SystemsMedium
  7. Vector Clock MergeVector clocks let processes with no shared time agree on which event caused which.Distributed SystemsEasy
  8. CRDT: Grow-Only CounterA counter many replicas increment independently, with no coordination, that always converges to the same total after syncing — a…Distributed SystemsEasy
  9. Raft Leader Election (Majority)The heartbeat of the Raft consensus algorithm: a candidate becomes leader only by winning a strict majority of the cluster — the…Distributed SystemsEasy

Integrations & messy data

Paginate, verify, redact, reconcile: the forward-deployed engineer’s actual week.

0 / 10 solved
  1. API Pagination Collector Start here The customer’s API returns 100 rows at a time behind a cursor.IntegrationsEasy
  2. Idempotency Key HandlerNetworks retry.IntegrationsEasy
  3. Config ValidatorHalf of "it doesn’t work at the customer" is a bad config — a missing key, a string where an int belongs, an env that isn’t allowed.ReliabilityEasy
  4. Exponential Backoff with Full JitterWhen a customer’s API throws 503s, everyone retrying on the same doubling schedule stampedes it in sync.ReliabilityMedium
  5. Verify a Webhook SignatureEvery real integration sends signed webhooks — and every FDE has to verify them.SecurityMedium
  6. PII RedactorBefore customer data touches a log line — or a third-party LLM — the personal bits have to go.SecurityMedium
  7. CSV → Schema MapperEvery customer hands you a messy export.DataMedium
  8. Data Reconciliation DiffThe customer swears the migration worked.DataMedium
  9. Harvest a Flaky Paginated APIThe vendor API is paginated, occasionally 500s, rate-limits without documenting it, and returns overlapping pages when the data m…DataMedium
  10. Reconcile Two Systems That DisagreeThe customer is certain the ERP and the CRM agree; they have never checked.DataMedium

Interview escalations

Five staged rounds that change the requirements mid-solution, like a real on-site.

0 / 5 solved
  1. Re-Engineer a Legacy ETL Start here You inherit an aggregation nobody can explain and the totals are wrong.DataMedium
  2. Repair the Spread TraversalInherited code computes how far something spreads through a contact graph, and the answers are wrong in a way that is invisible o…GraphsMedium
  3. LRU Cache, Constraint by ConstraintThe incremental-coding round, packaged: a cache that becomes bounded, then least-recently-used, then instrumented — each stage in…FDEMedium
  4. Deep Clone, Constraint by ConstraintThe incremental round on a problem where stage three genuinely breaks the obvious design: copy an object, then nested structures,…FDEMedium
  5. Rate Limiter, Constraint by ConstraintA third incremental round, where stage two invalidates stage one outright: a fixed-window counter becomes a sliding window, then…ReliabilityMedium

Coding challenges — frequently asked questions

What are these coding challenges?

Each challenge is a classic interview-style problem you solve in your browser. You get a stub, a problem statement with examples, and hidden tests. Write your solution in Python or TypeScript, hit Run, and the tests tell you instantly whether it works — no account, no setup, nothing to install.

How does the code actually run with no server?

Entirely in your browser. Python runs as real CPython compiled to WebAssembly (Pyodide); TypeScript is transpiled on the fly. The site is a static site with no backend, so your code never leaves your machine.

Can I see the solution if I get stuck?

Yes. Every challenge has hints and a one-click "Reveal solution" button that drops a clean, commented reference implementation into the editor. The goal is to build intuition — struggle first, then compare your approach with the canonical one.

Do these help with coding interviews?

Yes. The challenges target the array, string, hash-map, stack and two-pointer patterns that show up constantly in technical screens. Solving them by hand — then checking against hidden tests — is far more durable practice than reading solutions. Many also cross-link to an animated visualizer so you can see the underlying algorithm work.

Are the challenges free?

Completely free, with no sign-up. Your solved progress is saved locally in your browser so the catalog remembers what you have finished.