Finals on ENKR's Blog | Jing Hui PANG

TCX1002 | Python Finals Helpsheet

Mon, 20 Apr 2026 00:00:00 +0800

Constraints & Scope

1 × A4 double-sided (confirmed Prof Jiang, Apr 18)
Examplify fill-blank format — no compiler, no run-code
Relaxed vs PE: recursion ✅ allowed, NumPy ✅ allowed
TBC (still pending Apr 18 tutorial answers): OOP, regex
Strategy anchor: decomposition into subproblems → recursive thinking (Prof Jiang Apr 18 lunch)

Scope Priorities (TODO human)

Quick Reference

OOP — Class + Inheritance + Polymorphism

 1class Parent:
 2 def __init__(self, name):
 3 self.name = name
 4 def method(self): return "base"
 5 def __str__(self): return f"Parent({self.name})"
 6 def __repr__(self): return f"Parent('{self.name}')"
 7
 8class Child(Parent):
 9 def __init__(self, name, extra):
10 super().__init__(name)
11 self.extra = extra
12 def method(self): return "override" # polymorphism
13 def __str__(self): return f"Child({self.name})"

OOP — @property (Read-Only / Write-Only)

 1class X:
 2 def __init__(self):
 3 self._val = 0
 4
 5 @property # READ-ONLY
 6 def val(self): return self._val
 7
 8 @property # WRITE-ONLY (getter raises)
 9 def deposit(self): raise AttributeError
10 @deposit.setter
11 def deposit(self, amt): self._val += amt

filter / reduce

filter: keep items where fn returns True. reduce: fold list into one value.

1from functools import reduce
2
3valid = list(filter(lambda x: x[1] != "NA", data))
4
5total = reduce(lambda acc, x: acc + x, [1,2,3], 0) # 6

Build dict with reduce (mutable acc — faster):

1def collect(acc, item):
2 acc.setdefault(item[0], []).append(item[1])
3 return acc # ← MUST return acc!
4result = reduce(collect, data, {})

Immutable style (slower, but works in lambda):

1reduce(lambda acc, x: {**acc, x[0]: acc.get(x[0], 0) + x[1]}, data, {})

Sorting

1sorted(data, key=lambda x: (-x[1], x[0])) # desc by [1], asc by [0]
2# ⚠️ negative trick only works on numbers, not strings
3# sorted() → NEW list .sort() → in-place, returns None

@lru_cache (Memoization)

Turn exponential recursion into O(n). Args must be hashable (no lists — use tuples).

1from functools import lru_cache
2@lru_cache(maxsize=None)
3def fn(n): ...

defaultdict / Counter

1from collections import defaultdict, Counter
2
3groups = defaultdict(list) # auto [] on missing key
4counts = defaultdict(int) # auto 0 on missing key
5
6c = Counter([1,2,2,3,3,3]) # {3:3, 2:2, 1:1}
7c.most_common(2) # [(3,3), (2,2)]

String Methods

 1" hello ".strip() # 'hello' both ends
 2" hello ".lstrip() # 'hello ' left only
 3" hello ".rstrip() # ' hello' right only
 4"hello world".split() # ['hello', 'world'] by whitespace
 5"a,b,c".split(",") # ['a', 'b', 'c'] by delimiter
 6"a b c".split(" ") # ['a', 'b', '', 'c'] exact space (keeps empty!)
 7# ⚠️ "".split() → [] but "".split(" ") → [""]
 8", ".join(["a", "b", "c"]) # 'a, b, c' list → str
 9"hello".replace("ll", "r") # 'hero'
10"hello".find("ll") # 2 (-1 if not found)
11"abcabc".count("a") # 2
12"hello".startswith("he") # True
13"file.py".endswith(".py") # True
14"hello".upper() # 'HELLO'
15"HELLO".lower() # 'hello'
16"hello world".title() # 'Hello World'
17"123".isdigit() # True
18"abc".isalpha() # True
19"abc123".isalnum() # True

1# ord / chr — character ↔ number
2ord('A') # 65 ord('a') # 97 ord('0') # 48
3chr(65) # 'A' chr(97) # 'a'
4ord('c') - ord('a') # 2 (letter → index)
5chr(ord('a') + 3) # 'd' (index → letter)
6chr((ord(c) - ord('a') + shift) % 26 + ord('a')) # Caesar cipher

List / Set / Dict Methods

 1# LIST
 2lst.append(x) # add to end (in-place)
 3lst.insert(i, x) # insert at index (in-place)
 4lst.pop() # remove + return last
 5lst.pop(0) # remove + return first
 6lst.remove(x) # remove first x (ValueError if missing)
 7lst.index(x) # index of first x (ValueError if missing)
 8lst.reverse() # in-place, returns None!
 9lst.extend([1,2]) # add each item vs lst.append([1,2]) → nested
10
11# SET
12s.add(x) # add one
13s.discard(x) # remove (no error if missing)
14s.remove(x) # remove (KeyError if missing)
15a & b # intersection
16a | b # union
17a - b # difference
18a ^ b # symmetric difference
19
20# COMPREHENSIONS
21[x**2 for x in lst if x > 0] # list
22{k: v for k, v in pairs} # dict
23{x for x in lst} # set
24[x for row in matrix for x in row] # flatten 2D

Dict Tricks

1d.get(key, default) # no KeyError
2d.setdefault(key, []).append(item) # group without defaultdict
3counts[x] = counts.get(x, 0) + 1 # count without Counter

try / except

1try:
2 risky_thing()
3except ValueError: # catch specific
4 print("bad value")
5except (TypeError, KeyError): # catch multiple
6 print("wrong type or key")
7
8raise ValueError("insufficient balance") # throw your own
9raise AttributeError("write-only")

for-else

else runs only if loop finishes WITHOUT break. Useful for “search and fail” patterns.

1for item in lst:
2 if item == target:
3 print("found")
4 break
5else:
6 print("not found") # only runs if no break

enumerate

1for i, val in enumerate(lst): # i=0,1,2...
2for i, val in enumerate(lst, start=1): # i=1,2,3...

Formatting & Type Checks

1import math # for ceil, gcd, sqrt, inf
2f"${balance:.2f}" # 2 decimal places
3isinstance(x, (int, float)) # True for subclasses too
4type(x) == int # exact match only

Algorithms

Greedy vs Backtracking

“Can my local choice block someone downstream?” No → Greedy (O(N)). Yes → Backtracking (O(P^N)).

Backtracking — Wishful Thinking

Template: choose → recurse → undo. Assume the rest works (wishful thinking). If it didn’t, undo and try next.

 1def backtrack(remaining, state):
 2 if not remaining:
 3 return state
 4
 5 curr = remaining[0]
 6 for option in get_options(curr):
 7 if not is_valid(option, state): continue
 8 apply(option, state) # CHOOSE
 9 result = backtrack(remaining[1:], state)
10 if result is not None: # wish granted
11 return result
12 undo(option, state) # UNDO
13 return None # all failed

Concrete example — student scheduling:

 1def assign(students, classes):
 2 def bt(rem, cls, res):
 3 if not rem: return res
 4 curr = rem[0]
 5 for pref in curr["preferences"]:
 6 if cls[pref] == 0: continue
 7 res.setdefault(pref, []).append(curr["name"])
 8 cls[pref] -= 1
 9 ans = bt(rem[1:], cls, res)
10 if ans is not None: return ans
11 cls[pref] += 1; res[pref].pop()
12 return None
13 return bt(students, classes.copy(), {})

LCS (Longest Common Subsequence)

Find longest sequence present in both strings in same order. Exponential without memo.

1def lcs(t1, t2, acc=""):
2 if not t1 or not t2: return acc
3 if t1[0] == t2[0]:
4 return lcs(t1[1:], t2[1:], acc + t1[0])
5 p1 = lcs(t1, t2[1:], acc)
6 p2 = lcs(t1[1:], t2, acc)
7 return p1 if len(p1) > len(p2) else p2

Edit Distance (Levenshtein)

Min operations (insert/delete/replace) to turn s1 into s2. Use @lru_cache.

 1from functools import lru_cache
 2
 3def edit_distance(s1, s2):
 4 @lru_cache(maxsize=None)
 5 def dp(i, j):
 6 if i == 0: return j
 7 if j == 0: return i
 8 if s1[i-1] == s2[j-1]: return dp(i-1, j-1)
 9 return 1 + min(dp(i-1, j), dp(i, j-1), dp(i-1, j-1))
10 return dp(len(s1), len(s2))

Wildcard Match

? = one char, * = any sequence (including empty).

1def match(pat, text):
2 if not pat and not text: return True
3 if not pat: return False
4 if pat[0] == '*':
5 return match(pat[1:], text) or (bool(text) and match(pat, text[1:]))
6 if not text: return False
7 if pat[0] == '?' or pat[0] == text[0]:
8 return match(pat[1:], text[1:])
9 return False

RLE (Run-Length Encoding)

Group consecutive identical elements into (key, count) pairs. Only the bucket function changes per problem.

 1# Iterative
 2def rle(seq, bucket=lambda x: x):
 3 out = []
 4 for x in seq:
 5 key = bucket(x)
 6 if out and out[-1][0] == key:
 7 out[-1] = (key, out[-1][1] + 1) # tuple immutable → replace
 8 else:
 9 out.append((key, 1))
10 return out
11
12# Recursive
13def rle_rec(seq):
14 if not seq: return ()
15 rest = rle_rec(seq[1:])
16 if rest and rest[0][0] == seq[0]:
17 return ((seq[0], rest[0][1] + 1),) + rest[1:]
18 return ((seq[0], 1),) + rest

Two-Pointer Merge

Merge two sorted lists in O(M+N) without re-sorting.

1def merge(l1, l2, comp=lambda x, y: x - y):
2 p1 = p2 = 0; out = []
3 while p1 < len(l1) and p2 < len(l2):
4 if comp(l1[p1], l2[p2]) <= 0:
5 out.append(l1[p1]); p1 += 1
6 else:
7 out.append(l2[p2]); p2 += 1
8 out.extend(l1[p1:]); out.extend(l2[p2:])
9 return out

Dense Ranking (1-2-2-3)

Same score = same rank. Next different score = rank + 1 (no skip).

1def dense_rank(rows, key=lambda x: (-x[1], -x[2], -x[3], x[0])):
2 s = sorted(rows, key=key)
3 rank = 1; out = [(rank, *s[0])]
4 for i in range(1, len(s)):
5 if s[i][1:] != s[i-1][1:]: rank += 1
6 out.append((rank, *s[i]))
7 return out

Sliding Window (Moving Average)

O(n) with running sum: add new element, subtract oldest.

1def sma(prices, w):
2 out = [None] * (w - 1)
3 s = sum(prices[:w])
4 out.append(s / w)
5 for i in range(w, len(prices)):
6 s += prices[i] - prices[i - w]
7 out.append(s / w)
8 return out

2D Grid

Setup: find smallest N where N*N >= len(s), create grid.

1N = 1
2while N * N < len(s): N += 1
3grid = [[" "] * N for _ in range(N)]

Zigzag (odd rows reversed):

1row, col = i // N, i % N
2if row % 2 == 1: col = N - col - 1

Column fill right-to-left:

1for col_offset in range(N):
2 for row in range(N):
3 grid[row][N - col_offset - 1] = s[p]; p += 1
4 if p >= len(s): break

Formulas

Weighted average: sum(value x weight) / sum(weights). E.g. GPA.

1sum(v * w for v, w in data) / sum(w for _, w in data)

Trimmed mean: drop outliers then average. E.g. drop highest + lowest judge score.

1(sum(scores) - max(scores) - min(scores)) / (len(scores) - 2)

Euclidean distance: straight-line between two points.

1math.sqrt(sum((a - b) ** 2 for a, b in zip(p1, p2)))

Manhattan distance: grid-walking distance (no diagonals).

1sum(abs(a - b) for a, b in zip(p1, p2))

Prime check: trial division up to sqrt(n).

1def is_prime(n):
2 if n < 2: return False
3 for i in range(2, int(n**0.5) + 1):
4 if n % i == 0: return False
5 return True

GCD: built-in.

1math.gcd(a, b)

Newton’s method (sqrt): stop when guess stops changing.

1x_next = (x_prev + n / x_prev) / 2
2# converge when: abs(x_next - x_prev) < tol

“Top X% rounded up”: ceil, never round.

1top_k = math.ceil(total * percentage / 100)

Circular indexing: wraparound.

1day = i % 7

Diagonal detection: same diagonal = same sum or same difference.

1same_pos_diag = (r1 + c1) == (r2 + c2)
2same_neg_diag = (r1 - c1) == (r2 - c2)

90° rotation: given vector (dx, dy), the perpendicular is (-dy, dx) or (dy, -dx). Use to find square corners from one edge.

1dx, dy = x2 - x1, y2 - y1
2c1, d1 = (x2 - dy, y2 + dx), (x1 - dy, y1 + dx) # counterclockwise
3c2, d2 = (x2 + dy, y2 - dx), (x1 + dy, y1 - dx) # clockwise

Distance between two points:

1dist = ((x1 - x2)**2 + (y1 - y2)**2) ** 0.5
2# compare with tolerance: abs(dist - target) < 1e-9

Common Pitfalls

Banker’s rounding: round(2.5) = 2, not 3. Use math.ceil() for “round up”.

split gotcha: "".split(" ") = [""]. "".split() = [].

Shared reference: [[0]] * 3 — all rows are same list. Fix: [[0] for _ in range(3)].

Mutation during iteration: for n in nums: nums.remove(n) skips elements. Fix: list comp.

One-shot iterators: list(map(...)) second time = []. Wrap in list() immediately.

sorted vs sort: sorted(lst) = new list. lst.sort() = None (in-place).

Mutable default: def f(x, target=[]) — shared across calls. Fix: target=None.

+= on alias: y = x; y += [6] mutates x too. y = y + [6] is safe.

Shallow copy: a[:] — outer new, inner shared. Fix: [row[:] for row in a].

Single-element tuple: (1,) is tuple. (1) is just int.

str(n) for digits: left-to-right, handles 0. n%10 loop reverses + misses 0. Also: ch is string — int(ch) before math.

Tuple immutable: out[-1][1] += 1 crashes. Fix: out[-1] = (key, count+1).

Pre-Submit

1□ Edge: [], "", 0, None, single, all-same, negative, boundaries
2□ Return type matches spec (list? tuple? int? float?)
3□ return X, not print(X)
4□ Off-by-one: range(n) vs range(n+1), < vs <=
5□ Remove debug prints
6□ Didn't shadow: list, dict, sum, max, min, type
7□ Imports at top
8□ Fn signature matches spec

Regex

1import re

findall: all matches as list of strings. With groups (), returns only group content.

1re.findall(r'\d+', "age 25, score 99") # ['25', '99']
2re.findall(r'(\d+)-(\d+)', "12-34 56-78") # [('12','34'), ('56','78')]

search: first match anywhere. Returns match object or None — always check before .group().

1m = re.search(r'(\d+)-(\d+)', "call 123-456")
2if m:
3 m.group(0) # '123-456' (full match)
4 m.group(1) # '123' (first group)

sub / split:

1re.sub(r'\d+', 'X', "abc123def456") # 'abcXdefX'
2re.split(r'[,;\s]+', "a, b;c d") # ['a','b','c','d']

Greedy vs non-greedy:

1re.findall(r'<.+>', '<a><b>') # ['<a><b>'] greedy
2re.findall(r'<.+?>', '<a><b>') # ['<a>','<b>'] non-greedy

Pattern cheat:

Pattern	Meaning
`\d` / `\D`	digit / non-digit
`\w` / `\W`	word char `[a-zA-Z0-9_]` / non-word
`\s` / `\S`	whitespace / non-whitespace
`\b`	word boundary
`.`	any char except `\n`
`+` / `*` / `?`	1+ / 0+ / 0 or 1
`{n}` / `{n,m}`	exactly n / n to m
`^` / `$`	start / end of string
`(...)`	capture group
`(?=...)`	lookahead (match without consuming)

Mock Test Solutions

MT1 — Char Type Map (Recursive)

1def f(s):
2 if not s: return ""
3 c = s[0]
4 if c.lower() in "aeiou": pre = "V"
5 elif c.isalpha(): pre = "C"
6 else: pre = "-"
7 return pre + f(s[1:])

MT2 — DNA Grouping (Recursive RLE)

1def group_bases(dna):
2 if not dna: return ()
3 rest = group_bases(dna[1:])
4 if rest and rest[0][0] == dna[0]:
5 return ((dna[0], rest[0][1] + 1),) + rest[1:]
6 return ((dna[0], 1),) + rest

MT3 — Zigzag Grid

 1def zigzag_fill(s):
 2 if not s: return [[]]
 3 N = 1
 4 while N * N < len(s): N += 1
 5 grid = [[" "] * N for _ in range(N)]
 6 for i in range(len(s)):
 7 row, col = i // N, i % N
 8 if row % 2 == 1: col = N - col - 1
 9 grid[row][col] = s[i]
10 return grid

MT4 — Avg Rating (Functional)

1from functools import reduce
2def avg_rating(votes):
3 valid = list(filter(lambda x: x[1] != "NA", votes))
4 def collect(acc, item):
5 acc.setdefault(item[0], {"t": 0, "c": 0})
6 acc[item[0]]["t"] += item[1]; acc[item[0]]["c"] += 1
7 return acc
8 temp = reduce(collect, valid, {})
9 return {k: v["t"]/v["c"] for k, v in temp.items()}

MT5 — Library Fines (OOP + Polymorphism)

 1class MemberCard:
 2 def __init__(self, mid):
 3 self.member_id = mid; self.balance = 0.0
 4 def top_up(self, amt): self.balance += amt; return self.balance
 5 def fine_for(self, loan): return loan.days_overdue * 0.5
 6 def pay_fine(self, loan):
 7 fine = self.fine_for(loan)
 8 if self.balance >= fine: self.balance -= fine
 9 else: raise ValueError("insufficient")
10 return fine
11 def __str__(self): return f"MemberCard({self.member_id}): balance=${self.balance:.2f}"
12
13class StudentMemberCard(MemberCard):
14 def fine_for(self, loan): return super().fine_for(loan) * 0.5
15 def __str__(self): return f"StudentMemberCard({self.member_id}): balance=${self.balance:.2f}"

MT6 — BankAccount (@property)

 1class BankAccount:
 2 def __init__(self, owner):
 3 self._owner = owner; self._balance = 0.0; self._pin = "0000"
 4 @property
 5 def owner(self): return self._owner
 6 @property
 7 def balance(self): return self._balance
 8 @property
 9 def deposit(self): raise AttributeError
10 @deposit.setter
11 def deposit(self, q): self._balance += q
12 @property
13 def pin(self): raise AttributeError
14 @pin.setter
15 def pin(self, q): self._pin = q

MT7 — Column Grid R→L

 1def col_fill_rtl(s):
 2 if not s: return [[]]
 3 N = 1
 4 while N * N < len(s): N += 1
 5 grid = [["?"] * N for _ in range(N)]
 6 p = 0
 7 for i in range(N):
 8 for j in range(N):
 9 grid[j][N - i - 1] = s[p]; p += 1
10 if p >= len(s): return grid
11 return grid

MT8 — High/Low Rating (Functional)

Approach 1: named function (clean, O(n), recommended)

1from functools import reduce
2def high_low(records):
3 valid = list(filter(lambda x: type(x[1]) == int, records))
4 def collect(acc, item):
5 k = item[0]
6 prev = acc.get(k, (float("inf"), float("-inf")))
7 acc[k] = (min(prev[0], item[1]), max(prev[1], item[1]))
8 return acc
9 return reduce(collect, valid, {})

Approach 2: pure lambda (one-liner flex, O(n²) — new dict each step)

1from functools import reduce
2def high_low(records):
3 valid = list(filter(lambda x: type(x[1]) == int, records))
4 return reduce(lambda acc, item: {**acc, item[0]: (
5 min(acc.get(item[0], (float("inf"), float("-inf")))[0], item[1]),
6 max(acc.get(item[0], (float("inf"), float("-inf")))[1], item[1]),
7 )}, valid, {})

MT9 — Digit Parity RLE

 1# Iterative
 2def encode_parity(n):
 3 out = []
 4 for ch in str(n):
 5 t = "E" if int(ch) % 2 == 0 else "O"
 6 if out and t == out[-1][0]:
 7 out[-1] = (t, out[-1][1] + 1)
 8 else:
 9 out.append((t, 1))
10 return out
11
12# Recursive
13def encode_parity_rec(n):
14 char = "E" if (n % 10) % 2 == 0 else "O"
15 if n < 10: return [(char, 1)]
16 rest = encode_parity_rec(n // 10)
17 if rest[-1][0] == char:
18 return rest[:-1] + [(char, rest[-1][1] + 1)]
19 return rest + [(char, 1)]

TCX1004 | Finals Cheatsheet (Units 6-9)

Sun, 19 Apr 2026 00:00:00 +0800

for the general cheatsheet (Units 1-5: proof rules, sets, induction), see the TCX1004 cheatsheet. full unit-by-unit notes in the TCX1004 notebook.

Exam: Apr 30, 2026 · 17:00 · LT7A Seat 64 · Open Book · No calculators · 1.5h Scope: Unit 6+ (Combinatorics, Graph Theory, Probability, Distributions/Expectation/Variance) Note: leave answers unsimplified.

Unit 6: Combinatorics

Placeholder — to be translated from Unit Notes.

Unit 7: Graph Theory

Placeholder — to be translated from Unit Notes.

Unit 8: Probability

Placeholder — to be translated from Unit Notes.

Unit 9: Distributions, Expectation, Variance

Step 1 — identify the distribution (3 questions)

Single trial, two outcomes? → Bernoulli$(p)$
Fixed $n$ trials, count successes? → Binomial$(n, p)$ — verify BINS (Binary / Independent / Number fixed / Same $p$)
Count trials until first success? → Geometric$(p)$

If none match: likely Uniform (all outcomes equally likely), or distribution is unknown → use bounds (Markov / Chebyshev).

Step 2 — distribution formulas

Distribution	$E[X]$	$\text{Var}[X]$	Trigger words
Bernoulli$(p)$	$p$	$p(1-p)$	one trial, two outcomes
Binomial$(n, p)$	$np$	$np(1-p)$	$n$ fixed trials, count successes (BINS)
Geometric$(p)$	$1/p$	$(1-p)/p^2$	until first success
Uniform (discrete)	$(a+b)/2$	depends on range	equally likely outcomes

Bounds (distribution unknown)

Bound	Formula	When to use
Markov	$P[X \geq a] \leq E[X]/a$	only $E[X]$ known, one-tail, $X \geq 0$
Chebyshev	$P[\lvert X - \mu \rvert \geq a] \leq \text{Var}[X]/a^2$	$E[X]$ and $\text{Var}[X]$ known, two-tail

Linearity of Expectation

$$E[X + Y] = E[X] + E[Y] \quad \text{(always, even if dependent)}$$

$$\text{Var}[X + Y] = \text{Var}[X] + \text{Var}[Y] \quad \text{(only if independent)}$$

Variable legend (don’t confuse under pressure)

Symbol	Source	Role
$\mu$	$E[X]$ from question	center
$\text{Var}[X]$	from question	spread$^2$
$\sigma$	$= \sqrt{\text{Var}[X]}$ (derived)	std dev — appears in $1/k^2$ form only
$a$	threshold inside $P[\lvert X - \mu \rvert \geq a]$	denominator (squared)
$k$	$= a/\sigma$	$\sigma$-multiples in alternate form

$a$ and $\sigma$ are different variables even when they share a numeric value.

Pre-submit sanity checks

probability $\in [0, 1]$ — never negative
$E[X] \in [\min X, \max X]$ — NOT bounded by $[0, 1]$
re-add arithmetic on 1-mark questions
plugged $a$ (threshold) or $\sigma$ (std dev)? they are different
Chebyshev monotonicity: larger $a$ → smaller bound. if bound grew, you plugged wrong.

TCX2101 | Finals Helpsheet (A4 Double-Sided)

Sun, 19 Apr 2026 00:00:00 +0800

Ch 1: Functions

Domain Rules

Type	Restriction
Polynomial	ℝ (all real)
Rational	Denom ≠ 0
√ (numerator)	Inside ≥ 0
√ (denominator)	Inside > 0 (strict!)
Logarithm	Inside > 0

Multi-restriction: find each, intersect. Ex: √(x²−9) ⟹ |x| ≥ 3 ⟹ (−∞,−3] ∪ [3,∞) (two regions).

Transformations (inside = horizontal OPPOSITE, outside = vertical SAME)

Transform	Formula	Effect
Shift vertical	f(x) ± k	Same direction as sign
Shift horizontal	f(x ∓ h)	Opposite of sign: f(x−3) shifts RIGHT
Vert stretch / compress	a·f(x)	a>1 stretch · 0<a<1 compress
Horiz stretch / compress	f(bx)	b>1 COMPRESS · 0<b<1 stretch (opposite!)
Reflect x-axis	−f(x)	Flip vertical
Reflect y-axis	f(−x)	Flip horizontal
\|f(x)\|	—	Flip negatives up (reflect below x-axis)
f(\|x\|)	—	Mirror y-axis (copy right → left)

Composition & Inverse

Concept	Formula
Composition	(f∘g)(x) = f(g(x))
Domain of f∘g	{x ∈ D_g : g(x) ∈ D_f}
Order matters	f∘g ≠ g∘f
Inverse property	f⁻¹(f(x)) = x, f(f⁻¹(x)) = x

Exponent Rules

Rule	Formula
Product	aˣ · aʸ = aˣ⁺ʸ
Quotient	aˣ / aʸ = aˣ⁻ʸ
Power of power	(aˣ)ʸ = aˣʸ
Product to power	aˣ · bˣ = (ab)ˣ
Quotient to power	aˣ / bˣ = (a/b)ˣ
Master	aˣ = e^(x ln a)

Log Rules

Rule	Formula
Product	log_a(xy) = log_a x + log_a y
Quotient	log_a(x/y) = log_a x − log_a y
Power	log_a(xᶜ) = c log_a x
Change of base	log_a x = ln x / ln a
Special	log_a a = 1 · log_a 1 = 0

Ch 2: Limits & Continuity

One-Sided Limits

Notation	Meaning
lim_{x→a⁻} f	Approaches from left
lim_{x→a⁺} f	Approaches from right
lim_{x→a} f = L	⟺ both one-sided = L
Left ≠ Right	Jump discontinuity
L = R ≠ f(a)	Removable (hole)

Limit Laws (if lim f = L, lim g = M)

Law	Formula	Condition
Sum / Diff	L ± M	—
Product	LM	Both finite
Quotient	L/M	M ≠ 0
Power	Lⁿ	—
Root	ⁿ√L	L ≥ 0 if n even
Scalar	kL	—

Division Forms (Traps)

Form	Result
5/0	±∞ (blows up)
0/5	0 (fine)
0/0	Indeterminate
∞/∞	Indeterminate
0 · ∞	Indeterminate
∞ − ∞	Indeterminate
0⁰ / 1^∞ / ∞⁰	Indeterminate

Solving 0/0

Method	Trigger
Factor + cancel	Polynomial over polynomial
Conjugate	Radicals (√) in num or denom
L’Hôpital	See Ch 3 (fast fallback)

Key Limits


tan⁻¹(∞)=π/2	tan⁻¹(0)=0	tan⁻¹(−∞)=−π/2	e⁻∞=0	e∞=∞
ln(0⁺)=−∞	1/∞=0	1/0⁺=∞	1/0⁻=−∞	e⁰=1
ln(1)=0	ln(∞)=∞	x→0⁺: x ln x→0	x→∞: ln x/x→0	x→0: sin x/x→1
x→0: (1−cos x)/x→0	x→∞: xe⁻ˣ→0	arctan(∞)=π/2	arctan(−∞)=−π/2	arctan(0)=0

Limits at Infinity — Rational (aₙxⁿ+…) / (bₘxᵐ+…)

Degrees	Limit
n < m (top smaller)	0
n = m (same)	aₙ / bₘ (leading coef ratio)
n > m (top bigger)	±∞

Squeeze Theorem

g ≤ f ≤ h near c, lim g = lim h = L ⟹ lim f = L. Classic: |h sin(1/h)| ≤ |h| → 0 ⟹ h sin(1/h) → 0.

Asymptotes

Type	Condition	How to find
Horizontal y = b	lim_{x→±∞} f = b	Degree comparison
Vertical x = a	Denom = 0, num ≠ 0	Factor denom
Oblique y = mx+c	deg(top) = deg(bot) + 1	Long division, drop remainder

Continuity 3-step (at x = a)

Check	Must hold
1	f(a) defined
2	lim_{x→a} f(x) exists
3	lim = f(a)

Piecewise: left = right = f(a).

4 Discontinuity Types

Type	Condition	Fixable?
Removable (hole)	L = R ≠ f(a)	Yes — redefine f(a)
Jump	L ≠ R	No
Infinite	lim = ±∞	No
Oscillatory	lim DNE (e.g. sin(1/x) at 0)	No

IVT (Intermediate Value)

f continuous on [a,b], N between f(a), f(b) ⟹ ∃c ∈ (a,b) with f(c) = N.

Intersection proof (CT1 trap): Show f, h intersect ⟹ define g = f − h. Show g(a), g(b) opposite signs, apply IVT ⟹ ∃c with g(c) = 0 ⟹ f(c) = h(c).

Ch 3: Differentiation

Derivative Definition (both forms)

$$f’(a) = \lim_{h\to 0}\frac{f(a+h)-f(a)}{h} = \lim_{x\to a}\frac{f(x)-f(a)}{x-a}$$

Interpretation	Meaning
Geometric	Tangent slope
Physical	Instantaneous rate of change
Tangent line at P(a, f(a))	y = f(a) + f’(a)(x − a)

Differentiability (CT1 trap — lost 4 marks)

Step	Check
1	Continuous at a? (values match)
2	Slopes match? Compute left & right limits of [f(a+h)−f(a)]/h; equal ⟹ differentiable
Implication	Differentiable ⟹ continuous. Continuous ⇏ differentiable (e.g. \|x\| at 0)

Piecewise / |x| at non-smooth point: standard rules FAIL, must use LIMIT DEFINITION.

Core Rules

Rule	Formula
Power	(xⁿ)’ = n x^(n−1) (all real n)
Constant	c’ = 0, (cf)’ = cf'
Sum/Diff	(u ± v)’ = u’ ± v'
Product	(uv)’ = u’v + uv'
Quotient	(u/v)’ = (u’v − uv’) / v²
Chain	[f(g(x))]’ = f’(g(x)) · g’(x)
Triple product	(uvw)’ = u’vw + uv’w + uvw'
Reciprocal	(1/f)’ = −f’/f²

Trig Derivatives (CO = negative)

f	f'	f	f'
sin x	cos x	csc x	−csc x cot x
cos x	−sin x	sec x	sec x tan x
tan x	sec²x	cot x	−csc²x

Exp / Log / Inverse Trig

f	f'
eᵘ	eᵘ · u'
ln u	u’ / u
aᵘ	aᵘ ln(a) · u'
log_a u	u’ / (u ln a)
sin⁻¹ u	u’ / √(1 − u²)
cos⁻¹ u	−u’ / √(1 − u²)
tan⁻¹ u	u’ / (1 + u²)
cot⁻¹ u	−u’ / (1 + u²)
sec⁻¹ u	u’ / (\|u\| √(u² − 1))
csc⁻¹ u	−u’ / (\|u\| √(u² − 1))

Implicit Differentiation

Step	Action
1	Differentiate both sides w.r.t. x
2	On y-terms: chain rule, (f(y))’ = f’(y) · dy/dx
3	Collect dy/dx terms, solve

Ex: x² + y² = 25 ⟹ 2x + 2y·y’ = 0 ⟹ y’ = −x/y.

Higher-Order

Notation	Meaning
f’’(x)	d²f/dx²
f’’’(x)	d³f/dx³
f^(k)(x)	d^k f/dx^k

FDT / SDT / Concavity / Extrema

Test	Condition	Result
FDT	f’ changes + → − at c	Local max
FDT	f’ changes − → + at c	Local min
FDT	Same sign	No extremum
SDT	f’(c) = 0 and f’’(c) > 0	Local min (∪ cup)
SDT	f’(c) = 0 and f’’(c) < 0	Local max (∩ cap)
SDT	f’’(c) = 0	Inconclusive, fall back to FDT
Concavity	f’’ > 0	Concave up ∪
Concavity	f’’ < 0	Concave down ∩
Inflection	f’’ CHANGES sign	Verified inflection point
Critical	f’ = 0 OR f’ undefined	Candidate for extrema
Absolute on [a,b]	Compare f at crit pts AND endpoints	—

MVT / Rolle’s / L’Hôpital / “∃c” Detector

Theorem	Hypotheses	Conclusion
Rolle’s	f cts [a,b], diff (a,b), f(a)=f(b)	∃c with f’(c) = 0
MVT	f cts [a,b], diff (a,b)	∃c with f’(c) = (f(b)−f(a))/(b−a)
IVT	f cts [a,b], N between f(a), f(b)	∃c with f(c) = N
L’Hôpital	lim f/g = 0/0 or ∞/∞	lim f/g = lim f’/g'

“∃c such that…”	Use
f(c) = k	IVT (no derivative)
f’(c) = 0	Rolle’s
f’(c) = ratio	MVT

⚠ L’Hôpital: check indeterminate form FIRST. Stop when no longer indet. Diff top & bottom SEPARATELY (not quotient rule).

FTC I (Leibniz — 4 Cases)

Limits	d/dx ∫ f(t) dt =
[a, x]	f(x)
[a, g(x)]	f(g(x)) · g’(x) (CHAIN!)
[x, b]	−f(x)
[a(x), b(x)]	f(b(x))·b’(x) − f(a(x))·a’(x)

Linear Approximation

L(x) = f(a) + f’(a)(x − a) near x = a.

Ch 4: Integration

Definite Integral Properties

Property	Formula
Zero width	∫_a^a f = 0
Reverse	∫_a^b = −∫_b^a
Additivity	∫_a^c = ∫_a^b + ∫_b^c
Comparison	f ≤ g ⟹ ∫f ≤ ∫g
Non-negative	f ≥ 0 ⟹ ∫f ≥ 0
Max-min	m(b−a) ≤ ∫_a^b f ≤ M(b−a)

FTC II (Evaluation)

Formula	Note
∫_a^b f(x) dx = F(b) − F(a)	F any antiderivative. Don’t forget F(a)!

Antiderivatives (+C)

f	∫f	f	∫f	f	∫f
xⁿ (n ≠ −1)	x^(n+1)/(n+1)	1/x	ln\|x\|	eˣ	eˣ
e⁻ˣ	−e⁻ˣ	sin x	−cos x	cos x	sin x
sec²x	tan x	csc²x	−cot x	sec x tan x	sec x
csc x cot x	−csc x	tan x	ln\|sec x\|	cot x	ln\|sin x\|
1/(1+x²)	tan⁻¹x	1/√(1−x²)	sin⁻¹x	ln t	t ln t − t
1/(a²+x²)	(1/a)tan⁻¹(x/a)	1/√(a²−x²)	sin⁻¹(x/a)

⚠ ∫cos x = +sin x (−sin is derivative). xⁿ: divide by NEW exponent (n+1).

Power-Reduction

Identity
sin²u = (1 − cos 2u) / 2
cos²u = (1 + cos 2u) / 2

Integration Techniques

Tech	Formula / Trigger	Note
IBP	∫u dv = uv − ∫v du	LIATE: Log > InvTrig > Alg > Trig > Exp
IBP cycling	I = stuff − I ⟹ 2I = stuff	Solve algebraically
u-sub	u = g(x), du = g’(x) dx	Inner-deriv pattern. Convert bounds IMMEDIATELY
PF linear	A/(x−a) → A ln\|x−a\|	Single linear
PF repeated	A₁/(x−a) + A₂/(x−a)² + …	Each power gets a term
PF irred. quad	(Ax+B)/(x²+bx+c)	Split into ln + arctan parts
Trig sub √(a²−x²)	x = a sinθ	→ a cosθ
Trig sub √(a²+x²)	x = a tanθ	→ a secθ
Trig sub √(x²−a²)	x = a secθ	→ a tanθ
Abs-value	Split at zero of inside, ADD pieces	Sign analysis first
Long division	deg(P) ≥ deg(Q)	Do long div first, then PF

Trig Identities

Family	Identity
Pythagorean	sin² + cos² = 1
Pythagorean	1 + tan² = sec²
Pythagorean	1 + cot² = csc²
Addition (sin)	sin(A ± B) = sin A cos B ± cos A sin B
Addition (cos)	cos(A ± B) = cos A cos B ∓ sin A sin B (flip!)
Double (sin)	sin 2x = 2 sin x cos x
Double (cos)	cos 2x = cos²x − sin²x = 2cos²x − 1 = 1 − 2sin²x
Reciprocal	sec = 1/cos · csc = 1/sin · cot = cos/sin

Improper Integrals (4.8)

Type	Form	Rule
I (infinite)	∫_a^∞	= lim_{b→∞} ∫_a^b
II (disc bound)	∫_a^b with bad a	= lim_{c→a⁺} ∫_c^b
Interior disc at d	Must split	∫_a^d + ∫_d^b. One diverges ⟹ WHOLE diverges
∫_{−∞}^∞	Split at any c	Both halves must converge

p-Test

Integral	Converges
∫₁^∞ 1/xᵖ	p > 1
∫₀^1 1/xᵖ	p < 1

Direction flips: ∞ needs fast decay (p>1), 0 needs mild blow-up (p<1).

Odd / Even on [−a, a]

Symmetry	Integral
Odd f (f(−x) = −f(x))	0
Even f (f(−x) = f(x))	2 ∫₀ᵃ f

⚠ Improper: verify BOTH halves converge before using symmetry. ⚠ ∫₋₁^1 1/x² diverges (interior blow-up). Write “DIVERGES” not “= ∞”.

Area

Target	Formula
Under curve	∫_a^b \|f(x)\| dx (find zeros, split, negate where f < 0)
Between curves	∫_a^b (top − bottom) dx (sketch, find intersections)

⚠ ∫_a^b f is SIGNED area (negatives cancel). Use |f| for actual area.

Volume (4.9-4.10)

Method	Formula	When
Disk	π ∫_a^b [f(x)]² dx	Solid, ⊥ axis, no hole
Washer	π ∫_a^b [R² − r²] dx	Two curves, hole in middle
Shell	2π ∫_a^b (radius)(height) dx	Parallel to axis
Cross-section	∫_a^b A(x) dx	Non-revolution

Cross-Section Areas (s = side / diameter)

Shape	Area
Square	s²
Equilateral △	(√3/4) s²
Isosc. right △ (leg s)	s²/2
Semicircle (dia s)	π s²/8
Circle (dia s)	π s²/4

Shifted Axis

Axis	Method	Shift to	Radius
x-axis	Disk/Washer	y = k	f(x) − k (or k − f(x) if axis above curve)
y-axis	Shell	x = k	\|x − k\|

Disk vs Shell Decision

Slicing direction	Method
⊥ to axis of revolution	Disk / Washer
∥ to axis of revolution	Shell
y = f(x) revolved around y-axis	Shell (easier, no x = g(y))

Ch 5: Linear Systems (RREF)

Terminology

Concept	Details
REF	Zeros BELOW pivots (forward elimination)
RREF	Zeros ABOVE + below pivots (+leading 1s)
Pivot col	Has leading 1 (forced)
Free col	No leading 1 (parameter: s, t, …)
Count	#free = n − #pivots

⚠ RREF ≠ identity when free vars exist. Solve for PIVOT vars, not free.

Vector Form Solution

Step	Action
1. xₚ (particular)	Set free vars = 0, read RHS at pivot rows (0 at free positions)
2. Direction vectors	Per free var: pivot-row entries flipped sign → pivot slots; that free = 1, others = 0
3. Combine	x = xₚ + s v₁ + t v₂ + …

Solution Shapes

#free vars / pattern	Shape
0 free	Unique
1 free	Line
2 free	Plane
Row [0 … 0 \| nonzero]	No solution (contradiction)

Elementary Row Ops

Op	Effect on det
Swap 2 rows	Flip sign
Scale row by k ≠ 0	Multiply det by k
Add multiple of one row to another	Unchanged

Homogeneous vs Non-homogeneous

System	Property
Ax = 0 (homogeneous)	Always has x = 0. Non-trivial iff free vars exist
Ax = b (non-hom)	0, 1, or ∞ solutions

Ch 6: Matrix Algebra

Operations

Op	Formula / Note
Sum	(A+B)ᵢⱼ = Aᵢⱼ + Bᵢⱼ (same dim)
Scalar	(kA)ᵢⱼ = k · Aᵢⱼ
Product	(AB)ᵢⱼ = Σₖ Aᵢₖ Bₖⱼ. A is m×n, B is n×p ⟹ AB is m×p
Associative	(AB)C = A(BC)
Distributive	A(B + C) = AB + AC
⚠ NOT commutative	AB ≠ BA in general
Transpose of product	(AB)ᵀ = Bᵀ Aᵀ
Inverse of product	(AB)⁻¹ = B⁻¹ A⁻¹ (REVERSE order)
Double transpose	(Aᵀ)ᵀ = A
Double inverse	(A⁻¹)⁻¹ = A
Transpose / inverse mix	(A⁻¹)ᵀ = (Aᵀ)⁻¹

Determinant Compute

Size	Method
2×2	det = ad − bc
3×3	Cofactor expansion, row/col with MOST zeros. Sign: +−+−
4×4	Row reduce to triangular; track sign flips & scalar pulls
Triangular	det = ∏ diagonal

Determinant Properties

Formula	Result
det(kA)	kⁿ det(A) — NOT k det(A); each of n rows scaled
det(AB)	det(A) det(B)
det(A⁻¹)	1 / det(A)
det(Aⁿ)	det(A)ⁿ
det(Aᵀ)	det(A)
det(−M)	(−1)ⁿ det(M). 4×4: sign STAYS
det(Aᵀ A⁻¹)	1 (invertible A)

Determinant Traps

Trap	Detail
NOT linear	det(A+B) ≠ det(A) + det(B). Try A=B=I: det(2I)=4 ≠ 2
Zero + Zero	det(A)=0, det(B)=0 ⇏ det(A+B)=0. Try A=[[1,0],[0,0]], B=[[0,0],[0,1]] ⟹ A+B=I
Simplify first	M²M⁻¹ = M ⟹ det = det(M)

2×2 Inverse

$A = \begin{bmatrix}a & b \ c & d\end{bmatrix} \Rightarrow A^{-1} = \frac{1}{ad - bc}\begin{bmatrix}d & -b \ -c & a\end{bmatrix}$ (swap diag, negate off-diag)

Inverse via Row Reduction (any size)

Step	Action
1	Form augmented [A \| I]
2	Row reduce until left side = I
3	Right side is A⁻¹
Fail	Left can’t reach I (zero row) ⟹ A not invertible

Package Deal (Invertibility)

✓ Invertible	✗ Not invertible
det(A) ≠ 0	det(A) = 0
RREF = Iₙ	RREF has zero row
All n cols pivot	Col without pivot
No free vars	Free vars exist
Ax = 0 only x = 0	Ax = 0 has other solutions
Cols lin indep	Cols dependent
Cols span ℝⁿ / Ax = b solvable ∀b	Don’t span

Linear Independence

Test	Detail
Setup	Put vectors as COLUMNS, row reduce, count pivots
Indep	Every col has pivot
Dep	Any col without pivot (= combo of pivot cols)
Always dep	Contains 0 vector
⚠	Pairwise non-scalar ≠ indep. Always use pivot-count

Ch 7: Euclidean Vector Spaces

Definitions

Term	Meaning
Subspace	Non-empty subset closed under + and scalar × (auto contains 0)
Span	All combos c₁v₁ + … + c_kv_k
Basis	Independent set that spans V (no redundancy)
Dimension	# vectors in any basis (invariant)

Subspace Proof Rhythm (V = {x : equation(s)})

Step	Action
(i) Zero	Show 0 ∈ V (plug in, gives 0 = 0 ✓)
(ii) Closed under +	Let u, v ∈ V. Then [eq for u]…(1), [eq for v]…(2). Consider u+v: [expand] = [regroup by (1),(2)] = 0. ∴ u+v ∈ V
(iii) Closed under ×	Let u ∈ V, c ∈ ℝ. Then [eq]…(3). Consider cu: [factor c] = c·0 = 0. ∴ cu ∈ V

Homogeneous (= 0): always subspace. Non-homogeneous (≠ 0): NEVER (0 fails). Multi-eqs: check ALL in each step.

Basis from Equation

Step	Action
1	Variables NOT in equation = automatically FREE
2	dim(V) = n − #indep equations
3	Solve for pivot var, parameterise frees, collect direction vectors

Ex: V = {(x,y,z,w) ∈ ℝ⁴ : x − 2y + z = 0}. Solve x = 2y − z. y = s, z = t, w = r (3 free ⟹ dim = 3). (x,y,z,w) = s(2,1,0,0) + t(−1,0,1,0) + r(0,0,0,1). Basis = those three vectors.

Span Test (is w ∈ span{v₁, v₂}?)

Step	Action
Setup	Augment [v₁ \| v₂ \| w], row reduce
Result	Row [0 … 0 \| nonzero] ⟹ w ∉ span
Result	No contradiction ⟹ w ∈ span
vs Independence	[v₁ \| v₂] alone (no augment), count pivots

Rank-Nullity

Formula	Meaning
rank(A) + nullity(A) = n	n = # cols of A
rank	# pivot cols
nullity	# free cols
Null basis	Same as Ch 5 vector form with RHS = 0

⚠ Verify: plug each null basis vector into Ax = 0. Every row must = 0.

Dimension Constraints

Fact
dim(V) = k ⟹ cannot have k+1 independent vectors in V
2 vectors in ℝ³ ≠ basis (dim ℝ³ = 3)
If # vectors = dim(V), then indep ⟺ spans V

Column Space / Null Space

Space	Definition	Basis
Col(A)	Span of columns (image of x ↦ Ax)	PIVOT columns of A (from ORIGINAL, not RREF)
Null(A)	{x : Ax = 0}	Vector form with RHS = 0

Ch 8: Orthogonality, Projection, Least Squares ⭐ HIGHEST EMPHASIS

Foundation

Formula	Note
u · u = ‖u‖²	Always SQUARE. ‖u‖ = 3 ⟹ u · u = 9
‖u + v‖²	= ‖u‖² + 2(u · v) + ‖v‖²
If u ⊥ v	‖u + v‖² = ‖u‖² + ‖v‖²

Orthogonal vs Orthonormal

Set type	Condition
Orthogonal	Every pair u · v = 0. Lengths free.
Orthonormal	Orthogonal AND every ‖u‖ = 1
0 vector	Orthogonal to everything (ok in orthogonal set). NOT orthonormal (length 0)

§8.2 Orthogonal Complement W⊥

Rule	Statement
Efficiency	v ⊥ W ⟺ v ⊥ every basis vector of W
Core theorem	Non-zero orthogonal set ⟹ linearly independent (proof: pairwise dot products = 0)

Find basis of W⊥:

Step	Action
1	Let v = (x₁, …, xₙ) be unknown in W⊥
2	Set v · bᵢ = 0 for each basis vector bᵢ of W
3	Get homogeneous linear system
4	Solve (Ch 5 vector form) ⟹ basis of W⊥

§8.3 Coefficients in Basis Expansion

For v = c₁u₁ + … + cₙuₙ with {uᵢ} orthogonal basis of V:

Basis type	Coefficient
Orthogonal	cᵢ = (v · uᵢ) / (uᵢ · uᵢ)
Orthonormal	cᵢ = v · uᵢ (denom = 1)
Observation	v · u_k = 0 ⟹ c_k = 0

§8.3 Projection & Decomposition

Concept	Formula
proj_W(v)	Σ (v · uᵢ) / (uᵢ · uᵢ) · uᵢ over orthogonal basis of W
Decomposition	v = proj_W(v) + v_perp
v_perp	v − proj_W(v), lives in W⊥

§8.4 Gram-Schmidt (concept only, procedure NOT tested)

Step	Formula
v₁	= a₁
v₂	= a₂ − proj_{v₁}(a₂)
General	vᵢ subtracts projection onto previous v’s
Normalise (if orthonormal wanted)	Divide each vᵢ by ‖vᵢ‖

§8.5 Least Squares ⭐

Item	Formula / Note
Setup	Ax = b inconsistent (no exact solution)
Goal	Find u minimising ‖Ax − b‖
Normal equation	AᵀA u = Aᵀ b
Method	Form augmented [AᵀA \| Aᵀb], row reduce, solve
Size check	A is m × n ⟹ AᵀA is n × n

§8.5 Best Fit Line

Item	Formula
Data	(x₁, y₁), …, (x_k, y_k)
Model	y = mx + c
A matrix	Col 1 = 1s, Col 2 = x values
b vector	y values
Solve	AᵀA [c; m]ᵀ = Aᵀ b ⟹ intercept c, slope m
⚠ Qualitative fit judgment	NOT tested, only calculation

Errors to Avoid (CT1, CT2, CT3, Mocks, HW)

Error	Fix
Used standard rule at non-smooth point	Use LIMIT DEFINITION; check left & right
Evaluated across interior discontinuity	Scan denom for zeros, split integral
√(negative) / wrong sign across \|x − a\|	Left of a: use (a − x), chain rule (−1)
∫cos x = −sin x	No, +sin x (−sin is derivative)
u-sub forgot to convert bounds	x = a → u = g(a); convert IMMEDIATELY
Forgot shifted-axis radius	Radius = f(x) − k, not f(x)
5/0 thought “undefined”	±∞ (blows up)
0/0 thought = 0	Indeterminate — simplify!
0 · ∞ thought = 0	Indeterminate!
L’Hôpital without checking indet form	Check FIRST, else wrong
FTC I Case 2 chain rule forgotten	∫_a^{g(x)} needs f(g(x)) · g’(x)
Quotient rule with + not −	Lo·d-Hi MINUS Hi·d-Lo
det(kA) = k det(A)	Wrong: kⁿ det(A)
Solved for free vars instead of pivot	Free = parameter; solve PIVOT vars
Pairwise non-scalar = “independent”	Use pivot-count
Used ‖u‖ for u · u	u · u = ‖u‖² (square it)
Forgot denom in cᵢ formula	Orthogonal: / uᵢ · uᵢ. Drop only if orthonormal
2 vectors in ℝ³ = “basis”	dim(ℝ³) = 3; need 3
Projection vs decomposition confused	Projection = one vector. Decomposition = proj + perp
Horizontal shift wrong direction	f(x − 3) shifts RIGHT (opposite of sign)
Inflection from f’’ = 0 alone	Must verify sign CHANGE
Read tan(x³) as tan³(x)	Read notation twice
u-sub: du doesn’t match	Wrong u, try another
Forgot F(a) in FTC II	Answer = F(b) − F(a), not F(b)

Reasoning Templates (HW2 anchor: Prof “weak explanation = #1 mark killer”)

Topic	Template
Subspace	“Since u, v ∈ V: [eq(1)], [eq(2)]. Consider u+v: [expand] = [regroup] = [by (1),(2)] 0. ∴ u+v ∈ V.”
IVT	“f is continuous on [a,b] and f(a)·f(b) < 0, so by IVT, ∃c ∈ (a,b) with f(c) = 0.”
MVT	“f continuous on [a,b], differentiable on (a,b), so by MVT, ∃c with f’(c) = (f(b)−f(a))/(b−a).”
Differentiability	“f’(a) = lim_{h→0} (f(a+h)−f(a))/h. Left: L⁻. Right: L⁺. Since L⁻ = L⁺ = L, f is differentiable with f’(a) = L.”
L’Hôpital	“lim f/g gives 0/0 (indeterminate). By L’Hôpital, lim f/g = lim f’/g’ = …”
FTC I Case 2	“By FTC I with chain rule, d/dx ∫_a^{g(x)} f(t) dt = f(g(x)) · g’(x).”
u-sub (definite)	“Let u = g(x), du = g’(x) dx. x = a ⟹ u = g(a); x = b ⟹ u = g(b). Then ∫a^b … = ∫{g(a)}^{g(b)} f(u) du = …”
Least Squares	“Ax = b is inconsistent. Least-squares solution u satisfies AᵀAu = Aᵀb. Forming [AᵀA \| Aᵀb], row reduce: u = …”
Orthogonal complement	“v ∈ W⊥ ⟺ v · bᵢ = 0 for each basis vector bᵢ of W. This gives the homogeneous system [system], whose solution set is W⊥.”
Rank-Nullity	“A has rank r (# pivot cols), so nullity = n − r. Null space has dim n − r, basis {v₁, …, v_{n−r}} from free-var parameterisation.”

Y1S2 Finals Sprint: 17 Days, 3 Exams, 3 Prep Modes

Fri, 17 Apr 2026 00:00:00 +0800

Three finals in seven days. Apr 28 (2101), Apr 30 (1004), May 4 (1002). Between today and the last exam, 17 days.

The obvious planning mistake is to treat this as “three content piles, divide time proportionally”. That gives equal hours to very unequal problems.

The real shape: three different prep modes

Each exam rewards a different kind of practice. You cannot just read notes three times.

Module	Prep mode	Why
TCX2101	Helpsheet-first build, then drill from it	Prof’s HW2 feedback: “loss of marks is mainly due to weak explanation.” Closed book with 1 × A4 double-sided. Full syllabus (§1 to §8). Building the helpsheet IS the review pass; drilling from it locks recall.
TCX1004	Translate Quartz notes into a personal-style cheatsheet	Pure open book, no calculator. The cheatsheet IS 80% of the exam. Source: the `mathematical-techniques` Quartz notes. Target: a print-ready cheatsheet in my own words, Units 6 onward.
TCX1002	Trace-and-fill drills in the new format	PE (20/20) was “write full code”. Final is “fill the gaps in existing code”. Different skill, same language. Transition window matters more than more content review.

Historical signal shapes the allocation

Module	History	Implication
TCX2101	CT1 7/10, CT2 5/10, CT3 ~8/10	Weakest. Feed the hungriest mouth first.
TCX1004	HW1 9/9, HW2 est 30/30, all quizzes current	Strongest. Maintenance mode.
TCX1002	PE 20/20 (Apr 16)	Strong but format is new. Transition > bulk.

Translation to person-days, across the 17-day window:

1TCX2101 │ ████████████████████████ ~8 days (47%)
2TCX1004 │ ████████████ ~4 days (24%)
3TCX1002 │ ██████████ ~3 days (18%)
4Rest │ ██████ ~2 days (11%)

Constraints and carve-outs

This plan is not a monastery. Four things continue in parallel:

Ketchup work: 2 to 4 hours daily. Not pausable. Subtract it from the study budget instead of pretending.
Journal app: background maintenance only, no new features during the 17 days.
Workout: keep the 7-day parts split. Training during exam prep is stabilising, not distracting. Reduction is only if recovery becomes the bottleneck.
Family and social: paused for the duration. One exception: family dinner on Apr 18 evening, late-night catchup compensates.

Daily ritual that anchors everything: 30 minutes each morning reviewing CLAUDE.md and the sprint document. Mental warm-up, not work.

The 17-day grid

 1Date Mode Module Energy Focus hours
 2────────────────────────────────────────────────────────────────────────────────
 3Apr 17 Fri Post-Friday-Sweep reset 2101 Low 1h
 4Apr 18 Sat Tutorial + Mock 10 + fam dinner Mixed Medium 5h + late
 5Apr 19 Sun Helpsheet build 1 (§1 to §4) 2101 HIGH 6h
 6Apr 20 Mon Helpsheet build 2 (§5 to §8) 2101 HIGH 6h
 7Apr 21 Tue Drill from helpsheet 2101 HIGH 5h
 8Apr 22 Wed Past papers + helpsheet refine 2101 HIGH 6h
 9Apr 23 Thu Translate Unit 6 to cheatsheet 1004 Med-High 5h
10Apr 24 Fri Translate Units 7 to 9 + CA check 1004 Medium 4h
11Apr 25 Sat 1004 mock + 2101 light review Both Med-High 6h
12Apr 26 Sun 2101 final cram 2101 Focused 5h
13Apr 27 Mon 2101 pre-exam drill + early sleep 2101 Controlled 3h
14Apr 28 Tue EXAM 17:00 MPSH4 2101 Exam ---
15Apr 29 Wed Recovery AM + 1004 ramp PM 1004 Rebuild 4h
16Apr 30 Thu EXAM 17:00 LT7A 1004 Exam ---
17May 01 Fri Labour Day. Real rest. OFF OFF 0h
18May 02 Sat 1002 deep block: fill-blank drill 1002 HIGH 6h
19May 03 Sun 1002 mock + early sleep 1002 Focused 4h
20May 04 Mon EXAM 09:00 LT7A 1002 Exam ---

The energy curve

A sprint is not a constant-output machine. There are three natural peaks and two mandatory valleys.

Red points are exam days (Apr 28, Apr 30, May 4). Three peaks: Apr 19-22 (2101 helpsheet build and drill), Apr 26 (2101 cram), May 2 (1002 transition). Two valleys: Apr 28 to Apr 29 (post-2101 recovery), May 1 (Labour Day).

The valleys are load-bearing. Skipping them borrows recovery debt against the next peak.

What makes this plan tight but survivable

Reading Week (Apr 18 to Apr 24) absorbs the heaviest 2101 work. Seven clear days, no classes.
Apr 28 to Apr 30: only two calendar days between 2101 and 1004. 1004 is the strongest module, so the short gap is tolerable if the cheatsheet is complete before Apr 28.
Apr 30 to May 4: four days including Labour Day rest. 1002 transition from PE format to fill-in-blank format gets the remainder.
No new content after the eve of each exam. Apr 27, Apr 29, May 3 are review-only.

Known unknowns (pending intel)

Some decisions are on hold until information arrives.

TCX2101 tutorial topic hint. A classmate reports the lecturer said one specific tutorial topic will be tested. Resolved Apr 17 (post-CT3 recording review). Chapter 8 is the emphasis. Least squares is highest priority (normal equation, best fit line). Orthogonal complement and projection also confirmed. Gram-Schmidt full procedure is explicitly not tested, which is a scope reduction.
TCX1002 final format details. PE had explicit exclusions (no regex, OOP, recursion, numpy). Does the final continue those? Asking in tutorial on Apr 18.
TCX1004 final briefing. 2101 posted a detailed briefing a week out. Expect 1004 to follow. Question count and mark distribution will update the grid.
TCX2101 past papers. Canvas Files and NUS Library past exam portal to be checked.

The anchor

Prof Jonathon’s line from the Apr 7 HW2 announcement is the strategic anchor for this sprint:

Loss of marks is mainly due to weak explanation. This course does not assess computation alone.

The calculator is allowed this time (unlike CT3). That freed time is reallocated from arithmetic speed to explanation quality. The helpsheet lives and dies on how well it captures reasoning templates, not just formulas.

If I can explain each concept as a sentence a peer would understand, without re-deriving, it is ready. If I cannot, no amount of working problems will close the gap.

Three finals, three modes, one anchor. Apr 17 start, May 4 end.