Lecture 20 — Brute Force and When It Wins

Learning objectives

• Write clean brute-force solutions
• Estimate brute-force cost with rough arithmetic
• Decide when brute force is acceptable

Case-based lecture: you attempt, we discuss, then we reveal.

The plan

• Four cases: cs-077, cs-078, cs-079, cs-080
• Each: 5-minute attempt → discussion → reveal → prompt
• Worked examples in between — ask anything
• Break mid-lecture · exit question at the end

Key definitions

• Brute force — enumerate the candidate space directly; correct by construction, fast only when the space is small.
• Candidate space — the set of possibilities the enumeration walks; its size is the real cost.
• Counting first — size the space with arithmetic BEFORE writing enumeration code.
• Constraint propagation — apply constraints during generation, not after, so dead branches die early.
• Exhaustive search — brute force over combinations/subsets; 2^n is the wall that motivates smarter design.

The 4-Digit Lock: ten thousand tries and a theorem

count = 0
for code in range(10000):
    if sum(int(d) for d in f"{code:04d}") == 12:
        count += 1
print(count)

Expected: 415 codes

Cost: O(10^4 x 4) - constant here, but the pattern is exponential in the number of dials: k dials -> 10^k. Brute force wins while the space stays small.

Perfect Numbers: brute force with a sqrt speed-up

def is_perfect(n):
    total = 1
    d = 2
    while d * d <= n:
        if n % d == 0:
            total += d + n // d
        d += 1
    return n > 1 and total == n

print([n for n in range(2, 10000) if is_perfect(n)])

Expected: [6, 28, 496, 8128]

Cost: O(n * sqrt(n)) overall - about 1.3 million operations here; the naive version needs 50 million. Same answer, 40x cheaper.

The Subset Riddle: every subset, systematically

items = [3, 5, 2, 8]
target = 10
found = None
for mask in range(1 << len(items)):
    total = sum(items[i] for i in range(len(items)) if mask >> i & 1)
    if total == target:
        found = [items[i] for i in range(len(items)) if mask >> i & 1]
        break
print(found)

Expected: subset found: 3 + 5 + 2 = 10

Cost: O(2^n) time - the price of the proof; meet-in-the-middle or DP (later lectures) trade that certainty for speed.

• **Input:** 4-digit PINs, digits 0-9, digits sum to 12
• **Output:** count first: 10^4 = 10000 candidates; favourable = 415 (455 sums possible minus the four all-identical digits)
• Solve for the worked instance first. Then ask what would change if one
• number, name, or condition were replaced by something stranger.

Pseudocode, flowchart or Python. State one assumption. Compare with your neighbour at minute 4.

cs-077 — discuss

• What did the deciding quantity turn out to be?
• Which assumption shaped your answer?
• After the solution is revealed, the class spends five minutes on this prompt: **"Which constraint is cheapest to check first, and why does order matter?"**

Instructor: the reveal, the reasoning section and common wrong turns are in the instructor distribution for cs-077 — not embedded in this deck.

• **Input:** perfect numbers below 10000 (sum of proper divisors equals n): 6, 28, 496, 8128
• **Output:** naive O(n^2); divisor bound sqrt(n) makes it ~O(n sqrt n) - measure both
• Solve for the worked instance first. Then ask what would change if one
• number, name, or condition were replaced by something stranger.

Pseudocode, flowchart or Python. State one assumption. Compare with your neighbour at minute 4.

cs-078 — discuss

• What did the deciding quantity turn out to be?
• Which assumption shaped your answer?
• After the solution is revealed, the class spends five minutes on this prompt: **"Double the input size: is this still acceptable? Show the arithmetic."**

Instructor: the reveal, the reasoning section and common wrong turns are in the instructor distribution for cs-078 — not embedded in this deck.

• **Input:** 4 people, 3 slots; free masks: ada {1,2}, bo {2,3}, cy {1,3}, dee {1,2,3}
• **Output:** triples with a common slot: {ada,bo,cy} -> none! check: intersection {2}&{3}&{3}... enumerate all 4 triples
• Solve for the worked instance first. Then ask what would change if one
• number, name, or condition were replaced by something stranger.

Pseudocode, flowchart or Python. State one assumption. Compare with your neighbour at minute 4.

cs-079 — discuss

• What did the deciding quantity turn out to be?
• Which assumption shaped your answer?
• After the solution is revealed, the class spends five minutes on this prompt: **"Which constraint is cheapest to check first, and why does order matter?"**

Instructor: the reveal, the reasoning section and common wrong turns are in the instructor distribution for cs-079 — not embedded in this deck.

• **Input:** [3, 7, 1, 2, 9], target 12 -> 3+9 or 1+2+9... enumerate subsets
• **Output:** 2^5 = 32 subsets; subset-sum found: {3, 9} and {1, 2, 9}; cost curve doubles each +1 item
• Solve for the worked instance first. Then ask what would change if one
• number, name, or condition were replaced by something stranger.

Pseudocode, flowchart or Python. State one assumption. Compare with your neighbour at minute 4.

cs-080 — discuss

• What did the deciding quantity turn out to be?
• Which assumption shaped your answer?
• After the solution is revealed, the class spends five minutes on this prompt: **"Double the input size: is this still acceptable? Show the arithmetic."**

Instructor: the reveal, the reasoning section and common wrong turns are in the instructor distribution for cs-080 — not embedded in this deck.

Common misconceptions

• Writing enumeration code before counting the space.
• Filtering after full generation when constraints could prune during generation.
• Assuming brute force is always too slow - at classroom scale it is the oracle.
• Confusing permutations (order matters) with combinations (it does not).

Summary & exit question

• Named technique today: Brute Force and When It Wins
• Four cases attempted — methods before answers

Exit question (choose one, 60 seconds)

1. How big is the subset space of 25 items, roughly?
2. What makes pruning sound?
3. When is brute force the right deliverable?