Lecture 11 — Lists and Slicing

Learning objectives

• Mutate, slice, and rebuild lists
• Distinguish aliasing from copying
• Choose the right traversal (index vs element vs enumerate)

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

The plan

• Four cases: cs-041, cs-042, cs-043, cs-044
• Each: 5-minute attempt → discussion → reveal → prompt
• Worked examples in between — ask anything
• Break mid-lecture · exit question at the end

Key definitions

• Aliasing — two names bound to the same list object; mutation through one is visible through the other.
• Copy (shallow) — lst[:] or list(lst) makes a new outer list; nested items are still shared.
• In-place mutation — methods like append/sort/reverse change the object; they usually return None.
• Rotation — moving items from one end of a list to the other by k positions (wraparound).
• Deduplication — keeping first occurrences only - order-preserving vs set-based variants.
• Slicing view — a slice produces a *new* list; it is not a live window onto the original.

The queue reorder: rotations as slices

Expected: 0 unchanged | 2 [D,E,A,B,C] | 5 unchanged | 7 [D,E,A,B,C]

Cost: O(n); the in-place three-reversal rotation (O(1) extra space) is the enrichment extension.

Deduplication patterns: order vs sorted

Expected: [3, 1, 2] [1, 2, 3]

Cost: O(n) with a seen-set; the naive 'not in keep' is O(n^2) - measurable at n = 10,000.

Rotate and roll: left, right, and wraparound

Expected: [3, 4, 5, 1, 2] | [4, 5, 1, 2, 3]

Cost: O(n); in-place three-reversal is O(n) time, O(1) extra space.

The aliasing trap: [[0]*3]*2

a = [1, 2]
b = a
b.append(3)
print(a, b is a)

Expected: [[9, 0, 0], [9, 0, 0]] then [[9, 0, 0], [0, 0, 0]]

Cost: Constant per assignment; the defect class returns as cs-047's swap and cs-027's ghost duplicate.

• **Input:** queue [A, B, C, D, E], k = 2 (last 2 to front)
• **Output:** [D, E, A, B, C]; k = 0 -> same; k = 5 -> same; k = 7 -> same (wrap)
• 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-041 — 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: **"Find the smallest change to the task that makes the slice solution wrong."**

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

• **Input:** [3, 1, 3, 2, 1, 3]
• **Output:** order-keeping: [3, 1, 2]; sort-based: [1, 2, 3]; naive O(n^2): same as order-keeping
• 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-042 — 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: **"When is the extra memory of slicing worth it, and when would you insist on in-place?"**

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

• **Input:** [1, 2, 3, 4, 5], rotate left by 2; rotate right by 2
• **Output:** left 2: [3, 4, 5, 1, 2]; right 2: [4, 5, 1, 2, 3]
• 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-043 — 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: **"Find the smallest change to the task that makes the slice solution wrong."**

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

• **Input:** grid = [[0]*3]*2; grid[0][0] = 9
• **Output:** both rows become [9, 0, 0] - the two rows are one object; fix: [[0]*3 for _ in range(2)]
• 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-044 — 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: **"When is the extra memory of slicing worth it, and when would you insist on in-place?"**

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

Common misconceptions

• Assuming assignment copies a list.
• Slicing when a copy is needed - aliasing corruption follows.
• Reversing by popping while still iterating over the same list.
• Chaining lst = lst.sort() and losing the list to None.

Summary & exit question

• Named technique today: Lists and Slicing
• Four cases attempted — methods before answers

Exit question (choose one, 60 seconds)

1. What is the difference between a = b and a = b[:] for lists?
2. Give the slice for the last three items and for every second item.
3. Why did the roster corrupt in cs-044?