Quiz

Amortized Analysis Quick Quiz

Short drills on amortized cost for dynamic arrays, hash table rehashing, and the aggregate method. Good for solidifying the gap between worst-case and average-case-per-operation.

Array Fundamentals Quiz

Quick prompts on indexing, in-place mutation, and the cost of common array operations. Good for warming up before sliding-window or two-pointer drills.

Hash Table Basics Quiz

Short prompts on hash table lookup cost, collision handling, and when to reach for a Set vs a Map. Builds the mental model before harder hashing problems.

Linked List Basics Quiz

Short prompts on singly vs doubly linked lists, traversal, length, and the everyday operations that come up before cycle detection or in-place reversal.

Binary Tree Basics Quiz

Short prompts on node anatomy, depth vs height, and leaf counting. Foundation drills before tackling traversal, BSTs, or balanced tree problems.

String Basics Quiz

Three short prompts on JavaScript string immutability, slicing, and char codes. Good warm-up before tackling sliding-window or palindrome problems.

Two-Pointer Warm-Up

Four short prompts covering pair sums, in-place dedupe, and palindrome checks with two pointers. Great preparation before sliding-window drills.

Big-O Complexity Quiz

Four short prompts on identifying time complexity from JavaScript code: nested loops, halving, recursion, and a bug-by-complexity hunt.

Space Complexity Quiz

Three short prompts on space accounting: stack vs heap usage, recursion depth, and an in-place vs out-of-place comparison.

Graph Representation Quiz

Short drills on adjacency list vs adjacency matrix, edge-weight storage, and the memory trade-offs between the two formats.

BFS vs DFS Fundamentals

Pin down the queue-vs-stack mechanics behind BFS and DFS, plus when level-by-level versus deep-first traversal is the right tool.

Grid Search Patterns

Implement and trace classic grid problems: counting islands, flood fill, and multi-source distance maps. Code stems are mostly Python.

Topological Sort Essentials

Kahn's algorithm, DFS-based ordering, and using topo sort to detect cycles in directed graphs. Code stems are mostly Python.

Union-Find Warm-Up

Disjoint Set Union with path compression and union by rank. Drills cover find, union, connected-component counts, and Kruskal usage.

Sorting Algorithm Speed Round

Quick drills on quicksort, mergesort, heapsort, and counting sort: best / average / worst times, stability, and when each one wins.

Binary Search Fundamentals

Lower bound, upper bound, and the off-by-one corners of classic binary search. Code stems are Python.

Quickselect and Kth Element

Partition-based selection: kth smallest in expected `O(n)`, worst case `O(n^2)`, plus when to prefer a heap-based approach.

Dynamic Programming Warm-Up

Memoization, tabulation, and writing transitions for classic 1D DP. Code stems are Python.

Greedy Algorithms Warm-Up

Identify when a greedy choice is correct and when it fails. Drills cover activity selection, coin change with canonical denominations, and Huffman intuition.

Knapsack Family Quiz

0/1, unbounded, and bounded knapsack: state definitions, loop directions, and which variant fits a given problem.

DP on Strings Quiz

Edit distance, longest common subsequence, and palindrome DP. Drills focus on state definitions and transitions.

DP on Grids Quiz

Path counts, minimum path sum, and obstacle handling on rectangular grids. Code stems are Python.

Number Theory Warm-Up

Short drills on GCD, LCM, modular arithmetic, and modular exponentiation. A gentle on-ramp for interview problems that lean on integer math identities.

Promises and async/await Basics

Beginner drills on Promise resolution order, async/await semantics, and the microtask queue. Three short JavaScript snippets you can predict line-by-line.

JavaScript Language Trivia

Beginner JS quirks to predict and explain: `==` vs `===`, hoisting, `this` binding in different call sites, and one quick closure trace.

JavaScript Coercion and Equality Code Traces

Six output traces drilling on `==` vs `===`, unary `+`, falsy values, and chained relational coercion. Sharpens the rules JS applies before comparing.

JavaScript Hoisting and TDZ Code Traces

Six traces covering `var` declaration hoisting, function-declaration hoisting, TDZ access of `let`/`const`, and IIFE shadowing. Sharpens the mental model of when a binding exists vs. when it has a value.

JavaScript `this` and Arrow Function Code Traces

Six traces covering lost-`this` on extracted methods, arrow inherits-from-enclosing, function-as-constructor return, IIFE `this`, and static vs prototype methods.

JavaScript Scope and Closure Code Traces

Six traces covering the `var` loop-closure pitfall, parameter shadowing, IIFE captures, block scope leaks, and `delete` on locals.

JavaScript Object Reference and Key Coercion Traces

Six traces covering object-key stringification, reference vs literal equality, `Object.create` prototype chains, and shallow-copy aliasing with arrays.

JavaScript Array Method Output Traces

Six traces drilling on in-place vs returning array methods: `reverse`, sparse arrays, `indexOf`, `filter(Boolean)`, default lexicographic `sort`, and `copyWithin`.

JavaScript `typeof`, NaN, and Number Quirks Traces

Six traces covering the `typeof` chain, `isNaN` vs `Number.isNaN`, `parseInt` with `map`, the comma operator, `Object.is`, and `Number()` vs `new Number()`.

JavaScript Array and Object Fundamentals Quiz

Test the day-one moves for working with arrays and objects: type-checking, copying, deduping, and the gotchas hiding under shallow vs deep clones.

let, var, const, and Hoisting Conceptual Quiz

Walk through the scoping, redeclaration, and hoisting rules for `var`, `let`, and `const`, plus the TDZ trap that shows up in nearly every interview.

JavaScript Closures and Private State Quiz

Build the classic closure patterns: encapsulated counters, lexical-scope inheritance through nested functions, and constructor-level private fields.

Prototype Chain and Inheritance Quiz

Practice the prototype-chain mechanics: extending built-ins, defining shared properties on `Object.prototype`, and traversing the chain via `Object.getPrototypeOf`.

JavaScript Immutability and References Quiz

Lock down objects with `Object.freeze`, build read-only properties with `Object.defineProperty`, and reason about why React leans on immutable updates.

JavaScript Modules and Encapsulation Quiz

Compare the module patterns that ship in modern JavaScript: ES modules, the revealing-module IIFE, classic singletons, and method-borrowing via `call`, `apply`, and `bind`.

Debounce, Throttle, and Rate Limiting Quiz

Implement the rate-limiting primitives that ship in every UI codebase: debounce, throttle, leading-edge debounce, and `requestAnimationFrame`-paced throttling.

Event Delegation and Event Bus Quiz

Practice DOM event delegation, build a minimal pub/sub event bus, and roll your own dispatcher so cross-component communication stays decoupled.

Fetch API and Error Handling Quiz

Practice the small but easily-bungled `fetch` rituals: real error handling, Promise wrappers around timers, and `Promise.resolve` / `Promise.reject` for branching success states.

JavaScript Control Flow and Conditional Quiz

Read JavaScript's small but treacherous control-flow rules: switch fall-through, ASI biting return statements, and short-circuit logical chains.

JavaScript String Manipulation Challenges

Six small-but-tricky string problems: longest-word slicing, list extraction, manual reversal, palindrome checks, anagram detection, and capitalizing every word.

Numeric Puzzles and FizzBuzz Challenges

Six numeric warm-ups: recursive exponent, random sampling, prime check, recursive 1..n, completing missing numbers, and iterative Fibonacci.

Array Cross-Reference and Lookup Challenges

Six lookup-and-filter drills: id-to-id matching with Sets, random sampling without duplicates, valid-only filtering, numeric-only extraction, value-by-row matching, and rest-parameter multipliers.

Object Transformation Challenges

Six object-shape problems: building a tree from a flat array, valid-key extraction, chainable methods, stats reshaping, recursive leaf walking, and deep equality.

JavaScript Tooling and Build Trivia

Three quick-fire build-pipeline questions: transpiler vs polyfill, Babel vs SWC, and what source maps actually do.

JavaScript Function Fundamentals Quiz

Four day-one essentials about functions: how to define them, when to choose declaration vs expression vs arrow, default parameters, and rest/spread.

React Hooks Fundamentals Quiz

Six drills on the core React hooks: useState, useEffect, useReducer, useCallback, useMemo, and writing custom hooks. Good for tightening mid-level interview answers.

React Component Communication Quiz

Four quick checks on how React components pass data down via props and notify parents via callbacks, plus when render-props become a better tool than another layer of props.

Controlled vs Uncontrolled Components Quiz

Four checks on the controlled / uncontrolled split for React form inputs, including the file-input edge case and the warning React emits when you flip between defaultValue and value.

React State Management Without Redux Quiz

Four checks on the non-Redux options for sharing React state: local component state, Context, useReducer, and lightweight stores like Zustand or Jotai.

Lifting State and Context API Quiz

Six drills on lifting state to a common ancestor, when to switch to Context, and the useReducer + useContext pattern for a small, self-contained store.

React Error Boundaries and StrictMode Quiz

Four drills on class-component error boundaries and how React.StrictMode surfaces effect bugs by double-invoking lifecycles in development.

React Data Fetching and Effects Quiz

Four drills on fetching data with useEffect, avoiding stale closures, and cleaning up in-flight requests when the component unmounts or the input changes.

React Router and Code Splitting Quiz

Four drills on declarative routing with react-router and using React.lazy plus Suspense to split bundles per route or per heavy component.

React Rendering and Reconciliation Quiz

Four drills on React's virtual DOM, the reconciliation diffing algorithm, and why stable list keys matter so much.

React Lifecycle and Class Component Quiz

Four drills on legacy class lifecycle methods that still show up in interviews and codebases: mount/update/unmount, getSnapshotBeforeUpdate, setState batching, and getDerivedStateFromProps.

React Portals, Fragments, and StrictMode Quiz

Three drills on three small but tested React features: portals (with their event bubbling quirk), fragments, and what StrictMode does in development.

React Synthetic Events and Event Pooling Quiz

Three drills on React's SyntheticEvent wrapper, how delegation works, and the difference between the React 16 pooling era and React 17+ behavior.

React Refs and Imperative Handles Quiz

Three drills on using refs to reach into the DOM, forwarding a ref through a wrapper component, and using useImperativeHandle to expose a controlled API.

CSS Layout Fundamentals Quiz

Four drills on the foundational CSS layout primitives: the display property, positioning modes, a sticky footer pattern, and the z-index stacking context.

CSS Grid and Flexbox Quiz

Four drills on the differences between flexbox and grid, plus the gap, auto-fit, and minmax patterns that show up in real responsive layouts.

CSS Responsive Design and Media Queries Quiz

Three drills on responsive design: classic viewport media queries, modern container queries, and using clamp() for fluid typography that scales between breakpoints.

CSS Theming and Custom Properties Quiz

Three drills on theming with CSS custom properties: declaring a token set, switching themes at runtime, and respecting the OS prefers-color-scheme setting.

CSS Typography and Effects Quiz

Five drills on practical CSS typography and visual effects: text-shadow, gradients, layered shadows for a faux 3D look, fluid typography with clamp(), and the parallax background-attachment trick.

CSS Form and Component Styling Quiz

Four drills on styling forms and small components with pseudo-classes, pseudo-elements, and the sibling combinator: dropdown menus, custom checkboxes, accessible accordions, and automatic numbering.

HTML Semantic Tags and Accessibility Quiz

Quick drills on semantic HTML: why it matters, document outline with sectioning elements, figure/figcaption, and ARIA landmark roles for accessibility.

HTML Media and Interactive Elements Quiz

Six drills on HTML5 media: responsive video embeds, the progress element, canvas drawing, custom audio controls, the picture element for art direction, and image maps.

HTML Forms and Validation Quiz

Four drills on HTML5 forms: building accessible forms with constraint validation, `<datalist>` autocomplete, the `<output>` element for live calculations, and ARIA roles for error reporting.

Array Higher-Order Methods Quiz (map / filter / reduce / find)

Four drills on the core array higher-order methods: reduce for aggregation, filter plus reduce (or Math.max) for selection, find for first-match lookup, and flatMap for one-step map-and-flatten.

JavaScript Variable Hoisting: var vs let/const Explanations Quiz

Two seeded explanations (var hoisting and the let/const TDZ) plus two companion drills covering function-declaration hoisting and a common interview trap.

JavaScript Vowel Counting: Three Approaches Quiz

Count vowels in a string three different ways (loop + Set lookup, split + forEach, regex match) plus two companion drills on case sensitivity and big-O analysis.

JavaScript FizzBuzz: Two Implementations Quiz

Two seeded FizzBuzz implementations (modulo branching and order-sensitive variant) plus two companion drills covering a generalized N-divisors version and a micro-benchmark.

JavaScript Take-Out-and-Rest Array: Two Approaches Quiz

Two seeded approaches to build a map of each-element-to-the-rest (reduce + filter and forEach + filter), plus two companions on slice + concat and a complexity discussion.

JavaScript Count Backward by Evens: Two Approaches Quiz

Two seeded approaches to enumerate even numbers descending from n (filter-on-step-1 vs step-2 loop), plus two companions on Array.from and an odd-start edge case.

JavaScript Immutable Object Key Removal: Two Approaches Quiz

Two seeded approaches to remove an object key without mutation (spread + delete, reduce + filter), plus two companions on destructure-and-drop and a deep-clone caveat.

JavaScript Object Values to Array: Two Approaches Quiz

Two seeded approaches to convert an object's values to an array (Object.values spread vs Object.keys.map) plus two companions on Object.entries and ordering pitfalls.

JavaScript Group Students by ID: Two Approaches Quiz

Two seeded approaches to group an array of student records by id (reduce + dict and the `in` operator), plus two companions on Map and Object.groupBy.

JavaScript Cross-Browser Event Target: Two Approaches Quiz

Two seeded approaches to read the event target across browsers (event.target plus legacy event.srcElement, and a delegated table cell editor), plus two companions on currentTarget and composedPath.

JavaScript Largest Difference Without Sort: Two Approaches Quiz

Two seeded approaches to compute the largest pairwise difference in an array without sorting (single-pass min/max and the brute-force nested loop), plus two companions on prefix tracking and a negative-numbers twist.

JavaScript var Loop Closure: Two Explanations Quiz

The classic var-in-a-for-loop closure trap, explained two ways (shared `i` binding and the IIFE capture fix), plus two companions on the `let` per-iteration binding and a queueMicrotask version of the trap.

JavaScript Array Occurrences Count: Two Approaches Quiz

Tally how many times each value appears in an array, two ways (reduce + dict and Map-based counter), plus two companions on Object.create(null) safety and case-insensitive string tallies.

JavaScript Lost-this and Four Fixes Quiz

Repair a method whose inner regular function loses `this`, four ways (arrow function, `bind`, save-this-in-self pattern, explicit `.call`), plus an explainer on lexical-vs-dynamic this binding.

JavaScript String-Only Regex Match: Three Approaches Quiz

Validate that a string contains only letters and whitespace, three ways (`String.prototype.match` + literal, `RegExp.test`, including-special-chars via `\D`), plus companions on Unicode letters and inverting the rule.

JavaScript Missing Numbers Finder: Two Approaches Quiz

Find missing integers between the min and max of an array, two ways (sort + gap-walk and Set diff over min..max), plus companions on the consecutive-1..n case and detecting duplicates.

JavaScript X and O Balance: Two Approaches Quiz

Check whether a string contains an equal count of `x` and `o` (case-insensitive), two ways (regex match-array length and filter + length), plus companions on counting any pair of characters and treating empty input.

JavaScript Inherit x From Function b: Two Approaches Quiz

Make constructor `b` inherit `x` from constructor `a`: parent-constructor call via `Function.prototype.call`, ES6 `extends` + `super`, `Object.create` chaining, and an arrow-vs-constructor explainer.

JavaScript Function Declaration vs Expression Hoisting: Two Explanations Quiz

Trace mixed declaration / expression calls before either is defined: declaration fully hoisted vs expression-as-var only binding hoisted, plus TDZ for let/const and named function expressions.

JavaScript Spread Operator Refactor: Two Explanations Quiz

Refactor a manual `sum(nums[0], nums[1], nums[2])` call with the spread operator, two equivalent shapes (spread shortcut and the older `apply(null, nums)` form), plus companions on rest parameters and array-spread vs concat.

JavaScript Class Static vs Instance: Two Explanations Quiz

Two seeded explanations of how a `Person` class with a static method, a getter, and an instance method behaves when called via `new`, plus two companions on getter syntax and static field inheritance.

JavaScript Pair-Sum Finder: Two Approaches Quiz

Two seeded ways to test whether two numbers in an array add up to a target (nested loop and Set complement), plus two companions on time complexity and on returning the actual pair instead of a boolean.

JavaScript find vs filter for Student Lookup Quiz

Two seeded approaches to look up students by name: `find` returns the first match, `filter` returns every match. Two companions cover return-type pitfalls and short-circuit semantics.

JavaScript String Lengths Array: Four Approaches Quiz

Four seeded ways to turn an array of strings into an array of their lengths (map, for-loop with push, reduce, for-of), plus one companion on a recursive variant.

JavaScript Factorial: Three Implementations Quiz

Three seeded ways to compute n! (iterative loop, classic recursion, reduce), plus two companions on memoization and on guarding against negative inputs.

JavaScript Square and Join Digits: Two Approaches Quiz

Two seeded ways to square each digit of an integer and concatenate the results (string split with map and join, plus a while-loop modulo extraction), with two companions on negative numbers and on returning a string.

JavaScript Set and Map Values Output: Two Explanations Quiz

Two seeded explanations of how `Set` and `Map` expose their values via iterators and what `console.log` prints when you call `.values()` on each, plus two companions on insertion-order guarantees and on de-duplication semantics.

JavaScript Add-N via Currying: Two Approaches Quiz

Two seeded ways to build an `adder(n)` that adds `n` to its argument (closure-returning-function and `Function.prototype.bind`), plus two companions on three-arg currying and a generic curry helper.

JavaScript Merge Two Objects: Three Approaches Quiz

Three seeded ways to merge two plain objects (spread, `Object.assign`, and a manual `for...in` copy), plus two companions on shallow-vs-deep semantics and on which approaches mutate the target.

React ReactDOMServer: Two Explanations Quiz

Two explanations of `react-dom/server` rendering APIs (string vs streaming) plus companions on streaming SSR with `renderToPipeableStream` and on hydration mismatches.

React Controlled vs Uncontrolled Components: Two Explanations Quiz

Two explanations of controlled vs uncontrolled inputs with concrete code, plus companions on `defaultValue` and on extending the controlled idea beyond form inputs.

React Stateful vs Stateless Components: Two Explanations Quiz

Two explanations of the stateful/stateless (smart vs presentational) split, plus companions on hooks-era state in function components and on testability trade-offs.

React Auto-Focus With Refs: Two Approaches Quiz

Two approaches to auto-focusing an input in React (`useRef` + `useEffect` vs the native `autoFocus` prop), plus companions on focusing after async state and on focusing inside a portal.