Learn and practice
Coding interview guides, practice, and tools
Study data structures, algorithms, and JavaScript with worked guides, interactive visualizers, language preparation, and curated study plans.
Start with a topic you are studying, or choose a study plan if you want a sequence. The full course brings the lessons together with coding exercises. These resources are free to read without an account. The video library has chapter links and written notes for every recorded course lesson.
Interactive tools
Debounce and throttle visualizer
Send events and compare immediate, debounced, and throttled callbacks. Adjust the wait and leading/trailing options and inspect exact timelines.
Interactive toolsBig O complexity explorer
Compare growth functions across input sizes with a logarithmic chart, exact operation estimates where representable, and worked algorithm examples.
Interactive toolsBFS and DFS graph traversal visualizer
Edit an adjacency list and step through breadth-first or depth-first traversal. Inspect the frontier, visited nodes, parents, and reachable paths.
Interactive toolsBinary tree traversal visualizer
Build a binary tree from level-order values and step through preorder, inorder, postorder, and breadth-first traversal.
Interactive toolsCoding interview study-plan builder
Build a time-budgeted learning schedule with course links, rotating review, local completion marks, and a downloadable Markdown checklist.
Interactive toolsCoding interview pattern quiz with answer explanations
Practice choosing algorithms from constraints in 12 questions, compare alternatives, retry missed prompts, and study worked pattern guides.
Interactive toolsJavaScript output quiz: 12 snippets with explained answers
Predict JavaScript output for closures, this, copies, Map keys, defaults, sorting, and promises. Compare explanations and retry missed snippets.
Interactive toolsLinked-list pointer visualizer: reverse, insert, delete, and detect cycles
Trace fixed node identities, next links, saved pointers, head insertion and deletion, and Floyd cycle detection on empty and nonempty lists.
Interactive toolsSorting comparison visualizer with operation counts
Compare insertion, selection, and bubble sort on identical inputs, inspecting value comparisons, array writes, early exits, and intermediate state.
Interactive toolsRecursion call-stack visualizer: calls, frames, and returns
Step through a stair-counting recurrence and inspect active frames, returned values, repeated calls, and the difference between stack depth and total work.
Interactive toolsDynamic programming visualizer: recursion, memoization, and tabulation
Compare the same stair recurrence with plain recursion, cached answers, and bottom-up tables. Inspect stored states, cache hits, calls, and dependency order.
Interactive toolsEdge-case practice: find tests that expose algorithm bugs
Practice choosing counterexamples for missing index zero, invalid BST descendants, cyclic graphs, Unicode assumptions, mutation, and boundary searches.
Interactive toolsTime and space complexity practice with explained answers
Derive bounds for loops, queues, graphs, recursion, memoization, and generated output through eight questions with concrete cost models and explanations.
Interactive toolsAlgorithm flashcards with browser-local spaced review
Recall algorithm invariants and constraints across twelve review cards, reveal worked explanations, and keep a simple review schedule in your browser.
Interactive toolsCoding interview rehearsal timer, prompts, notes, and rubric
Rehearse clarification, implementation, tests, and explanation with public problem contracts, a pausable timer, self-review, and downloadable notes.
Interactive toolsAccessible tabs, modal focus, and React state lab
Practice tab keyboard navigation, native modal focus, and queued React state updates in three working browser examples.
Guides
Debounce vs. throttle in JavaScript
Build both functions, compare leading and trailing calls, and test timing behavior with an interactive event timeline.
GuidesImplement Promise.all in JavaScript
Write a Promise.all implementation that preserves input order, handles empty iterables, and rejects correctly.
GuidesThe JavaScript event loop, explained with execution traces
Trace synchronous code, promise microtasks, timers, and async functions. Work through examples before checking their output.
GuidesBFS vs. DFS: choosing a graph traversal
Compare queues, stacks, shortest paths, visited sets, and memory costs with worked graph and grid examples.
GuidesBig O time and space complexity with worked examples
Analyze loops, nested work, recursion, and auxiliary memory. Learn to state assumptions and distinguish worst-case from amortized cost.
GuidesHow to explain a coding interview solution
A worked Two Sum interview: clarify the contract, develop a baseline, justify a hash map, test edge cases, and explain complexity.
GuidesImplement a JavaScript queue for BFS without repeated shift calls
Build a FIFO queue with bounded compaction, distinguish empty results from undefined values, and use it in a cyclic graph traversal.
GuidesTypeScript collections: missing values, keys, and readonly contracts
Model lookup presence explicitly, handle unchecked indexes, preserve zero and undefined, and write a typed frequency counter and graph BFS.
GuidesCount islands in Python with iterative flood fill
Solve a four-neighbor binary-grid problem with an explicit stack, visited-set and in-place variants, complexity analysis, and boundary tests.
GuidesJava PriorityQueue: top-K values, comparators, and stable ties
Retain top-K stream values, process jobs with explicit tie order, and test Java heap ranking separately from iteration and sorted output.
GuidesC++ lower_bound and upper_bound: counts, neighbors, and record ranges
Use C++ search boundaries for duplicate counts, strict predecessors and successors, and custom record keys without invalid iterator operations.
GuidesLongest unique substring in Go: bytes, runes, and Unicode
Implement rune and ASCII sliding windows, reject invalid input, preserve forward-only boundaries, and test Unicode length assumptions.
GuidesRust BFS shortest paths with borrowed graph labels
Return a shortest unweighted route using borrowed string labels, a FIFO frontier, explicit parents, and a lifetime that matches the source graph.
GuidesJavaScript closures and this: state, receivers, and callback lifetimes
Explain closure bindings, independent instances, receiver loss, arrow functions, listener cleanup, and callback lifetime through tested JavaScript examples.
GuidesDesign an accessible autocomplete: state, stale requests, and keyboard behavior
Work through query state, cancellation, stale-response guards, keyboard focus, combobox semantics, caching, and test cases for a frontend autocomplete.
GuidesDOM event delegation: boundaries, nested targets, and cleanup
Build a delegated button handler with explicit container boundaries, nested targets, disabled controls, keyboard activation, and listener cleanup.
GuidesHow a multilingual coding exercise runner works
Follow a language-neutral problem spec through source generation, execution, authenticated result parsing, server-side comparison, and conformance checks.
GuidesHow to test a coding exercise across programming languages
Design a language-neutral contract, independent reference checks, comparison rules, starter controls, edge cases, and conformance tests for a multilingual lesson.
GuidesRetry with exponential backoff in JavaScript
Build a bounded retry loop with full jitter, cancellation, explicit retry policy, and deterministic timing tests.
GuidesLimit promise concurrency in JavaScript
Run lazy task factories in an ordered worker pool, stop new work after failure, and drain active tasks before settling.
GuidesDeep clone JavaScript data: cycles, aliases, and property contracts
Copy a supported object graph without losing cycles, shared references, sparse holes, or property flags, and compare with structuredClone.
GuidesFlatten nested JavaScript arrays with an explicit stack
Preserve left-to-right order, distinguish holes from undefined, reject cycles, and expand repeated references correctly.
GuidesImplement currying in JavaScript with an explicit arity
Collect grouped arguments, reuse partial applications safely, and define receiver, excess-argument, and exception behavior.
GuidesJavaScript memoization: keys, invalidation, and rejected promises
Build receiver-aware argument caching and pending-promise deduplication with explicit identity, retention, and failure rules.
GuidesBuild a JavaScript event emitter with reliable cleanup
Implement duplicate subscriptions, recursive once listeners, dispatch mutation rules, and idempotent unsubscription.
GuidesJavaScript prototypes: lookup, ownership, and method receivers
Trace inherited properties, shadowing, accessors, constructor prototypes, and dictionary ownership with executable examples.
GuidesJavaScript equality, coercion, and object identity
Compare strict equality, Object.is, Map keys, falsy values, and object identity through tested cases and practical API contracts.
GuidesURL shortener system design: IDs, caching, and failure tradeoffs
Work through a hypothetical short-link service, from durable key allocation to redirects, cache invalidation, analytics, and regional visibility.
GuidesChoose a coding interview practice platform with a repeatable trial
Evaluate guided courses, problem banks, language tracks, and frontend practice using one task, delayed recall, feedback, and verified access.
GuidesExplain a technical project in interviews and on your resume
Prepare an accurate project story with your contribution, tradeoffs, failure recovery, measured evidence, and recruiter-screen follow-ups.
Topics
Arrays and matrix interview practice
Learn array invariants, in-place work, prefix/suffix products, and matrix traversal through a curated sequence of lessons and exercises.
TopicsBig O and algorithm analysis
Practice reasoning about input size, loops, recursion, and auxiliary memory before comparing the efficiency of interview solutions.
TopicsHash tables and frequency counting
Use hash maps and sets to count frequencies, track previously seen values, and trade additional memory for faster lookups.
TopicsStrings and text interview problems
Practice text traversal, character counts, palindromes, and anagrams while making the character model and input constraints explicit.
TopicsRecursion and recursive problem solving
Define base cases, trace recursive calls, and understand return values and shared state through progressively harder exercises.
TopicsSearching and sorting interview practice
Learn binary-search invariants, sorted-input reasoning, and sorting tradeoffs with targeted interview problems.
TopicsLinked lists and pointer techniques
Trace pointer updates, preserve reachability, and practice reversing lists and joining chains without losing nodes.
TopicsStacks and queues for coding interviews
Choose last-in-first-out or first-in-first-out processing for bracket matching, traversal, and state tracking.
TopicsTrees and binary search trees
Practice recursive contracts, traversal order, binary-search-tree bounds, and ancestor relationships with a structured learning path.
TopicsGraphs, traversal, and shortest paths
Represent relationships, track visited nodes, choose BFS or DFS, and solve graph and grid interview problems.
TopicsDynamic programming interview practice
Connect subproblems, memoization, tabulation, and state design with worked interview exercises.
TopicsJavaScript interview utilities and concepts
Practice promises, closures, array methods, event emitters, debounce, and throttle with guides and coding lessons.
Patterns
Sliding window: fixed and variable windows
Derive a window invariant, update state in constant time, and recognize when negative values or a different condition break the approach.
PatternsTwo pointers: sorted pairs, partitions, and in-place work
Understand why moving a pointer is safe. Work through sorted Two Sum, palindrome checks, and duplicate removal.
PatternsDynamic programming: states, transitions, and evaluation order
Build a recurrence from choices, define a complete state, and compare memoization with tabulation through a worked non-adjacent-sum problem.
PatternsPrefix sums: range queries and signed subarray counts
Build prefix arrays and frequency maps, count target-sum subarrays with negative values, and test boundary and numeric assumptions.
PatternsBinary search: lower bounds, upper bounds, and first true
Use a half-open boundary invariant to handle duplicates, missing answers, monotone predicates, and binary-search edge cases.
PatternsBacktracking: subsets, permutations, and pruning
Model a decision tree, restore shared state, copy independent results, and justify pruning with worked subset and permutation code.
PatternsMonotonic stacks: next greater values and stock spans
Trace unresolved indexes, choose strict or non-strict comparisons, and prove linear total work with tested next-greater and span implementations.
PatternsHeaps and priority queues: keep the K largest stream values
Implement a numeric min-heap, choose the right top-K orientation, and separate heap order, sorted output, and update costs.
PatternsTries for prefix search: insert, count, and delete words
Build an iterative Unicode-aware trie with prefix counts, duplicate handling, safe deletion, explicit text contracts, and operation-cost analysis.
PatternsUnion-find: weighted components, path halving, and connectivity
Implement disjoint sets with weighted unions, trace component counts, explain amortized costs, and distinguish connectivity from paths and deletions.
PatternsGreedy algorithms: interval scheduling, exchange proofs, and counterexamples
Prove earliest-finish interval scheduling, implement a nonmutating selector, reject tempting rules with counterexamples, and test against exhaustive subsets.
Language preparation
JavaScript coding interview preparation
Practice the data structures, language behavior, asynchronous utilities, and testing habits that support clear JavaScript interview solutions.
Language preparationTypeScript coding interview preparation
Use precise types for maps, trees, unions, and asynchronous functions while keeping your interview implementation readable and testable.
Language preparationPython coding interview preparation
Choose lists, dictionaries, sets, deque, and heaps deliberately. Practice readable Python solutions with clear time and memory analysis.
Language preparationJava coding interview preparation: collections, numbers, and traversal
Prepare with HashMap, ArrayDeque, safe comparators, UTF-16 text, and tested Java implementations of Two Sum and graph traversal.
Language preparationC++ coding interview preparation: STL, ownership, and boundaries
Use vectors, hash maps, queues, and priority queues while handling iterator invalidation, integer overflow, and safe index boundaries.
Language preparationGo coding interview preparation: slices, maps, and text
Practice Go slice ownership, map presence checks, byte and rune boundaries, and queue-based graph traversal with worked code.
Language preparationRust coding interview preparation: borrowing and collections
Write interview algorithms with borrowed slices, explicit Option results, HashMap entries, VecDeque, and min-heap priority through Reverse.
Language preparationC# coding interview preparation: collections, tuples, and traversal
Practice C# dictionary presence, nullable tuple results, widened arithmetic, queue traversal, priority ordering, and UTF-16 text contracts.
Language preparationKotlin coding interview preparation: arrays, nullability, and JVM collections
Use primitive arrays, nullable results, map presence, JVM queues, safe comparisons, and explicit collection-sharing assumptions in Kotlin.
Language preparationSwift coding interview preparation: value semantics, optionals, and text
Prepare Swift algorithms with optional results, checked arithmetic, collection value semantics, FIFO traversal, and Unicode-aware text choices.
Study plans
A seven-day coding interview review plan
A focused review for developers who already know the basics: daily objectives, selected exercises, timed rehearsals, and a final preparation checklist.
Study plansA 30-day coding interview study plan
A day-by-day sequence through data structures, algorithms, language practice, review sessions, and mock interviews using the existing course.
Study plansA 90-day coding interview plan for studying around work
Build a twelve-week practice rhythm with diagnostics, delayed review, all ten programming-language paths, and focused interview rehearsals.
Reference
Data structure time complexity reference
Compare arrays, hash maps, linked lists, stacks, queues, trees, and heaps with worst-case, expected, and amortized costs explained.
ReferencePython collections for interviews: dict, Counter, deque, and heapq
Choose Python collections by operation, write counts and adjacency lists, and test queue, heap, missing-key, and copying behavior.
ReferenceCoding interview practice worksheet: contract, invariant, tests, and review
Use a printable problem-solving worksheet to clarify a contract, compare approaches, trace an invariant, select edge cases, and plan a concrete follow-up.
ReferenceMock coding interview rubric with observable review criteria
Review clarification, correctness, reasoning, testing, complexity, and communication using observable evidence and specific follow-ups, without a fabricated hiring score.
ReferenceHow to choose a data structure for an interview problem
Choose arrays, maps, sets, deques, heaps, trees, tries, and disjoint sets by required operations, order, identity, mutation, and cost assumptions.
ReferenceInterview collection operations across ten programming languages
Compare map presence, queues, copying, numeric boundaries, and text units across JavaScript, TypeScript, Python, Java, C++, C#, Go, Kotlin, Swift, and Rust.