Tuples

single = (5,)  # a 1-tuple
plain = (5)  # just 5
pair = 3, 4  # parentheses are optional
type(single), type(plain)
# (<class 'tuple'>, <class 'int'>)
squares = tuple(n * n for n in range(4))  # (0, 1, 4, 9)
gen = (n * n for n in range(4))  # a generator, not a tuple

point = (3, 4)
x, y = point
first, *rest = (1, 2, 3)  # 1 and [2, 3]: rest is a list
(r, c), dist = (0, 1), 5  # nested unpacking
 
 
def describe(p: tuple[int, int]) -> str:
    match p:
        case (0, 0):
            return "origin"
        case (v, 0) | (0, v):
            return f"on an axis at {v}"
        case _:
            return "elsewhere"
 
 
describe((0, 7)), describe((2, 2))
# ('on an axis at 7', 'elsewhere')

seen = {(0, 0), (0, 1)}
(0, 1) in seen  # True: compared by value
 
memo: dict[tuple[int, int], int] = {}
memo[2, 3] = 10  # the parentheses are optional in [ ]
memo[(2, 3)]  # 10
 
t = ([1], 2)
t[0].append(3)  # allowed: the list itself is mutable
print(t)  # ([1, 3], 2)
try:
    hash(t)
except TypeError as e:
    print(e)  # unhashable type: 'list'

import heapq
from itertools import count
 
tasks = [(2, "write"), (1, "plan"), (2, "test")]
sorted(tasks)  # [(1, 'plan'), (2, 'test'), (2, 'write')]
sorted(tasks, key=lambda t: (-t[0], t[1]))
# [(2, 'test'), (2, 'write'), (1, 'plan')]
 
h: list[tuple[int, int, dict[str, str]]] = []
tick = count()  # a tiebreaker before the payload
for prio, name in tasks:
    heapq.heappush(h, (prio, next(tick), {"name": name}))
heapq.heappop(h)[2]  # {'name': 'plan'}

from typing import NamedTuple
 
 
class Edge(NamedTuple):
    w: int
    u: str
    v: str
 
 
edges = [
    Edge(4, "a", "b"),
    Edge(1, "b", "c"),
    Edge(3, "a", "c"),
]
cheapest = min(edges)  # compared by w, then u, then v
print(cheapest)  # Edge(w=1, u='b', v='c')
w, u, v = cheapest  # unpacks like any tuple
cheapest._replace(w=0)  # Edge(w=0, u='b', v='c')
Edge(1, "b", "c") == (1, "b", "c")  # True: just a tuple

import sys
 
sys.getsizeof(())  # 48: the header (64-bit CPython 3.14)
sys.getsizeof((1, 2, 3))  # 72: plus 3 pointers
sys.getsizeof([1, 2, 3])  # 88: list header plus 4 slots

from collections import deque
 
DIRS = ((1, 0), (-1, 0), (0, 1), (0, -1))
rows = ["..#", "...", "#.."]
cells = {
    (r, c)
    for r, row in enumerate(rows)
    for c, ch in enumerate(row)
    if ch == "."
}  # open cells: membership replaces bounds checks
dist = {(0, 0): 0}
q = deque([(0, 0)])
while q:
    r, c = q.popleft()
    for dr, dc in DIRS:
        nxt = (r + dr, c + dc)
        if nxt in cells and nxt not in dist:
            dist[nxt] = dist[r, c] + 1
            q.append(nxt)
print(dist[2, 2])  # 4
 
xs = [5, 1, 5]
max((v, i) for i, v in enumerate(xs))  # (5, 2): last index
edge = (7, 3)
(min(edge), max(edge))  # (3, 7): one spelling per edge

from collections.abc import Sequence
 
type Cell = tuple[int, int]
 
 
def neighbors(cell: Cell) -> list[Cell]:
    r, c = cell
    return [(r + 1, c), (r, c + 1)]
 
 
def total(xs: Sequence[float]) -> float:
    return sum(xs)
 
 
ints: tuple[int, ...] = (1, 2, 3)
floats: tuple[float, ...] = ints  # OK: tuples are covariant
total(ints)  # 6: a tuple is a Sequence
bad: tuple[int, int] = (1, 2, 3)  # ❌ type error: 3 items

from collections import deque
 
 
def sliding_puzzle(board: list[list[int]]) -> int:
    start = tuple(x for row in board for x in row)
    goal = (1, 2, 3, 4, 5, 0)
    moves = (  # neighbors of each index on a 2 x 3 board
        (1, 3), (0, 2, 4), (1, 5),
        (0, 4), (1, 3, 5), (2, 4),
    )
    seen = {start}
    q = deque([(start, 0)])
    while q:
        state, steps = q.popleft()
        if state == goal:
            return steps
        z = state.index(0)
        for j in moves[z]:
            nxt = list(state)  # tuples can't swap in place
            nxt[z], nxt[j] = nxt[j], nxt[z]
            key = tuple(nxt)  # back to a hashable state
            if key not in seen:
                seen.add(key)
                q.append((key, steps + 1))
    return -1
 
 
print(sliding_puzzle([[1, 2, 3], [4, 0, 5]]))  # 1
print(sliding_puzzle([[4, 1, 2], [5, 0, 3]]))  # 5
print(sliding_puzzle([[1, 2, 3], [5, 4, 0]]))  # -1

from collections import defaultdict
 
 
def shift_key(s: str) -> tuple[int, ...]:
    return tuple(
        (ord(b) - ord(a)) % 26 for a, b in zip(s, s[1:])
    )
 
 
words = "abc bcd acef xyz az ba a z".split()
groups: defaultdict[tuple[int, ...], list[str]]
groups = defaultdict(list)
for w in words:
    groups[shift_key(w)].append(w)
print(sorted(groups.values()))
# [['a', 'z'], ['abc', 'bcd', 'xyz'], ['acef'], ['az', 'ba']]
 
edges = [(1, 2), (2, 1), (3, 1)]
unique = {(min(u, v), max(u, v)) for u, v in edges}
print(sorted(unique))  # [(1, 2), (1, 3)]

import bisect
from operator import itemgetter
 
 
class TimeMap:
    def __init__(self) -> None:
        self.log: dict[str, list[tuple[int, str]]] = {}
 
    def set(self, key: str, value: str, t: int) -> None:
        self.log.setdefault(key, []).append((t, value))
 
    def get(self, key: str, t: int) -> str:
        pairs = self.log.get(key, [])  # times increase
        i = bisect.bisect_right(pairs, t, key=itemgetter(0))
        return pairs[i - 1][1] if i else ""
 
 
tm = TimeMap()
tm.set("foo", "bar", 1)
tm.set("foo", "baz", 4)
print(tm.get("foo", 3), tm.get("foo", 4))  # bar baz
print(repr(tm.get("foo", 0)))  # ''

type Interval = tuple[int, int]
 
 
def merge(ivs: list[Interval]) -> list[Interval]:
    out: list[Interval] = []
    for lo, hi in sorted(ivs):  # by start, then end
        if out and lo <= out[-1][1]:
            out[-1] = (out[-1][0], max(out[-1][1], hi))
        else:
            out.append((lo, hi))
    return out
 
 
print(merge([(8, 10), (1, 3), (2, 6), (15, 18)]))
# [(1, 6), (8, 10), (15, 18)]

from typing import NamedTuple
 
 
class Score(NamedTuple):
    name: str
    points: int
    time: float
 
 
rows = ["ann,90,31.5", "bo,95,40.2", "cy,90,29.8"]
scores = [
    Score(n, int(p), float(t))
    for n, p, t in (row.split(",") for row in rows)
]
board = sorted(scores, key=lambda s: (-s.points, s.time))
print([s.name for s in board])  # ['bo', 'cy', 'ann']
top = board[0]._replace(points=board[0].points + 5)
print(top)  # Score(name='bo', points=100, time=40.2)

from functools import cache
 
 
def can_split(nums: list[int], k: int) -> bool:
    total = sum(nums)
    if total % k:
        return False
    target = total // k
    items = sorted(nums, reverse=True)
 
    @cache
    def fill(i: int, buckets: tuple[int, ...]) -> bool:
        if i == len(items):
            return True
        for j, b in enumerate(buckets):
            if b + items[i] <= target:
                nxt = list(buckets)
                nxt[j] += items[i]
                # sorted: equivalent states share an entry
                if fill(i + 1, tuple(sorted(nxt))):
                    return True
        return False
 
    return fill(0, (0,) * k)
 
 
print(can_split([4, 3, 2, 3, 5, 2, 1], 4))  # True
print(can_split([2, 2, 2, 2, 3, 4, 5], 4))  # False