AlgoScope

Interview Core

The mainstream set a university course or an interview loop expects, easiest first.

180 stops over 77 lessons, teaching 227 of the 382 topics in the registry. A stop is one screen, not one topic: a lesson page teaches everything on it at once, so the path stops at pages rather than sending you back to one you have read. Nothing here is hand-ordered - the order is resolved from the registry, easiest first, and never puts a topic before what it needs.

180stops, each one a screen
Start the track →
  1. Array: Insert 7 at index 2Data Structures · 2 topics
  2. Array: Delete index 1Array Algorithms and Techniques
  3. Array: Visit every slotArray Algorithms and Techniques
  4. Array: Linear search, foundSearching
  5. Binary SearchSearching
  6. Two Pointers: Two sum on a sorted arrayArray Algorithms and Techniques · 4 topics
  7. Two Pointers: Remove duplicatesTwo Pointers · 2 topics
  8. Two Pointers: Reverse in placeArray Algorithms and Techniques
  9. Bubble SortSorting
  10. Stable Sorting: Selection sort flips itComplexity Analysis
  11. Insertion SortSorting
  12. Selection SortSorting
  13. Dynamic ArrayData Structures
  14. Singly Linked List: Reverse the listData Structures · 2 topics
  15. Singly Linked List: Insert at the headLinked List Algorithms
  16. Singly Linked List: Insert at index 2Linked List Algorithms
  17. Singly Linked List: TraverseLinked List Algorithms
  18. Singly Linked List: Delete 4Linked List Algorithms
  19. Singly Linked List: Insert at the tailLinked List Algorithms
  20. Complexity in Numbers: Six classes as n doublesComplexity Analysis
  21. Complexity in Numbers: Extra memory, stack includedComplexity Analysis
  22. Best, Average, Worst: Worst case: reversedComplexity Analysis
  23. Brute Force: Found near the endAlgorithmic Paradigms
  24. Merging Sorted Lists: Two lists, interleavingLinked List Algorithms
  25. LRU Cache: A hit moves the node to the frontData Structures · 2 topics
  26. Queue: Enqueue, dequeue, peekData Structures · 3 topics
  27. Circular Queue: Rear wraps aroundData Structures
  28. Deque: Push and pop at both endsData Structures
  29. Stack: Push, pop, peekData Structures · 4 topics
  30. The Call Stack: fact(5) down and back upData Structures
  31. The Call Stack: Summing a list recursivelyRecursion
  32. The Call Stack: No base case, stack overflowRecursion
  33. Tree Traversals: Inorder comes out sortedData Structures · 2 topics
  34. Tree Traversals: Level order uses a queueTree Algorithms
  35. Tree Traversals: Postorder, root comes lastTree Algorithms
  36. Tree Traversals: Preorder, node before subtreesTree Algorithms
  37. BFS and DFS: Breadth-first from 0Data Structures · 3 topics
  38. BFS and DFS: Depth-first from 0Graph Traversal · 2 topics
  39. BFS and DFS: Three componentsGraph Traversal
  40. DFS Checks: Recursive DFS and its call stackGraph Traversal
  41. Binary Search Tree: Search for 45Data Structures · 2 topics
  42. Binary Search Tree: Insert 65Tree Algorithms
  43. BST Queries: Find the minimumTree Algorithms
  44. DP on a Grid: Paths on a 3 x 4 gridDynamic Programming · 3 topics
  45. Stacks for Expressions: Evaluate postfixStack and Queue Algorithms
  46. String Matching: Naive, every shiftData Structures · 2 topics
  47. Stacks for Expressions: Balanced bracketsStack and Queue Algorithms
  48. Matrix: Row-major orderData Structures
  49. Matrix: Adjacency matrix from edgesData Structures
  50. Flood Fill: Fill a regionGraph Traversal
  51. Prefix Sum and Kadane: Range sum from prefix totalsArray Algorithms and Techniques · 2 topics
  52. Bit Manipulation: Read one bitBit Manipulation
  53. Bit Manipulation: Clear a bit that was 1Bit Manipulation
  54. Bit Manipulation: Count the 1s, Kernighan styleBit Manipulation · 2 topics
  55. Bit Manipulation: Set a bit that was 0Bit Manipulation
  56. Bit Manipulation: Flip a bitBit Manipulation
  57. XOR Tricks: Swap without a temporaryBit Manipulation
  58. Number Theory Basics: gcd(48, 18) by EuclidMathematics · 2 topics
  59. Number Theory Basics: Adding on a clock of 12Mathematics
  60. Number Theory Basics: Is 97 prime?Mathematics
  61. Number Theory Basics: Prime factors of 360Mathematics
  62. Sieve of Eratosthenes: Primes up to 30Mathematics
  63. Multiples, Powers, Pascal: lcm of 4 and 6Mathematics
  64. Multiples, Powers, Pascal: C(5, 2)Mathematics
  65. Shortest Paths: Dijkstra on directed edgesData Structures
  66. Shortest Paths: Dijkstra from 0Data Structures · 2 topics
  67. Minimum Spanning Tree: Kruskal, cheapest edges firstData Structures · 2 topics
  68. Plane Geometry: Points, a vector and a distanceComputational Geometry · 3 topics
  69. Plane Geometry: A left turnComputational Geometry · 2 topics
  70. Plane Geometry: Monotone chain hullComputational Geometry
  71. Plane Geometry: Two segments that crossComputational Geometry
  72. Plane Geometry: Shoelace area of a pentagonComputational Geometry
  73. Extended Euclid: gcd(48, 18) with coefficientsMathematics
  74. Number Theory Basics: 3 to the 13, mod 7Mathematics
  75. Multiples, Powers, Pascal: 3 to the 6 mod 7Mathematics
  76. Multiples, Powers, Pascal: Inverse of 3 mod 11Mathematics
  77. Hash Table: Fill a table and watch it collideData Structures · 2 topics
  78. Hash Table: Find a key behind a collisionData Structures · 2 topics
  79. Hash Table: Insert that walks past a collisionData Structures · 2 topics
  80. Hash Table: Delete leaves a markerHashing
  81. Hash Map: Filling buckets, with collisionsData Structures · 2 topics
  82. Frequency Map: First value seen beforeProblem-Solving Patterns
  83. Prefix Sum and Kadane: Count subarrays summing to 7Array Algorithms and Techniques
  84. Prefix Sum and Kadane: Kadane on a mixed arrayArray Algorithms and Techniques · 2 topics
  85. String Matching: Rabin-Karp rolling hashString Algorithms
  86. String Matching: Prefix function of a patternString Algorithms
  87. String Matching: KMP, no re-readingString Algorithms
  88. XOR Tricks: Find the single numberBit Manipulation
  89. Bitmask: A set in one integerBit Manipulation
  90. Bitmask: Every subset of threeBit Manipulation
  91. Bit Manipulation: 64 is a power of twoBit Manipulation
  92. Bit Manipulation: Isolate the lowest 1Bit Manipulation
  93. Counting and Radix Sort: Counting sort, repeated keysSorting
  94. Counting and Radix Sort: Radix sort, ones then tensSorting
  95. Matrix: 2D prefix sumRange Queries
  96. Difference Array: Three overlapping rangesArray Algorithms and Techniques
  97. Flood Fill: Count the islandsGraph Traversal
  98. Trie: Insert words sharing prefixesData Structures · 2 topics
  99. Trie: Search for a stored wordString Algorithms
  100. Trie: Autocomplete: everything under caString Algorithms
  101. DP on a Grid: Cheapest pathDynamic Programming
  102. Knapsack: 0/1 knapsack, capacity 7Dynamic Programming
  103. Knapsack: Unbounded, the same itemsDynamic Programming
  104. String DP: LCS of abcde and aceDynamic Programming
  105. String DP: kitten to sittingDynamic Programming
  106. String DP: Longest common substringDynamic Programming
  107. All-Pairs Shortest Paths: Four vertices, three rounds of gainsShortest Path
  108. BST Queries: Successor from an ancestorTree Algorithms
  109. BST Queries: Values between 35 and 65Tree Algorithms
  110. BST Queries: Lowest common ancestorTree Algorithms
  111. Binary Search Tree: Delete a node with two children (30)Tree Algorithms
  112. DFS Checks: An undirected cycleGraph Traversal
  113. DFS Checks: Two-colouring an even cycleGraph Traversal
  114. Topological Sort: Kahn's algorithmData Structures · 2 topics
  115. Topological Sort: DFS finish orderConnectivity and Topological Order
  116. Binary Heap: Build a min heapData Structures · 3 topics
  117. Binary Heap: Build a max heapData Structures
  118. Binary Heap: Insert climbs to the rootData Structures · 3 topics
  119. Binary Heap: Extract the minimumHeap Algorithms · 2 topics
  120. K-th Largest: Third largest of nineHeap Algorithms
  121. Heap Sort: Eight valuesSorting
  122. Merging Sorted Lists: Three lists through a heapLinked List Algorithms
  123. Shortest Paths: Bellman-Ford from 0Shortest Path
  124. Huffman Coding: The classic: five characters, very skewedGreedy
  125. Union-Find: Merging sets by sizeData Structures
  126. Union-Find: Path compression at workConnectivity and Topological Order
  127. Recursion Trees: Divide and conquer over a rangeDivide and Conquer
  128. Recursion Trees: fib(5), the plain treeDynamic Programming
  129. Recursion Trees: fib(6) with memoizationDynamic Programming · 2 topics
  130. DP in One Row: Fibonacci by tableDynamic Programming
  131. DP in One Row: Ways to climb 8 stairsDynamic Programming
  132. DP in One Row: House robberDynamic Programming
  133. DP in One Row: Fewest coins for 6 from 1, 3, 4Dynamic Programming
  134. DP in One Row: Maximum subarrayDynamic Programming
  135. DP in One Row: Longest increasing subsequenceDynamic Programming
  136. Merge Sort: Eight valuesSorting
  137. Minimum Spanning Tree: Prim, growing from 0Minimum Spanning Tree
  138. Two Pointer Problems: Three sum to zeroTwo Pointers
  139. Two Pointer Problems: Container with most waterTwo Pointers
  140. Build and Validate a BST: Seven sorted values, balancedTree Algorithms
  141. Build and Validate a BST: Swap two values and catch itTree Algorithms
  142. Backtracking: 4 queens, with backtrackingBacktracking · 2 topics
  143. Backtracking: A maze with a dead endBacktracking
  144. Backtracking: Word search with a dead endBacktracking
  145. Enumeration: All orderings of threeBacktracking
  146. Enumeration: All subsets of threeBacktracking
  147. Enumeration: Choose 2 of 4Backtracking
  148. Enumeration: Sums to 7 with repeats allowedBacktracking
  149. Monotonic Stack: Next greater elementData Structures · 2 topics
  150. Stacks for Expressions: Evaluate infix with two stacksStack and Queue Algorithms
  151. Stacks for Expressions: Infix to postfixStack and Queue Algorithms
  152. The Call Stack: Tail recursion reuses the frameRecursion
  153. Complexity in Numbers: Appends to a doubling arrayComplexity Analysis
  154. Complexity in Numbers: 3n + 5 is Theta(n)Complexity Analysis
  155. Rehashing: One rehashHashing
  156. Rehashing: Collisions before the rehashHashing
  157. Greedy Choice: Coins where greedy failsAlgorithmic Paradigms
  158. Fractional Knapsack: The classic three itemsGreedy
  159. Intervals and Greedy Choices: Assigning roomsGreedy
  160. Intervals and Greedy Choices: How many roomsGreedy
  161. Intervals and Greedy Choices: Earliest finish firstGreedy
  162. Fast and Slow Pointers: Find the middle of sevenTwo Pointers · 2 topics
  163. Fast and Slow Pointers: A list that loopsLinked List Algorithms
  164. Fast and Slow Pointers: Where the loop beginsLinked List Algorithms
  165. Fast and Slow Pointers: Remove the 2nd from the endLinked List Algorithms
  166. Quick Sort: Seven valuesArray Algorithms and Techniques · 2 topics
  167. Rotate, Partition, Select: The 4th smallestSorting
  168. Rotate, Partition, Select: Sort into less, equal, greaterArray Algorithms and Techniques
  169. Rotate, Partition, Select: Rotate right by 3Array Algorithms and Techniques
  170. Sliding Window: Largest sum of 3 in a rowSliding Window · 3 topics
  171. Sliding Window: Shortest run summing to 7Sliding Window
  172. Frequency Map Window: At most 2 distinctSliding Window
  173. Substring Windows: Longest run without a repeatSliding Window
  174. Sliding Window Maximum: Maximum of every 3Data Structures
  175. Search on the Answer: Least ship capacity in 5 daysProblem-Solving Patterns
  176. Segment Tree: Minimum of indices 1 to 6Range Queries
  177. AVL Tree: A longer mixed sequenceData Structures
  178. AVL Tree: Already balanced, no rotationsTree Algorithms
  179. AVL Tree: Right-right needs a left rotationTree Algorithms
  180. AVL Tree: Left-left needs a right rotationTree Algorithms

Not this one?

Foundations covers the same curriculum with a different reach, and every topic is reachable on its own through the 29 categories.

FoundationsBrowse by category