Lecture 13 — Dictionaries and Sets

Learning objectives

• Model lookups as key-value mappings
• Use sets for uniqueness and membership
• Count with dictionaries idiomatically

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

The plan

• Four cases: cs-049, cs-050, cs-051, cs-132, cs-052
• Each: 5-minute attempt → discussion → reveal → prompt
• Worked examples in between — ask anything
• Break mid-lecture · exit question at the end

Key definitions

• Dictionary — a collection of key -> value pairs; you look things up by key, not by position
• Key uniqueness — each key appears at most once; assigning to an existing key overwrites its value
• Set — an unordered collection with no duplicates; membership tests are fast
• Set operations — union (in either), intersection (in both), difference (in one but not the other)
• Membership test — asking 'is x present?' - the `in` operator, O(1) average on dict/set
• Accumulator pattern — initialise a structure before a loop and grow it inside the loop

The word tally: dictionary as counter

words = "the cat the dog the bird cat".split()
tally = {}
for w in words:
    tally[w] = tally.get(w, 0) + 1
best = max(tally, key=tally.get)
print(tally["the"], tally["cat"])
print(best, tally[best])

Expected: {'the': 3, 'cat': 2, 'dog': 1, 'bird': 1} and the (count 3)

Cost: O(n) time for n words, O(u) space for u distinct words - one pass, no nesting.

Course rosters: set operations as questions

CS = {"ada", "bo", "cy"}
DS = {"bo", "dee", "ada"}
print(sorted(CS & DS))
print(sorted(CS | DS))
print(sorted(CS - DS))
print(sorted(DS - CS))

Expected: both {ada, bo}; either {ada, bo, cy, dee}; only CS {cy}; only DS {dee}

Cost: Set operations are O(min(len)) on average; building sets is O(n).

The LRU cache: recency as a moving queue

order = []
def use(k):
    if k in order:
        order.remove(k)
    order.insert(0, k)
for op, k in [("put","a"),("put","b"),("get","a"),("put","c")]:
    use(k)
    if op == "put" and len(order) > 2:
        order.pop()
print(order)
use("d")
order.pop()
print(order)

Expected: after put c: {a, c} (b evicted); next eviction: a

Cost: O(capacity) per operation with a list; real caches use a hash map plus linked list for O(1).

• **Input:** "the cat the dog the bird cat"
• **Output:** the:3, cat:2, dog:1, bird:1 -> top three: the(3), cat(2), then dog and bird tie at 1 (tie-break: alphabetical)
• 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-049 — 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: **"Re-derive the tie-break rule: is it a technicality or part of the specification?"**

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

• **Input:** CS = {ada, bo, cy}; DS = {bo, dee, ada}
• **Output:** both: {ada, bo}; either: {ada, bo, cy, dee}; only CS: {cy}; only DS: {dee}
• 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-050 — 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: **"What breaks if two different real-world things map to the same key — and how would you detect it?"**

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

• **Input:** capacity 2; operations: put a, put b, get a, put c (evicts b)
• **Output:** after put c: {a, c}; LRU order a (recent), c; then put d evicts a
• 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-051 — 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: **"Re-derive the tie-break rule: is it a technicality or part of the specification?"**

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

• **Input:** the export column list; the session lead's request
• **Output:** three interpretations with their required columns, one
• clarifying question, one safe email opening line
• Solve for the worked instance first. Then ask what would change if one

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

cs-132 — 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: **"The app team answers: 'the device was offline for that session, but the door log has everyone.' Does that settle it? What do you now owe the session lead before the email goes out?"**

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

• **Input:** 3 ballots: A>B>C, B>C>A, C>A>B
• **Output:** A beats B 2-1; B beats C 2-1; C beats A 2-1 - a Condorcet cycle: no majority winner
• 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-052 — 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: **"What breaks if two different real-world things map to the same key — and how would you detect it?"**

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

Common misconceptions

• 'A dictionary is just a fancy list' - it answers different questions: lookup by key, not position.
• Assuming keys are sorted or ordered by insertion in every language - only some languages guarantee it.
• Using `dict[key]` to read a possibly-missing key - use `get` or `in` first; crashes are not policies.
• Confusing set union with list concatenation - union deduplicates, concatenation does not.

Summary & exit question

• Named technique today: Dictionaries and Sets
• Four cases attempted — methods before answers

Exit question (choose one, 60 seconds)

1. When do you choose a dictionary over a list?
2. What single operation do sets make O(1)-ish and lists O(n)?
3. Restate the consensus rule of cs-052 precisely.