College Algebra Refresher

Reading maths feels like understanding it. It isn't. The only way to know whether you've got an idea back is to use it with nothing in front of you, and then say it out loud in your own words. Every lesson below is built around that, so follow the same five moves each time:

1. Read the idea at the top of the lesson. It's short on purpose.
2. Cover the worked example with your hand and try it yourself first. Then uncover it a line at a time and see where you and the page part ways.
3. Do the “Now you” problems on paper before you click Reveal. Getting one wrong and seeing why is worth more than getting it right by peeking.
4. Answer the “Explain it simply” prompt out loud, as if to a teenager. Where you reach for jargon, that's the part you haven't really got back yet. Go re-read that bit.
5. Then open the Go program. It does the same arithmetic you just did. If your numbers match its output, move on. If they don't, one of you is wrong — and it's usually a sign error.

Pencil first. Reveal second. Explain it out loud third. Code last.

An exponent is a count of multiplications: 2³ means 2 × 2 × 2. Every exponent rule is a shortcut you could rediscover by writing the multiplications out, which is worth doing once so the rules stop feeling arbitrary. A radical (square root, cube root) is just an exponent that's a fraction, so it obeys the same rules.

Worked by hand

1. Power rule on the bracket, and it applies to the 2 as well: (2x³)² = 2² · x⁶ = 4x⁶
2. Product rule: 4x⁶ · x⁻⁴ = 4x^{6 + (−4)} = 4x²

1. Find the largest perfect square inside: 72 = 36 × 2
2. Roots split over multiplication: √72 = √36 · √2 = 6√2  (≈ 8.485)

1. Read a^m/n as “nth root, then mth power” — root first keeps the numbers small: ³√8 = 2
2. Then square it: 2² = 4

Check it in Go

math.Pow(a, b) is a^b for any real exponent, so every rule in the table can be checked numerically. One thing to notice in the output: 8^(1/3) prints as 1.9999999999999998, not 2. That's not a maths error — it's floating-point arithmetic being honest about the fact that 1/3 can't be stored exactly. math.Cbrt exists precisely so you get an exact 2 when you want a cube root.

package main

import (
	"fmt"
	"math"
)

func main() {
	// product rule: a^m * a^n = a^(m+n)
	fmt.Println("2^3 * 2^4 =", math.Pow(2, 3)*math.Pow(2, 4), "= 2^7 =", math.Pow(2, 7))

	// quotient rule: a^m / a^n = a^(m-n)
	fmt.Println("2^7 / 2^5 =", math.Pow(2, 7)/math.Pow(2, 5), "= 2^2 =", math.Pow(2, 2))

	// power rule: (a^m)^n = a^(m*n)
	fmt.Println("(3^2)^3 =", math.Pow(math.Pow(3, 2), 3), "= 3^6 =", math.Pow(3, 6))

	// negative exponent: a^-n = 1 / a^n
	fmt.Println("5^-2 =", math.Pow(5, -2), "= 1/25 =", 1.0/25)

	// fractional exponent: a^(1/n) is the nth root
	fmt.Println("8^(1/3) =", math.Pow(8, 1.0/3), " cube root:", math.Cbrt(8))
	fmt.Println("8^(2/3) =", math.Pow(8, 2.0/3), " (cube root, then squared:", math.Pow(math.Cbrt(8), 2), ")")

	// simplify a radical: sqrt(72) = sqrt(36 * 2) = 6 * sqrt(2)
	fmt.Printf("sqrt(72) = %.4f   6*sqrt(2) = %.4f\n", math.Sqrt(72), 6*math.Sqrt(2))
}

Expanding is easy: (x + 2)(x + 3) = x² + 5x + 6, you just multiply everything by everything. Factoring is the same equation read right-to-left, and it's harder because you're guessing what was multiplied. It matters for one reason above all others: if two things multiply to zero, one of them is zero. Factor an expression that equals zero and you've solved the equation.

Four patterns cover almost everything at this level. Always try them in this order:

Worked by hand

1. No common factor, not a difference of squares. It's a trinomial, so: two numbers that multiply to 12 and add to −7.
2. Pairs for 12: (1, 12), (2, 6), (3, 4). Adding to −7 means both negative: (−3, −4). Check: (−3)(−4) = 12 ✓, −3 + (−4) = −7 ✓.
3. So x² − 7x + 12 = (x − 3)(x − 4). Expand it back to be sure.

1. Common factor first, always: 2(x² + 4x + 3) = 0
2. Trinomial: multiply to 3, add to 4 → (1, 3). So 2(x + 1)(x + 3) = 0
3. Zero product: 2 isn't zero, so either x + 1 = 0 or x + 3 = 0. x = −1 or x = −3.
4. Check one: 2(−1)² + 8(−1) + 6 = 2 − 8 + 6 = 0 ✓

Check it in Go

The program does exactly the by-hand search: for x² + bx + c it tries every integer p that divides c, sets q = c/p, and stops when p + q = b. When nothing works it says so — which is the honest answer for x² + x + 1, and your cue to reach for the quadratic formula in the next lesson.

package main

import "fmt"

// factor x^2 + bx + c by finding two integers whose product is c
// and whose sum is b — exactly the by-hand method.
func factor(b, c int) (int, int, bool) {
	for p := -100; p <= 100; p++ {
		if p == 0 {
			continue
		}
		if c%p == 0 {
			q := c / p
			if p+q == b {
				return p, q, true
			}
		}
	}
	return 0, 0, false
}

// signed prints "+ 4" or "- 4" so the output reads like the textbook
func signed(n int) string {
	if n < 0 {
		return fmt.Sprintf("- %d", -n)
	}
	return fmt.Sprintf("+ %d", n)
}

// terms writes the "+ bx + c" part of the polynomial
func terms(b, c int) string {
	return fmt.Sprintf("%sx %s", signed(b), signed(c))
}

func main() {
	problems := [][2]int{{5, 6}, {-7, 12}, {2, -15}, {1, 1}}
	for _, pr := range problems {
		b, c := pr[0], pr[1]
		p, q, ok := factor(b, c)
		if ok {
			fmt.Printf("x^2 %s  =  (x %s)(x %s)\n", terms(b, c), signed(p), signed(q))
		} else {
			fmt.Printf("x^2 %s  does not factor over the integers\n", terms(b, c))
		}
	}
}

A quadratic is anything with an x² in it and nothing higher, and its graph is always a parabola — a U, or an upside-down U if the x² coefficient is negative. The same parabola can be written three ways, and each form makes one fact obvious:

Lesson 02 got you from standard to factored. Completing the square gets you from standard to vertex form, and it's the technique the quadratic formula is secretly made of.

Worked by hand — completing the square

1. Take half the x coefficient and square it: half of −6 is −3, squared is 9. That's the number that would make x² − 6x a perfect square.
2. Add it and take it away again, so nothing changes: y = (x² − 6x + 9) − 9 + 5
3. The bracket is now a perfect square: y = (x − 3)² − 4
4. Read the vertex straight off: (3, −4). Since (x − 3)² can't be negative, y is smallest when it's zero, at x = 3, and that smallest value is −4.

The shortcut, once you've done it by hand a few times: the vertex is always at x = −b / 2a. Here that's 6/2 = 3. Plug it in for y.

The discriminant — how many roots before you find them

Inside the quadratic formula x = (−b ± √(b² − 4ac)) / 2a, the part under the root, b² − 4ac, decides everything:

• Positive → two real roots. The parabola crosses the x-axis twice.
• Zero → one repeated root. The vertex sits exactly on the x-axis.
• Negative → no real roots. You'd need the square root of a negative; the parabola floats above (or below) the axis without touching it.

For x² − 6x + 5: b² − 4ac = 36 − 20 = 16, positive, so two roots: x = (6 ± 4)/2 = 5 and 1. Which matches the factoring: (x − 5)(x − 1). Three forms, one parabola.

Check it in Go

The program computes the vertex with −b/2a, then classifies the discriminant with a switch — the three-way branch is the same three cases as the picture above. Change a, b, c at the top to the coefficients from the “Now you” problems and run it again.

package main

import (
	"fmt"
	"math"
)

func main() {
	// y = ax^2 + bx + c
	a, b, c := 1.0, -6.0, 5.0

	// vertex: x = -b / 2a, then plug in for y
	vx := -b / (2 * a)
	vy := a*vx*vx + b*vx + c
	fmt.Printf("vertex at (%g, %g)\n", vx, vy)
	fmt.Printf("vertex form: y = %g(x - %g)^2 - %g\n", a, vx, -vy)

	// discriminant decides how many real roots there are
	d := b*b - 4*a*c
	fmt.Printf("discriminant b^2 - 4ac = %g\n", d)
	switch {
	case d > 0:
		r1 := (-b + math.Sqrt(d)) / (2 * a)
		r2 := (-b - math.Sqrt(d)) / (2 * a)
		fmt.Printf("two real roots: x = %g and x = %g\n", r1, r2)
	case d == 0:
		fmt.Printf("one repeated root: x = %g\n", -b/(2*a))
	default:
		fmt.Println("no real roots (the parabola never touches the x-axis)")
	}
}

A function is a machine: put a number in, get exactly one number out. f(x) = 2x + 3 is the machine's name and its recipe, and f(4) means “put 4 in”: f(4) = 2(4) + 3 = 11. The notation trips people up because f(x) looks like multiplication. It isn't. Read the brackets as “of”: f of 4.

Four things college algebra asks about any function:

• Evaluate it — substitute and compute. f(−1), f(a + 1), f(x²) all work the same way: replace every x with the thing in the brackets.
• Its domain — which inputs are allowed. Two things break: dividing by zero, and taking the square root of a negative. The domain is every real number that avoids both.
• Compose it with another — feed one machine's output into the next. f(g(x)) means do g first, then f. Written (f ∘ g)(x).
• Invert it — build the machine that undoes it, f⁻¹. If f turns 4 into 11, f⁻¹ turns 11 back into 4.

Worked by hand

1. f(g(4)): inside first. g(4) = 16. Then f(16) = 2(16) + 3 = 35.
2. g(f(4)): inside first. f(4) = 11. Then g(11) = 121.
3. Different answers. Order matters in composition — “square then double-plus-three” is not “double-plus-three then square.”

1. Write it as y = 2x + 3.
2. Swap x and y — that's the whole trick, because an inverse swaps inputs and outputs: x = 2y + 3.
3. Solve for y: x − 3 = 2y, so y = (x − 3)/2. Hence f⁻¹(x) = (x − 3)/2.
4. Check: f(4) = 11, and f⁻¹(11) = 8/2 = 4 ✓. An inverse always brings you home.

1. The root needs x − 2 ≥ 0, so x ≥ 2.
2. The bottom can't be zero, so x ≠ 5.
3. Domain: x ≥ 2 and x ≠ 5. In interval notation, [2, 5) ∪ (5, ∞).

Check it in Go

Go functions are values, so f and g are ordinary variables and f(g(4)) is written exactly as in maths. The domain question becomes an error return: h refuses inputs it can't handle and says why, which is the domain made executable.

package main

import (
	"fmt"
	"math"
)

func main() {
	f := func(x float64) float64 { return 2*x + 3 }
	g := func(x float64) float64 { return x * x }

	fmt.Println("f(4) =", f(4))
	fmt.Println("g(4) =", g(4))

	// composition: (f o g)(x) = f(g(x)) — do g first, then f
	fmt.Println("f(g(4)) =", f(g(4))) // 2*16 + 3
	fmt.Println("g(f(4)) =", g(f(4))) // (2*4+3)^2 — order matters

	// inverse of f: swap x and y in y = 2x + 3, solve for y -> (x - 3) / 2
	fInv := func(x float64) float64 { return (x - 3) / 2 }
	fmt.Println("fInv(f(4)) =", fInv(f(4)), "  (an inverse undoes the function)")

	// domain: h(x) = sqrt(x - 2) / (x - 5) only makes sense for some x
	h := func(x float64) (float64, error) {
		if x-2 < 0 {
			return 0, fmt.Errorf("x=%g: square root of a negative", x)
		}
		if x == 5 {
			return 0, fmt.Errorf("x=%g: division by zero", x)
		}
		return math.Sqrt(x-2) / (x - 5), nil
	}
	for _, x := range []float64{1, 3, 5, 11} {
		if v, err := h(x); err != nil {
			fmt.Println("h(x) undefined:", err)
		} else {
			fmt.Printf("h(%g) = %g\n", x, v)
		}
	}
}

An exponential equation has the unknown in the exponent: 2^x = 50. You can't get x down with the tools so far. A logarithm is the tool: log_b(y) is the exponent you'd need to put on b to get y. log₂(8) = 3 because 2³ = 8. That's the whole definition; everything else follows from it.

Two bases matter in practice. ln is log base e (e ≈ 2.718, the base that makes calculus tidy), and log without a subscript usually means base 10. Any other base you reach through the change-of-base rule. The three log rules are the three exponent rules from Lesson 01, seen from the other side:

Worked by hand

1. Take the log of both sides. Any base works; use ln: ln(2^x) = ln 50
2. The power rule pulls the x down in front: x · ln 2 = ln 50
3. Divide: x = ln 50 / ln 2 = 3.912 / 0.693 ≈ 5.644
4. Sanity check: 2⁵ = 32 and 2⁶ = 64, so 50 needs an x between 5 and 6 ✓

1. The formula: A = P(1 + r/n)^nt, with P = 1000, r = 0.06, n = 12, t = 10.
2. Monthly rate 0.06/12 = 0.005; number of months 120: A = 1000 × 1.005¹²⁰
3. 1.005¹²⁰ ≈ 1.8194, so A ≈ $1,819.40

1. Set A = 2P and cancel P: 2 = 1.005^12t
2. Logs of both sides, power rule: ln 2 = 12t · ln 1.005
3. t = ln 2 / (12 × ln 1.005) = 0.6931 / (12 × 0.004988) ≈ 11.58 years
4. The banker's shortcut “rule of 72” says 72/6 = 12 years. Close — now you know where it comes from.

Check it in Go

math.Log is ln; math.Log10 and math.Log2 exist for those bases, and any other base is math.Log(y) / math.Log(b). The program solves 2^x = 50, checks all three log rules numerically, and runs the interest and doubling-time calculations from the worked example.

package main

import (
	"fmt"
	"math"
)

func main() {
	// solve 2^x = 50: take the log of both sides, x = ln(50) / ln(2)
	x := math.Log(50) / math.Log(2)
	fmt.Printf("2^x = 50  ->  x = ln50/ln2 = %.4f   check: 2^x = %.4f\n", x, math.Pow(2, x))

	// the three log rules, checked numerically
	a, b := 8.0, 32.0
	fmt.Printf("log(ab) = log a + log b :  %.4f = %.4f\n", math.Log(a*b), math.Log(a)+math.Log(b))
	fmt.Printf("log(a/b) = log a - log b:  %.4f = %.4f\n", math.Log(a/b), math.Log(a)-math.Log(b))
	fmt.Printf("log(a^3) = 3 log a      :  %.4f = %.4f\n", math.Log(math.Pow(a, 3)), 3*math.Log(a))

	// compound interest: A = P(1 + r/n)^(nt)
	P, r, n, t := 1000.0, 0.06, 12.0, 10.0
	A := P * math.Pow(1+r/n, n*t)
	fmt.Printf("$%.0f at 6%% monthly for %g years = $%.2f\n", P, t, A)

	// how long to double? solve 2 = (1 + r/n)^(nt) for t
	years := math.Log(2) / (n * math.Log(1+r/n))
	fmt.Printf("doubling time = %.2f years   (rule of 72 guess: %.2f)\n", years, 72/6.0)
}

An inequality is solved like an equation — do the same thing to both sides — with one exception that causes nearly every error: multiplying or dividing both sides by a negative number flips the sign. 2 < 3 is true; multiply both sides by −1 and −2 < −3 is false. You have to write −2 > −3.

Absolute value, |x|, is distance from zero, and |x − 3| is distance from 3. Reading it as a distance turns every absolute-value inequality into a sentence:

• |x − a| < d — “x is within d of a” → a − d < x < a + d. One interval.
• |x − a| > d — “x is more than d away from a” → x < a − d or x > a + d. Two pieces.

Worked by hand

1. Subtract 6: −3x > 9
2. Divide by −3 — and flip: x < −3
3. Test a value to be sure. x = −4: −3(−4) + 6 = 18 > 15 ✓. x = 0: 6 > 15? No ✓. The flip was right.

1. Read it: x is within 5 of 3.
2. So 3 − 5 < x < 3 + 5, i.e. −2 < x < 8. Interval notation: (−2, 8).

1. “Greater than” splits into two cases: 2x + 1 ≥ 7  or  2x + 1 ≤ −7
2. First: 2x ≥ 6, x ≥ 3. Second: 2x ≤ −8, x ≤ −4.
3. x ≤ −4 or x ≥ 3. Interval notation: (−∞, −4] ∪ [3, ∞). Square bracket means the endpoint is included (≥), round means it isn't (>).

Check it in Go

You can't “solve” an inequality in code the way you solve an equation, but you can do something better for a refresher: test candidate values against the original inequality and against your solution, side by side. If the two columns ever disagree, your solution is wrong. math.Abs is absolute value.

package main

import (
	"fmt"
	"math"
)

func main() {
	// -3x + 6 > 15  ->  -3x > 9  ->  x < -3   (dividing by -3 FLIPS the sign)
	// test a few values against the ORIGINAL inequality to confirm
	fmt.Println("-3x + 6 > 15 ?")
	for _, x := range []float64{-5, -4, -3, -2, 0} {
		fmt.Printf("  x = %2g: %-5v  (x < -3 says %v)\n", x, -3*x+6 > 15, x < -3)
	}

	// |x - 3| < 5  means x is within 5 of 3  ->  -2 < x < 8
	fmt.Println("|x - 3| < 5 ?")
	for _, x := range []float64{-3, -2, 0, 3, 7, 8, 9} {
		fmt.Printf("  x = %2g: %-5v  (-2 < x < 8 says %v)\n", x, math.Abs(x-3) < 5, -2 < x && x < 8)
	}

	// |2x + 1| >= 7  splits into two cases: 2x+1 >= 7  or  2x+1 <= -7
	//                                        x >= 3     or  x <= -4
	fmt.Println("|2x + 1| >= 7 ?")
	for _, x := range []float64{-5, -4, -3, 0, 2, 3, 4} {
		fmt.Printf("  x = %2g: %-5v  (x <= -4 or x >= 3 says %v)\n", x, math.Abs(2*x+1) >= 7, x <= -4 || x >= 3)
	}
}

A sequence is a list of numbers made by a rule; a series is what you get when you add them up. College algebra covers the two rules that come up everywhere — in loans, in savings, in anything that grows by the same amount or the same factor each step:

The arithmetic sum formula has a story worth knowing: it's “number of terms times the average term,” and the average of an evenly spaced list is just the average of the first and last. That's the whole formula. The geometric one is less obvious, so the Go program checks it with a plain loop.

Worked by hand

1. a₁ = 5, d = 3. The 20th term has had 19 steps of 3 added: a₂₀ = 5 + 19 × 3 = 62
2. Sum: 20 terms, average of first and last is (5 + 62)/2 = 33.5, so S₂₀ = 20 × 33.5 = 670

1. a₁ = 3, r = 2. Nine doublings: a₁₀ = 3 × 2⁹ = 3 × 512 = 1536
2. S₁₀ = 3(1 − 2¹⁰) / (1 − 2) = 3(1 − 1024) / (−1) = 3 × 1023 = 3069

1. Geometric with a₁ = 1, r = ½. Since |r| < 1, the infinite sum is finite.
2. S = 1 / (1 − ½) = 2. Each term closes half the remaining gap to 2 and never crosses it.

Check it in Go

The program applies each formula and then does the same sum with a for loop, so the formula and the brute force sit next to each other in the output. The last line shows the infinite series creeping up on 2: twenty terms get you to 1.999998.

package main

import "fmt"

func main() {
	// arithmetic: 5, 8, 11, ...  a1 = 5, d = 3
	a1, d := 5.0, 3.0
	n := 20.0
	an := a1 + (n-1)*d       // nth term
	sum := n / 2 * (a1 + an) // sum of the first n terms
	fmt.Printf("arithmetic: 20th term = %g, sum of 20 terms = %g\n", an, sum)

	// check the sum formula with a plain loop
	loop := 0.0
	for i := 0; i < 20; i++ {
		loop += a1 + float64(i)*d
	}
	fmt.Printf("  loop says %g\n", loop)

	// geometric: 3, 6, 12, ...  a1 = 3, r = 2
	g1, r := 3.0, 2.0
	gn := g1 * pow(r, 10-1)                 // 10th term
	gsum := g1 * (1 - pow(r, 10)) / (1 - r) // sum of the first 10 terms
	fmt.Printf("geometric: 10th term = %g, sum of 10 terms = %g\n", gn, gsum)

	// infinite geometric series converges when |r| < 1: S = a1 / (1 - r)
	fmt.Printf("1 + 1/2 + 1/4 + 1/8 + ... = %g\n", 1/(1-0.5))
	partial := 0.0
	for i := 0; i < 20; i++ {
		partial += pow(0.5, float64(i))
	}
	fmt.Printf("  first 20 terms add to %.6f\n", partial)
}

func pow(base, exp float64) float64 {
	result := 1.0
	for i := 0; i < int(exp); i++ {
		result *= base
	}
	return result
}

Seven lessons is a refresher, not a course. If a lesson felt shaky, the fix is the same one this page is built on: close it, take a blank sheet, and re-derive the worked example from memory. What you can rebuild, you own.