Free coding interview video lessons
Watch all 65 course recordings without an account, from data structures and algorithms to JavaScript. Each video includes chapters, written notes, and any corrections made since recording.
65 video lessons across 12 topics.
Arrays
Arrays
Understand array indexing, insertion, iteration, and resizing, then practice the invariants used in array and matrix interview problems.
12 min · Chapters and lesson notes
Worked problemImplement an Array
Build an array abstraction and reason about indexed access, insertion, removal, capacity, and the costs of moving existing elements.
10 min · Chapters and lesson notes
Worked problemWalk a Matrix
Watch a clockwise spiral traversal, trace shrinking boundaries, and review the corrected final-edge behavior in the current lesson.
17 min · Chapters and lesson notes
Worked problemProduct Array
Compute each array position from the product of the other values without division. Work through prefix/suffix state and zero-value cases.
14 min · Chapters and lesson notes
Worked problemValid Sudoku Board
Check Sudoku rows, columns, and subgrids for duplicate values. Practice mapping board positions to the constraints they must satisfy.
27 min · Chapters and lesson notes
Worked problemBest Time to Buy and Sell Stock
Find the best single buy-and-sell opportunity by tracking an earlier minimum. Practice ordering constraints and decreasing-price inputs.
10 min · Chapters and lesson notes
Essential Concepts
Hash Tables
Hash Tables
Learn how hashing maps keys to storage, why collisions matter, and how maps and sets support common interview optimizations.
24 min · Chapters and lesson notes
Worked problemImplement a Hash Table
Build a hash-table implementation, store and retrieve key/value pairs, and examine how collisions affect correctness and performance.
11 min · Chapters and lesson notes
Worked problemCatch the Hacker
Identify a repeatedly duplicated email by counting frequencies. Compare repeated scans with a map-based pass through the input.
8 min · Chapters and lesson notes
Worked problemTarget Two Sum
Find two distinct indices whose values reach a target. Compare pair enumeration with a hash-map solution and test duplicate values.
14 min · Chapters and lesson notes
Strings
Strings
Study string traversal, character representation, immutability, and construction costs before practicing text interview problems.
9 min · Chapters and lesson notes
Concept lessonPalindromes, Permutations, Anagrams
Distinguish palindrome order, permutation arrangements, and anagram frequency counts, then choose the state each text problem needs.
4 min · Chapters and lesson notes
Worked problemGroup Permutations of Palindromes
Practice grouping strings by character relationships and reasoning about which arrangements can form a palindrome.
21 min · Chapters and lesson notes
Recursion
Recursion
Trace recursive execution, define a smaller subproblem, and connect base cases and return values to a clear correctness argument.
15 min · Chapters and lesson notes
Worked problemSum Digits
Compute a number’s digit sum using arithmetic. Practice recursive decomposition, termination, and tests for single-digit inputs.
12 min · Chapters and lesson notes
Worked problemGenerate All Permutations
Enumerate input arrangements while managing choices and restoring state. Analyze the output size and test small permutation examples.
20 min · Chapters and lesson notes
Searching and Sorting
Logarithms and Time Complexity
Understand why repeated halving produces logarithmic work and apply that reasoning to search intervals and recursive algorithms.
7 min · Chapters and lesson notes
Concept lessonSearching and Binary Search
Search sorted data by narrowing a candidate interval. Practice boundaries, midpoint updates, and the conditions that guarantee progress.
14 min · Chapters and lesson notes
Concept lessonSorting
Compare sorting approaches, runtime assumptions, and the ways sorted order changes an interview problem’s available solutions.
10 min · Chapters and lesson notes
Worked problemInterview Scheduler
Work through an interview scheduling problem and practice using ordered information to reduce the search for a valid answer.
23 min · Chapters and lesson notes
Worked problemShifted Search
Find a target in a shifted sorted array by reasoning about ordered intervals and choosing which half can still contain the answer.
16 min · Chapters and lesson notes
Worked problemSorted Matrix Search
Use a matrix’s ordering constraints to reduce the search space. Track boundaries and test targets at edges or outside the data.
12 min · Chapters and lesson notes
Worked problemAge Sort
Explore how a restricted value range can change a sorting problem. Compare counting-based work with general comparison sorting.
9 min · Chapters and lesson notes
Worked problemFirst Bad Version
Find a transition in an ordered sequence using a predicate. Practice binary-search interval definitions and edge-boundary cases.
13 min · Chapters and lesson notes
Linked Lists
Linked Lists
Understand linked-list structure, traversal costs, and the pointer relationships behind insertion, deletion, and reversal.
14 min · Chapters and lesson notes
Concept lessonPointers
Reason about references, node identity, and reachability so pointer updates do not lose the remainder of a list or tree.
10 min · Chapters and lesson notes
Worked problemImplement a Linked List
Build linked nodes and list operations, maintain head and tail relationships, and test empty and single-node structures.
13 min · Chapters and lesson notes
Worked problemCombine Blockchains
Practice combining linked chains while preserving their nodes and maintaining the relationships needed to traverse the result.
13 min · Chapters and lesson notes
Worked problemReverse a Linked List
Reverse a list by tracking the previous, current, and next nodes. Explain the invariant and handle empty and single-node inputs.
7 min · Chapters and lesson notes
Worked problemMirror Delete
Work through a linked-list deletion exercise with careful reference updates, boundary checks, and tests that preserve reachable nodes.
13 min · Chapters and lesson notes
Stacks and Queues
Queues
Learn queue operations, implementation choices, and the role of first-in-first-out order in breadth-first traversal and scheduling.
6 min · Chapters and lesson notes
Concept lessonStacks
Learn stack operations and use last-in-first-out state for nested structures, traversal, and interview problem solving.
9 min · Chapters and lesson notes
Worked problemImplement a Queue
Implement enqueue and dequeue behavior while maintaining first-in-first-out order and handling empty-queue transitions.
10 min · Chapters and lesson notes
Worked problemImplement a Stack
Implement push, pop, and peek, maintain the top of the stack, and reason about operation costs and empty-state behavior.
7 min · Chapters and lesson notes
Worked problemMax Min Stack
Support stack operations while tracking minimum and maximum values. Practice duplicate values and restoring earlier aggregate state.
14 min · Chapters and lesson notes
Worked problemValid Brackets
Validate bracket ordering with a stack of unmatched openings. Test mismatched types, unfinished openings, and closing-first inputs.
13 min · Chapters and lesson notes
Trees
Trees
Learn tree terminology and recursive structure, then prepare for traversal, depth, ancestor, and binary-search-tree exercises.
17 min · Chapters and lesson notes
Concept lessonTree Traversal: In-Order, Pre-Order, Post-Order
Compare traversal orders by changing when each node is processed. Trace recursive calls and distinguish traversal from search-tree ordering.
10 min · Chapters and lesson notes
Concept lessonBinary Search Trees
Understand the ordering rules that guide binary-search-tree operations and how tree height affects search performance.
14 min · Chapters and lesson notes
Worked problemImplement a Binary Search Tree
Build a binary search tree, preserve its ordering contract during updates, and test search paths and empty-tree behavior.
9 min · Chapters and lesson notes
Worked problemBinary Tree Max Depth
Compute a tree’s depth from its subtrees. State the empty-tree convention and compare balanced and chain-shaped inputs.
11 min · Chapters and lesson notes
Worked problemBST Validate
Check the complete binary-search-tree ordering rule, including ancestor constraints that a parent-only comparison can miss.
16 min · Chapters and lesson notes
Worked problemClosest Common Ancestor in Binary Tree
Find the shared ancestor of two nodes by reasoning about subtree results and the relationship between node identity and ancestry.
15 min · Chapters and lesson notes
Graphs
Graphs
Model relationships with graph nodes and edges, compare representations, and prepare for reachability and traversal exercises.
21 min · Chapters and lesson notes
Concept lessonDepth-First Search
Traverse a graph by following branches, track visited nodes to handle cycles, and reason about recursive or explicit stack state.
15 min · Chapters and lesson notes
Concept lessonBreadth-First Search
Traverse by distance with a queue, avoid duplicate discoveries, and reconstruct shortest paths when edges have equal cost.
17 min · Chapters and lesson notes
Worked problemImplement a Graph
Represent vertices and edges, maintain neighbor relationships, and prepare a graph structure for traversal and reachability queries.
8 min · Chapters and lesson notes
Worked problemPilot a Rocket
Find a route through a satellite network. Practice BFS discovery order, parent tracking, cycles, and an unreachable destination.
20 min · Chapters and lesson notes
Worked problemCount Islands
Count connected land regions in a matrix. Compare DFS and BFS, mark visited cells, and test disconnected and diagonal land.
12 min · Chapters and lesson notes
Worked problemRobot Maze
Determine whether a robot can reach an exit under the allowed movement rules. Practice grid bounds, blocked cells, and path choices.
26 min · Chapters and lesson notes
Dynamic Programming
Subproblems and Overlapping Subproblems
Identify repeated smaller decisions and define state precisely before using caching or a dynamic-programming table.
11 min · Chapters and lesson notes
Concept lessonMemoization
Turn repeated recursive work into reusable results. Choose complete cache keys and distinguish missing results from valid zero values.
16 min · Chapters and lesson notes
Concept lessonBottom-Up vs. Top-Down
Compare memoized recursion with tabulation, choose a valid evaluation order, and reason about stack and table storage.
5 min · Chapters and lesson notes
Concept lessonDynamic Programming
Develop a recurrence, identify repeated states, and connect memoization and tabulation to interview problem-solving strategies.
31 min · Chapters and lesson notes
Worked problemVending Machine
Work through a vending-machine interview problem by identifying choices, smaller subproblems, and the state needed to reuse results.
44 min · Chapters and lesson notes
Worked problemThree Moves
Define transitions for a constrained-movement problem and practice solving repeated subproblems without recomputing each path.
20 min · Chapters and lesson notes
Worked problemSteal Packages
Maximize a total without taking adjacent entries. Derive skip/take decisions and compare recursive, memoized, and iterative approaches.
27 min · Chapters and lesson notes
JavaScript
Why does JavaScript Get its Own Topic
Connect general algorithm skills with JavaScript-specific behavior, browser programming, and practical utility implementations.
3 min · Chapters and lesson notes
Worked problemFix 'this'
Trace JavaScript receivers and callback invocation so you can explain and repair unexpected this values in interview code.
12 min · Chapters and lesson notes
Worked problemArray Methods
Practice array-method behavior, callback arguments, iteration, and edge cases by implementing familiar JavaScript operations.
9 min · Chapters and lesson notes
Worked problemBuild a JavaScript Promise
Watch a teaching implementation of a JavaScript promise, then compare settlement and callback scheduling with the current lesson.
25 min · Chapters and lesson notes
Worked problemPub-Sub and Event-Driven Programming
Implement event subscription and publication, track listeners, and connect the pattern to event-driven JavaScript applications.
13 min · Chapters and lesson notes
Worked problemDebounce
Watch how a trailing debounce resets its timer, retains the latest call, and waits until an event burst stops.
14 min · Chapters and lesson notes
Worked problemThrottle
Watch leading and trailing throttle behavior, track pending calls, and review the fix for absent or falsy arguments.
13 min · Chapters and lesson notes
Continue with the course
Open the full course for coding exercises and lessons without recordings, including JavaScript Interview Questions. Watching here does not mark an exercise complete or change your saved programming language.