Math for Algorithms

Counting, indexing, division and the single most reused expression in all of programming: n % size.

• 1. Numbers, quantities and indexes
• 2. Division as grouping
• 3. Modulo and remainders
• 4. Modulo as a cycle
• 5. Circular indexes: next and previous

Why indexes start at zero, off-by-one errors, traversal in both directions, and rotating an array.

• 6. Why array indexes work the way they do
• 7. length vs length − 1, and half-open ranges
• 8. Off-by-one errors and the fencepost problem
• 9. Forward traversal and stopping early
• 10. Backward traversal (and the bug it fixes)
• 11. Jumping through arrays
• 12. Circular arrays and ring buffers
• 13. Rotating arrays

Running totals, averages, min/max, occurrence counts and balances — the loop patterns behind every dashboard.

• 14. Counters
• 15. Running totals
• 16. Sum an array
• 17. Calculate an average
• 18. Find min and max manually
• 19. Count occurrences
• 20. Running balance

Even/odd, divisibility, truth tables, De Morgan, and how to simplify a condition nobody can read.

• 21. Even and odd numbers
• 22. Multiples
• 23. Divisibility rules and the order you test them
• 24. AND, OR and NOT
• 25. Truth tables
• 26. De Morgan's laws
• 27. Simplifying complicated conditions

Clamping, percentages, ratios, mapping one range onto another, and linear interpolation.

• 28. Minimum and maximum as a decision
• 29. Clamping values
• 30. Percentages
• 31. Ratios and proportions
• 32. Mapping a value from one range to another
• 33. Linear interpolation

Deltas, distance, bounding boxes, collision and keeping a dragged object inside its container.

• 34. X and Y coordinates
• 35. Delta movement
• 36. Distance
• 37. Bounding rectangles
• 38. Collision detection
• 39. Keeping objects inside boundaries

Frequency counters, two pointers, sliding windows and prefix sums — derived from brute force, not memorized.

• 40. Brute force thinking
• 41. Frequency counters
• 42. Two pointers
• 43. Palindromes with two pointers
• 44. Two Sum, three ways
• 45. Sliding window
• 46. Prefix sums
• 47. Fast and slow pointers

Powers of two, binary, bits, masks, permission flags and exponential backoff.

• 48. Powers
• 49. Powers of two
• 50. Binary numbers
• 51. Bits and bytes
• 52. Bit masks
• 53. Permission flags
• 54. Exponential growth and backoff

Linear search, binary search drawn half by half, and what O(log n) actually feels like.

• 55. Linear search
• 56. Binary search, drawn half by half
• 57. Why halving is so powerful
• 58. Reading O(log n)
• 59. Implementing binary search

Compare, swap, selection and insertion for understanding, then divide-and-conquer with merge sort — plus bubble sort and quicksort.

• 60. Comparison
• 61. Swapping
• 62. Selection sort
• 63. Insertion sort
• 64. Divide and conquer
• 65. Merge sort
• 66. Why you should use the built-in sort
• 133. Bubble sort
• 134. Quicksort

Base cases, the call stack drawn frame by frame, factorial, Fibonacci and why the naive version collapses.

• 67. What recursion really means
• 68. Base cases
• 69. Visualising the call stack
• 70. Factorial
• 71. Fibonacci
• 72. Why naive Fibonacci collapses, and memoisation
• 73. Recursive tree traversal

Seconds to h:m:s, clock arithmetic, countdowns, repeating intervals and time windows.

• 74. Seconds, minutes and hours
• 75. Clock arithmetic
• 76. Countdown timers
• 77. Repeating intervals
• 78. Time windows

Pagination, offsets, batching, round-robin, rate limits, backoff, hash buckets and sharding.

• 79. Pagination
• 80. Offsets
• 81. Batch processing
• 82. Round-robin load balancing
• 83. Rate limiting
• 84. Exponential backoff in practice
• 85. Hash buckets
• 86. Partitioning and sharding

Progress, scroll percentage, aspect ratios, animation interpolation, drag math and index → row/column.

• 87. Progress calculations
• 88. Scroll percentage
• 89. Responsive layout calculations
• 90. Aspect ratios
• 91. Animation interpolation
• 92. Drag and drop mathematics
• 93. Grid calculations: index to row and column

Count the operations first, then name the curve. O(1), O(n), O(n²), O(log n), O(n log n), time vs space.

• 94. Counting operations
• 95. O(1) — constant time
• 96. O(n) — linear time
• 97. O(n squared) — quadratic time
• 98. O(log n) and O(n log n)
• 99. Comparing algorithms honestly
• 100. Time versus space

Read it, solve it by hand, find the pattern, write pseudocode, translate it twice, then break your own assumptions.

• 101. Read the problem correctly
• 102. Identify inputs and outputs
• 103. Solve it by hand first
• 104. Create your own examples
• 105. Find the pattern
• 106. Write pseudocode
• 107. Translate pseudocode into JavaScript
• 108. Translate the same algorithm into Kotlin
• 109. Find the edge cases
• 110. Test your assumptions
• 111. Improve a brute-force solution
• 112. Explain your own algorithm

How memory actually stores an array, arrays vs linked lists, hash functions, collisions and load factor.

• 113. How memory actually stores an array
• 114. Arrays versus linked lists
• 115. Hash functions
• 116. Collisions and load factor
• 117. When a hash table is the wrong answer

Graphs as data, breadth-first search, weighted edges and Dijkstra's algorithm.

• 118. Graphs as data
• 119. Breadth-first search
• 120. Depth-first search
• 121. Weighted edges, and why BFS stops working
• 122. Dijkstra's algorithm

Trees as nested data, binary search trees, traversal orders and why balance decides performance.

• 123. Trees as a special kind of graph
• 124. Binary search trees
• 125. Why balance decides everything
• 126. Choosing a tree, and when not to

Greedy choices and when they fail, dynamic programming tables, and classifying with k-nearest neighbours.

• 127. Greedy algorithms
• 128. When greedy fails, and how to find out
• 129. Dynamic programming: from memoisation to a table
• 130. The knapsack problem
• 131. Edit distance
• 132. k-nearest neighbours

Why passing tests is not the same as being right, induction and loop invariants, and the skill that decides everything — recognising your problem as one somebody already solved.

• 135. Why testing is not proof
• 136. Proof by induction, for programmers
• 137. Loop invariants
• 138. Modelling: recognising your problem as a known one

The two data structures that make later algorithms possible: a queue that always hands you the smallest thing, and a structure that answers "are these two connected?" almost instantly.

• 139. The priority queue
• 140. The binary heap
• 141. Heapsort
• 142. Union-find: keeping track of what is connected

Directed graphs and cycles, topological order, components, minimum spanning trees with Prim and Kruskal, flow and matching — and the lesson that ties them together: model the graph, then reuse an algorithm.

• 143. Naming the cycle, not just finding it
• 144. Topological sort
• 145. Connected components
• 146. Minimum spanning trees: Prim's algorithm
• 147. Kruskal's algorithm, and where union-find pays off
• 148. Matching people to things
• 149. Design graphs, not algorithms

Backtracking as one idea that generates every subset, permutation and Sudoku solution — then pruning, which is the only reason it finishes.

• 150. Backtracking
• 151. Generating subsets and permutations
• 152. Pruning the search
• 153. Solving Sudoku
• 154. When exact search is too slow

Longest increasing subsequence, longest common subsequence and partitioning — then how to recognise a DP problem on sight, and the shapes where DP simply does not apply.

• 155. The longest improving run that is not a run
• 156. What two pipelines still agree on
• 157. Splitting work that refuses to be reordered
• 158. How to tell it is a DP problem, before writing the table
• 159. Where the table stops working

Reductions, satisfiability and P versus NP explained without hand-waving — how to tell a problem is hard, what to ship when it is, and a closing checklist for designing any algorithm.

• 160. Solving a problem you have not solved
• 161. The problem everything else turns into
• 162. Why checking is easy and finding is not
• 163. Telling how hard something is, by measuring it
• 164. What to ship when the problem is hard
• 165. The checklist