Most programming needs less math than people fear: arithmetic, basic algebra, logic, and a feel for how fast quantities grow. For coding interviews you add modulo arithmetic, a little combinatorics and Big O. Calculus, linear algebra, trigonometry and statistics matter only in specific fields such as graphics, games, machine learning and data work. You can start coding before you are “good at math”, and learn the rest when a project demands it.<\/p>\n
You know addition and division, but code adds details that trip people up:<\/p>\n
\/\/<\/code> and %<\/code> in Python give the quotient and remainder. Negative numbers are where languages differ: in Python -7 % 3<\/code> is 2<\/code>, while in JavaScript, Java and C++ it is -1<\/code>.<\/li>\n- Floating point is approximate.<\/strong> Decimal fractions often cannot be stored exactly in binary.<\/li>\n
- Integers can overflow<\/strong> in fixed-size types such as C++
int<\/code> or Java int<\/code> (Python integers grow as needed).<\/li>\n<\/ul>\nimport math\n\nprint(-7 % 3, -7 \/\/ 3) # 2 -3\nprint(0.1 + 0.2) # 0.30000000000000004\nprint(0.1 + 0.2 == 0.3) # False\nprint(math.isclose(0.1 + 0.2, 0.3)) # True<\/code><\/pre>\nNever compare floats with ==<\/code>; compare with a tolerance. For money, use integers (cents) or a decimal type. The Modulo Operator lesson<\/a> is a quick drill for the remainder part.<\/p>\nAlgebra: variables, functions and formulas<\/h3>\n
Programming is mostly algebra in disguise: a variable stands for a value, a function maps inputs to outputs, and you rearrange an expression to isolate what you need. A concrete skill is turning a loop into a formula. The sum of 1 to n is n * (n + 1) \/ 2<\/code>, so a loop that adds up to 100 can be replaced by one expression:<\/p>\nn = 100\nprint(sum(range(1, n + 1))) # 5050\nprint(n * (n + 1) \/\/ 2) # 5050<\/code><\/pre>\nYou will use this when analysing loops and when a problem has a closed-form shortcut.<\/p>\n
Boolean logic<\/h3>\n
Conditions are logic. You need AND, OR, NOT, and De Morgan’s laws, which let you simplify a condition: not (a and b)<\/code> equals (not a) or (not b)<\/code>, and not (a or b)<\/code> equals (not a) and (not b)<\/code>. A common bug is negating a compound condition wrongly when you flip an if<\/code> to an early return. Check it with a truth table when unsure.<\/p>\nGrowth rates and logarithms (Big O)<\/h3>\n
This is the most useful math for interviews. You must tell apart constant, logarithmic, linear, n log n, quadratic and exponential growth, and know what each means at real sizes. A logarithm answers “how many times can I halve this?”:<\/p>\n
import math\nprint(math.log2(1_000_000)) # 19.931568569324174\nprint(math.ceil(math.log2(1_000_000))) # 20<\/code><\/pre>\nA binary search over a million sorted items needs at most about 20 comparisons. A nested loop over a million items does around a trillion operations. That gap is the reason algorithms matter. For a gentle start, try the Big O lessons<\/a>.<\/p>\nNumber systems and bits<\/h3>\n
Binary, hexadecimal, and the operators &<\/code>, |<\/code>, ^<\/code>, <<<\/code> and >><\/code> come up in low-level code, flags, hashing and a set of interview problems. Shifting left by k multiplies by 2k<\/sup>; the lowest bit tells you odd or even.<\/p>\nn = 13\nprint(bin(n)) # 0b1101\nprint(n & 1) # 1 (odd)\nprint(n >> 1) # 6 (integer divide by 2)\nprint(n << 2) # 52 (multiply by 4)<\/code><\/pre>\nWhat you need for algorithms and interviews<\/h2>\nModular arithmetic and gcd<\/h3>\n
Remainders are useful whenever things wrap around: clock times, circular buffers, hash table indexes, “every k-th item”. Many problems also ask for the answer modulo 109<\/sup>+7 to keep numbers small. The greatest common divisor, found by Euclid’s algorithm, is short enough to write from memory:<\/p>\ndef gcd(a, b):\n while b:\n a, b = b, a % b\n return a\n\nprint(gcd(48, 18)) # 6\nprint((22 + 5) % 24) # 3 -> 5 hours after 22:00 is 03:00<\/code><\/pre>\nCounting: permutations, combinations, subsets<\/h3>\n
You need to estimate how many possibilities a brute-force search has. n items can be ordered in n! ways, a set of n items has 2n<\/sup> subsets, and choosing k items from n has C(n, k) options:<\/p>\nimport math\nprint(math.factorial(10)) # 3628800\nprint(2 ** 20) # 1048576\nprint(math.comb(5, 2)) # 10\nprint(math.perm(5, 2)) # 20<\/code><\/pre>\nTen items give 3.6 million orderings; twenty give 2.4 quintillion, which no loop can finish. Seeing that is how you know when backtracking needs pruning or when dynamic programming is required.<\/p>\n
Discrete math: sets, graphs, induction, recurrences<\/h3>\n
This is the math of computer science. You deal with sets (hash sets and their operations), graphs (nodes and edges for maps, networks and dependencies), recurrences (the running time of a recursive function, such as T(n) = 2T(n\/2) + n), and proof by induction, which is the same idea as writing a correct recursive function: assume it works for smaller input and show it works for the next. Our post on mathematical induction in algorithm design<\/a> shows how.<\/p>\nBasic probability<\/h3>\n
Enough to compute simple odds and expected values, and to understand randomized algorithms and hash collisions. For example, two dice sum to 7 in 6 of 36 outcomes, so 1\/6:<\/p>\n
ways = sum(1 for a in range(1, 7) for b in range(1, 7) if a + b == 7)\nprint(ways, ways \/ 36) # 6 0.16666666666666666<\/code><\/pre>\nWhat you need only in some fields<\/h2>\n
\n\n\nField<\/th>\n Math<\/th>\n What it is used for<\/th>\n<\/tr>\n<\/thead>\n \n\nGames, graphics, simulations<\/td>\n Geometry, vectors, trigonometry, matrices<\/td>\n Distances, rotation, collision, camera transforms<\/td>\n<\/tr>\n \nMachine learning<\/td>\n Linear algebra, calculus (derivatives), probability<\/td>\n Vectors and matrices as data, gradient-based training<\/td>\n<\/tr>\n \nData analysis, A\/B testing<\/td>\n Statistics<\/td>\n Mean, spread, confidence, hypothesis tests<\/td>\n<\/tr>\n \nCryptography<\/td>\n Number theory, modular arithmetic<\/td>\n Primes, modular exponentiation<\/td>\n<\/tr>\n \nFinance, science<\/td>\n Numerical methods<\/td>\n Precision, rounding, error<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\nTwo short examples. Distance between points is the Pythagorean theorem, and rotating a point uses sine and cosine:<\/p>\n
import math\n\ndef dist(x1, y1, x2, y2):\n return math.hypot(x2 - x1, y2 - y1)\n\ndef rotate(x, y, degrees):\n t = math.radians(degrees)\n return (x * math.cos(t) - y * math.sin(t),\n x * math.sin(t) + y * math.cos(t))\n\nprint(dist(0, 0, 3, 4)) # 5.0\nprint(tuple(round(v, 6) for v in rotate(3, 4, 90))) # (-4.0, 3.0)<\/code><\/pre>\nThe unrounded rotation gives 3.0000000000000004<\/code> for the y value, another reminder about floating point, which is why the example rounds.<\/p>\nMean and standard deviation (the population version, which divides by n) in the standard library:<\/p>\n
import statistics\ndata = [2, 4, 4, 4, 5, 5, 7, 9]\nprint(statistics.mean(data), statistics.pstdev(data)) # 5 2.0<\/code><\/pre>\nGradient descent, which trains most machine-learning models, is calculus applied in a loop: take the derivative, step the other way. You can learn it when you start machine learning, not before.<\/p>\n
How to learn the math without a math course<\/h2>\n\n- Learn it when a problem needs it.<\/strong> When a task involves angles, read about trigonometry for that task. Motivation helps retention.<\/li>\n
- Implement it.<\/strong> Write gcd, binomial coefficients, a prime check, matrix multiplication yourself, and test them against the standard library.<\/li>\n
- Estimate before you run.<\/strong> Before executing a loop, guess how many operations it does. Check yourself with a counter.<\/li>\n
- Use free courses for the gaps.<\/strong> Many universities publish discrete math and linear algebra lectures online. Khan Academy covers school-level algebra through calculus.<\/li>\n<\/ul>\n
If your goal is interviews, the order that pays off is: modulo and basic number properties, Big O, counting, then graphs. Our post on the mathematics behind algorithm design<\/a> goes deeper into this side. You can practice the pieces in code with the exercises on AlgoCademy<\/a>.<\/p>\nCommon misconceptions<\/h2>\n\n- “I’m bad at math, so I can’t code.”<\/strong> Most code is logic and clear thinking about cases, not computation. Many working developers rarely go beyond arithmetic and Big O.<\/li>\n
- “I need advanced math for interviews.”<\/strong> Not for typical software roles. Competitive programming and some quantitative or research roles do ask for more.<\/li>\n
- “Libraries do it, so I can skip it.”<\/strong> Libraries do the computing, but you still decide which formula applies, what the edge cases are, and whether the result is plausible.<\/li>\n<\/ul>\n","protected":false},"excerpt":{"rendered":"
Which math you really need to code, from arithmetic, modulo and Big O to discrete math and probability, with Python examples and what to skip until a job asks.<\/p>\n","protected":false},"author":1,"featured_media":5388,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[23],"tags":[],"class_list":["post-5389","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-problem-solving"],"_links":{"self":[{"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/posts\/5389"}],"collection":[{"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/comments?post=5389"}],"version-history":[{"count":1,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/posts\/5389\/revisions"}],"predecessor-version":[{"id":8710,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/posts\/5389\/revisions\/8710"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/media\/5388"}],"wp:attachment":[{"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/media?parent=5389"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/categories?post=5389"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/tags?post=5389"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}