Problem Solving — CS & DS

Lecture 19 — Invariants and Two Pointers

Learning objectives

State and defend loop invariants
Apply two-pointer scans to arrays and strings
Prove a loop terminates

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

Today

The plan

Four cases: cs-073, cs-074, cs-075, cs-076
Each: 5-minute attempt → discussion → reveal → prompt
Worked examples in between — ask anything
Break mid-lecture · exit question at the end

Key definitions

Two pointers — two indices moving through one list under a rule - from the ends inward, or a trailing/leading pair.
Invariant — a statement true before, during, and after every loop iteration; the correctness argument in miniature.
Movement rule — which pointer moves when, and why that rule can never skip the answer.
Partition — rearrange elements around a predicate (evens first) in place, preserving no order within groups.
Slow/fast pointers — two pointers advancing at different speeds; used to detect cycles without extra memory.

Explain each in one breath; the cases will do the heavy lifting.

Worked example

The Palindrome Walk: two pointers closing in

cs-073

Is 'Level' a palindrome? Compare characters from both ends, ignoring case.

word = "Level"
lo, hi = 0, len(word) - 1
ok = True
while lo < hi:
    if word[lo].lower() != word[hi].lower():
        ok = False
        break
    lo += 1
    hi -= 1
print(ok)

Expected: True ('Level' is a palindrome, case-insensitively)

Cost: O(n) time but only n/2 comparisons, O(1) extra space - the reverse-compare alternative also reads O(n) but copies the string.

Worked example

The Pair Sum Contract: two pointers on sorted data

cs-074

Sorted values 1, 3, 4, 6, 8. Find a pair summing to 10, or report none.

a = [1, 3, 4, 6, 8]
lo, hi = 0, len(a) - 1
found = None
while lo < hi:
    s = a[lo] + a[hi]
    if s == 10:
        found = (a[lo], a[hi])
        break
    if s < 10:
        lo += 1
    else:
        hi -= 1
print(found)

Expected: pair found: 4 + 6 = 10

Cost: O(n) after sorting - each round removes one element from consideration for good; the all-pairs alternative is O(n^2).

Worked example

Partition by Parity: evens left, odds right, one pass

cs-075

Rearrange 3, 1, 2, 4 so all even numbers precede all odd numbers. Order within each group does not matter.

a = [3, 1, 2, 4]
lo, hi = 0, len(a) - 1
while lo < hi:
    if a[lo] % 2 == 0:
        lo += 1
    else:
        a[lo], a[hi] = a[hi], a[lo]
        hi -= 1
print(a)

Expected: [4, 2, 1, 3] - all evens before all odds

Cost: O(n) time, O(1) space, single pass - each step settles one element permanently.

Case attempt · lecture 19

Case cs-073 · Beginner

The Palindrome Walk

Check a palindrome with two pointers from both ends. State the invariant ('everything outside the pointers is verified') and why it ends correctly.

**Input:** "Never odd or even" -> palindrome; "hello" -> not
**Output:** True / False via two pointers; invariant: everything outside [l, r] already verified
Solve for the worked instance first. Then ask what would change if one
number, name, or condition were replaced by something stranger.

⏱ 5 minutes — attempt now

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

Discussion

cs-073 — 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: **"Change one movement rule and predict the first input that breaks it."**

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

Case attempt · lecture 19

Case cs-074 · Foundational

The Pair Sum Contract

In a sorted list, find two elements summing to a target. The classic two-pointer; focus on the movement rule as an invariant, not a memorised trick.

**Input:** sorted [1, 2, 4, 7, 11], target 15 -> 4+11; target 20 -> none
**Output:** pair found (indices 3,4); none for 20; movement rule: sum small -> left++, sum big -> right
Solve for the worked instance first. Then ask what would change if one
number, name, or condition were replaced by something stranger.

⏱ 5 minutes — attempt now

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

Discussion

cs-074 — 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: **"Restate the invariant in your own words — is yours strong enough to prove the answer?"**

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

Case attempt · lecture 19

Case cs-075 · Intermediate

Partition by Parity

Rearrange a list so evens precede odds, in-place. Two pointers from both ends with a loop invariant stated before code. Termination argument required.

**Input:** [3, 1, 6, 2, 5] -> evens first: [6, 2, 3, 1, 5] (order within groups free)
**Output:** in-place two-pointer partition; invariant: [0,l) even, (r,n-1] odd; terminates because the gap shrinks
Solve for the worked instance first. Then ask what would change if one
number, name, or condition were replaced by something stranger.

⏱ 5 minutes — attempt now

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

Discussion

cs-075 — 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: **"Change one movement rule and predict the first input that breaks it."**

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

Case attempt · lecture 19

Case cs-076 · Advanced

The Slow-Fast Cycle

Detect a cycle in a sequence given only a 'next' function (Floyd's idea). The invariant is about distance; the aha is why they must meet. Proof-shaped thinking.

**Input:** next(i) cycles: 1->2->3->4->2 (cycle of length 3); slow/fast pointers from 1
**Output:** they meet inside the cycle; meeting guaranteed because the gap closes by 1 each step
Solve for the worked instance first. Then ask what would change if one
number, name, or condition were replaced by something stranger.

⏱ 5 minutes — attempt now

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

Discussion

cs-076 — 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: **"Restate the invariant in your own words — is yours strong enough to prove the answer?"**

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

Check yourself

Common misconceptions

Writing the two-pointer loop before stating the invariant - then being unable to debug it.
Moving both pointers in the same iteration of pair-sum search - can skip the unique answer.
Believing partition must preserve within-group order - it deliberately does not; that is the speed.
Assuming slow/fast meeting requires knowing the cycle length in advance - it does not.

Summary

Summary & exit question

Named technique today: Invariants and Two Pointers
Four cases attempted — methods before answers

Exit question (choose one, 60 seconds)

State cs-074's invariant in one sentence.
Why do two pointers give linear cost?
What ends the slow/fast walk's doubt?

Expected answers (instructor): the answer pair, if it exists, lies within the current window each pointer moves at most n times; total moves 2n the gap strictly shrinks — termination is provable