Docs: Add Space column to all complexity tables

Standardize complexity tables to include Time, Space, and Notes columns:
- bisect.md, collections.md (all sections)
- list.md, dict.md, set.md, tuple.md, str.md
- frozenset.md, range.md, bytes.md, bool.md

Merged separate Time/Space sections into unified tables for consistency.

Co-Authored-By: Amp <amp@ampcode.com>

Author: heikkitoivonen

docs/builtins/bool.md

@@ -19,11 +19,11 @@ The `bool` type is a subclass of `int` representing truth values: `True` and `Fa
 
 ## Logical Operations
 
-| Operation | Time | Notes |
-|-----------|------|-------|
-| `x and y` | O(1) | Short-circuit: returns first falsy or last value |
-| `x or y` | O(1) | Short-circuit: returns first truthy or last value |
-| `not x` | O(1) | Logical negation |
+| Operation | Time | Space | Notes |
+|-----------|------|-------|-------|
+| `x and y` | O(1) | O(1) | Short-circuit: returns first falsy or last value |
+| `x or y` | O(1) | O(1) | Short-circuit: returns first truthy or last value |
+| `not x` | O(1) | O(1) | Logical negation |
 
 ### Short-circuit Evaluation
 

docs/builtins/bytes.md

@@ -2,91 +2,82 @@
 
 The `bytes` type is an immutable sequence of bytes, while `bytearray` is the mutable equivalent.
 
-## Time Complexity
+## Complexity Reference
 
 ### Bytes
 
-| Operation | Time | Notes |
-|-----------|------|-------|
-| `len()` | O(1) | Direct lookup |
-| `access[i]` | O(1) | Direct indexing |
-| `in` (membership) | O(n) | Linear search |
-| **Search** |||
-| `find(sub)` | O(n + m) worst for long strings, O(n*m) worst for pathological cases | n = bytes length, m = pattern length |
-| `rfind(sub)` | O(n*m) worst case | Search from right |
-| `index(sub)` | O(n) | Like find() but raises ValueError |
-| `rindex(sub)` | O(n*m) worst case | Like rfind() but raises ValueError |
-| `count(sub)` | O(n) | Count non-overlapping occurrences |
-| `startswith(prefix)` | O(m) | m = prefix length |
-| `endswith(suffix)` | O(m) | m = suffix length |
-| **Replace/Translate** |||
-| `replace(old, new)` | O(n) | Creates new bytes object |
-| `translate(table)` | O(n) | Single pass with table lookup |
-| `maketrans(from, to)` | O(k) | k = mapping size; static method |
-| `expandtabs(tabsize)` | O(n) | Replace tabs with spaces |
-| `removeprefix(prefix)` | O(n) | Returns slice if prefix matches (Python 3.9+) |
-| `removesuffix(suffix)` | O(n) | Returns slice if suffix matches (Python 3.9+) |
-| **Split/Join** |||
-| `split(sep)` | O(n) | Single pass |
-| `rsplit(sep)` | O(n) | Split from right |
-| `splitlines()` | O(n) | Split on line boundaries |
-| `partition(sep)` | O(n) | Split into 3-tuple at first sep |
-| `rpartition(sep)` | O(n) | Split into 3-tuple at last sep |
-| `join(iterable)` | O(n) | n = total output length |
-| **Case Conversion** |||
-| `upper()` | O(n) | ASCII uppercase |
-| `lower()` | O(n) | ASCII lowercase |
-| `capitalize()` | O(n) | Uppercase first, lowercase rest |
-| `title()` | O(n) | Titlecase words |
-| `swapcase()` | O(n) | Swap upper/lower |
-| **Stripping** |||
-| `strip(chars)` | O(n) | Remove from both ends |
-| `lstrip(chars)` | O(n) | Remove from left |
-| `rstrip(chars)` | O(n) | Remove from right |
-| **Padding/Alignment** |||
-| `center(width)` | O(n) | Pad both sides |
-| `ljust(width)` | O(n) | Pad right side |
-| `rjust(width)` | O(n) | Pad left side |
-| `zfill(width)` | O(n) | Pad with zeros |
-| **Predicates** |||
-| `isalnum()` | O(n) | Check alphanumeric |
-| `isalpha()` | O(n) | Check alphabetic |
-| `isascii()` | O(n) | Check ASCII (Python 3.7+) |
-| `isdigit()` | O(n) | Check digit chars |
-| `islower()` | O(n) | Check lowercase |
-| `isspace()` | O(n) | Check whitespace |
-| `istitle()` | O(n) | Check titlecase |
-| `isupper()` | O(n) | Check uppercase |
-| **Encoding** |||
-| `decode(encoding)` | O(n) | Convert to string |
-| `hex()` | O(n) | Convert to hex string |
-| `fromhex(string)` | O(n) | Create bytes from hex; class method |
+| Operation | Time | Space | Notes |
+|-----------|------|-------|-------|
+| `len()` | O(1) | O(1) | Direct lookup |
+| `access[i]` | O(1) | O(1) | Direct indexing |
+| `in` (membership) | O(n) | O(1) | Linear search |
+| **Search** ||||
+| `find(sub)` | O(n + m) avg | O(1) | n = bytes length, m = pattern length |
+| `rfind(sub)` | O(n*m) worst | O(1) | Search from right |
+| `index(sub)` | O(n) | O(1) | Like find() but raises ValueError |
+| `rindex(sub)` | O(n*m) worst | O(1) | Like rfind() but raises ValueError |
+| `count(sub)` | O(n) | O(1) | Count non-overlapping occurrences |
+| `startswith(prefix)` | O(m) | O(1) | m = prefix length |
+| `endswith(suffix)` | O(m) | O(1) | m = suffix length |
+| **Replace/Translate** ||||
+| `replace(old, new)` | O(n) | O(n) | Creates new bytes object |
+| `translate(table)` | O(n) | O(n) | Single pass with table lookup |
+| `maketrans(from, to)` | O(k) | O(k) | k = mapping size; static method |
+| `expandtabs(tabsize)` | O(n) | O(n) | Replace tabs with spaces |
+| `removeprefix(prefix)` | O(n) | O(n) | Returns slice if prefix matches (Python 3.9+) |
+| `removesuffix(suffix)` | O(n) | O(n) | Returns slice if suffix matches (Python 3.9+) |
+| **Split/Join** ||||
+| `split(sep)` | O(n) | O(n) | Single pass |
+| `rsplit(sep)` | O(n) | O(n) | Split from right |
+| `splitlines()` | O(n) | O(n) | Split on line boundaries |
+| `partition(sep)` | O(n) | O(n) | Split into 3-tuple at first sep |
+| `rpartition(sep)` | O(n) | O(n) | Split into 3-tuple at last sep |
+| `join(iterable)` | O(n) | O(n) | n = total output length |
+| **Case Conversion** ||||
+| `upper()` | O(n) | O(n) | ASCII uppercase |
+| `lower()` | O(n) | O(n) | ASCII lowercase |
+| `capitalize()` | O(n) | O(n) | Uppercase first, lowercase rest |
+| `title()` | O(n) | O(n) | Titlecase words |
+| `swapcase()` | O(n) | O(n) | Swap upper/lower |
+| **Stripping** ||||
+| `strip(chars)` | O(n) | O(n) | Remove from both ends |
+| `lstrip(chars)` | O(n) | O(n) | Remove from left |
+| `rstrip(chars)` | O(n) | O(n) | Remove from right |
+| **Padding/Alignment** ||||
+| `center(width)` | O(n) | O(n) | Pad both sides |
+| `ljust(width)` | O(n) | O(n) | Pad right side |
+| `rjust(width)` | O(n) | O(n) | Pad left side |
+| `zfill(width)` | O(n) | O(n) | Pad with zeros |
+| **Predicates** ||||
+| `isalnum()` | O(n) | O(1) | Check alphanumeric |
+| `isalpha()` | O(n) | O(1) | Check alphabetic |
+| `isascii()` | O(n) | O(1) | Check ASCII (Python 3.7+) |
+| `isdigit()` | O(n) | O(1) | Check digit chars |
+| `islower()` | O(n) | O(1) | Check lowercase |
+| `isspace()` | O(n) | O(1) | Check whitespace |
+| `istitle()` | O(n) | O(1) | Check titlecase |
+| `isupper()` | O(n) | O(1) | Check uppercase |
+| **Encoding** ||||
+| `decode(encoding)` | O(n) | O(n) | Convert to string |
+| `hex()` | O(n) | O(n) | Convert to hex string |
+| `fromhex(string)` | O(n) | O(n) | Create bytes from hex; class method |
 
 *Note: bytes is immutable, so operations that appear to modify return new objects (O(n) space).*
 
 ### Bytearray
 
-| Operation | Time | Notes |
-|-----------|------|-------|
-| `append(x)` | O(1)* | Amortized, may resize |
-| `insert(i, x)` | O(n) | Shift elements |
-| `extend(iterable)` | O(k) | k = length |
-| `pop()` | O(1) | Remove last |
-| `pop(0)` | O(n) | Shift remaining |
-| `remove(x)` | O(n) | Search and remove |
-| `clear()` | O(n) | Deallocate |
-| `copy()` | O(n) | Shallow copy |
-| `reverse()` | O(n) | Reverse in-place |
-| `resize(n)` | O(n) | Resize to n bytes; may truncate or zero-fill |
-
-## Space Complexity
-
-| Operation | Space |
-|-----------|-------|
-| `bytes()` copy | O(n) |
-| `bytearray()` operations | O(1) amortized |
-| `decode()` | O(n) for string |
-| `join()` | O(n) result |
+| Operation | Time | Space | Notes |
+|-----------|------|-------|-------|
+| `append(x)` | O(1)* | O(1) | Amortized, may resize |
+| `insert(i, x)` | O(n) | O(1) | Shift elements |
+| `extend(iterable)` | O(k) | O(k) | k = length |
+| `pop()` | O(1) | O(1) | Remove last |
+| `pop(0)` | O(n) | O(1) | Shift remaining |
+| `remove(x)` | O(n) | O(1) | Search and remove |
+| `clear()` | O(n) | O(1) | Deallocate |
+| `copy()` | O(n) | O(n) | Shallow copy |
+| `reverse()` | O(n) | O(1) | Reverse in-place |
+| `resize(n)` | O(n) | O(1) | Resize to n bytes; may truncate or zero-fill |
 
 ## Implementation Details
 

docs/builtins/dict.md

@@ -2,37 +2,29 @@
 
 The `dict` type is a mutable mapping that stores key-value pairs. It's implemented as a hash table in CPython.
 
-## Time Complexity
-
-| Operation | Time | Notes |
-|-----------|------|-------|
-| `len()` | O(1) | Direct count |
-| `access[key]` | O(1) avg, O(n) worst | Hash lookup; worst case with collisions |
-| `set[key] = value` | O(1) amortized | Hash insertion; may trigger resize |
-| `del[key]` | O(1) avg, O(n) worst | Hash deletion |
-| `key in dict` | O(1) avg, O(n) worst | Hash lookup |
-| `get(key)` | O(1) avg, O(n) worst | Hash lookup |
-| `pop(key)` | O(1) avg, O(n) worst | Hash deletion |
-| `clear()` | O(n) | Must deallocate all entries |
-| `keys()` | O(1) | View object (O(n) to iterate) |
-| `values()` | O(1) | View object (O(n) to iterate) |
-| `items()` | O(1) | View object (O(n) to iterate) |
-| `copy()` | O(n) | Shallow copy of all pairs |
-| `update(other)` | O(k) | k = len(other), amortized |
-| `setdefault(key, val)` | O(1) avg | Hash lookup + insert |
-| `fromkeys(keys)` | O(k) | k = len(keys) |
-| `popitem()` | O(1) | Remove last inserted pair (LIFO since 3.7) |
+## Complexity Reference
+
+| Operation | Time | Space | Notes |
+|-----------|------|-------|-------|
+| `len()` | O(1) | O(1) | Direct count |
+| `access[key]` | O(1) avg, O(n) worst | O(1) | Hash lookup; worst case with collisions |
+| `set[key] = value` | O(1) amortized | O(1) | Hash insertion; may trigger resize |
+| `del[key]` | O(1) avg, O(n) worst | O(1) | Hash deletion |
+| `key in dict` | O(1) avg, O(n) worst | O(1) | Hash lookup |
+| `get(key)` | O(1) avg, O(n) worst | O(1) | Hash lookup |
+| `pop(key)` | O(1) avg, O(n) worst | O(1) | Hash deletion |
+| `clear()` | O(n) | O(1) | Must deallocate all entries |
+| `keys()` | O(1) | O(1) | View object (O(n) to iterate) |
+| `values()` | O(1) | O(1) | View object (O(n) to iterate) |
+| `items()` | O(1) | O(1) | View object (O(n) to iterate) |
+| `copy()` | O(n) | O(n) | Shallow copy of all pairs |
+| `update(other)` | O(k) | O(1) | k = len(other), amortized; modifies in place |
+| `setdefault(key, val)` | O(1) avg | O(1) | Hash lookup + insert |
+| `fromkeys(keys)` | O(k) | O(k) | k = len(keys) |
+| `popitem()` | O(1) | O(1) | Remove last inserted pair (LIFO since 3.7) |
 
 *Note: O(1) average case assumes good hash distribution. Worst case O(n) occurs with pathological hash collisions, which is rare with Python's randomized hashing.*
 
-## Space Complexity
-
-| Operation | Space |
-|-----------|-------|
-| `copy()` | O(n) |
-| `update()` | O(1) (modifies in place) |
-| General storage | O(n) for n key-value pairs |
-
 ## Implementation Details
 
 ### Hash Table Structure

docs/builtins/frozenset.md

@@ -2,32 +2,23 @@
 
 The `frozenset` type is an immutable set that can be hashed and used as a dictionary key or set member.
 
-## Time Complexity
-
-| Operation | Time | Notes |
-|-----------|------|-------|
-| `frozenset(iterable)` | O(n) | Create from iterable |
-| `len()` | O(1) | Direct count |
-| `in` (membership) | O(1) avg, O(n) worst | Hash lookup; worst case with hash collisions |
-| `union(\|)` | O(n+m) | Combine sets |
-| `intersection(&)` | O(min(n,m)) | Common elements |
-| `difference(-)` | O(n) | Elements in first |
-| `symmetric_diff(^)` | O(n+m) | Exclusive elements |
-| `issubset()` | O(n) | Check containment |
-| `issuperset()` | O(m) | Check containment |
-| `isdisjoint()` | O(min(n,m)) | Check overlap |
-| `copy()` | O(1) | Shallow copy |
-| `hash()` | O(n) first call, O(1) cached | Hash value computed once, then cached |
-| `frozenset(set)` | O(n) | Convert from set |
-
-## Space Complexity
-
-| Operation | Space |
-|-----------|-------|
-| Creation | O(n) for n elements |
-| Copy | O(1) (same object) |
-| Union | O(n+m) for result |
-| Intersection | O(min(n,m)) for result |
+## Complexity Reference
+
+| Operation | Time | Space | Notes |
+|-----------|------|-------|-------|
+| `frozenset(iterable)` | O(n) | O(n) | Create from iterable |
+| `len()` | O(1) | O(1) | Direct count |
+| `in` (membership) | O(1) avg, O(n) worst | O(1) | Hash lookup; worst case with hash collisions |
+| `union(\|)` | O(n+m) | O(n+m) | Combine sets |
+| `intersection(&)` | O(min(n,m)) | O(min(n,m)) | Common elements |
+| `difference(-)` | O(n) | O(n) | Elements in first |
+| `symmetric_difference(^)` | O(n+m) | O(n+m) | Exclusive elements |
+| `issubset()` | O(n) | O(1) | Check containment |
+| `issuperset()` | O(m) | O(1) | Check containment |
+| `isdisjoint()` | O(min(n,m)) | O(1) | Check overlap |
+| `copy()` | O(1) | O(1) | Returns same object (immutable) |
+| `hash()` | O(n) first call, O(1) cached | O(1) | Hash value computed once, then cached |
+| `frozenset(set)` | O(n) | O(n) | Convert from set |
 
 ## Implementation Details
 

docs/builtins/list.md

@@ -2,39 +2,29 @@
 
 The `list` type is a mutable, ordered sequence. It's implemented as a dynamic array in CPython.
 
-## Time Complexity
-
-| Operation | Time | Notes |
-|-----------|------|-------|
-| `len()` | O(1) | Direct lookup |
-| `access[i]` | O(1) | Direct indexing |
-| `append(x)` | O(1) amortized | May resize; worst case O(n) when reallocation needed |
-| `insert(0, x)` | O(n) | Must shift all elements |
-| `insert(i, x)` | O(n-i) | Shift elements from index i |
-| `remove(x)` | O(n) | Must search and shift |
-| `pop()` | O(1) | Remove last element |
-| `pop(0)` | O(n) | Shift remaining elements |
-| `pop(i)` | O(n-i) | Shift elements after i |
-| `clear()` | O(n) | Deallocate memory |
-| `index(x)` | O(n) | Linear search |
-| `count(x)` | O(n) | Linear scan |
-| `sort()` | O(n log n) avg/worst, O(n) best | Timsort/Powersort; adaptive for partially sorted data |
-| `reverse()` | O(n) | In-place reversal |
-| `copy()` | O(n) | Shallow copy |
-| `extend(iterable)` | O(k) | k = length of iterable |
-| `in` (membership) | O(n) | Linear search |
-| `x + y` (concatenation) | O(m+n) | m, n are lengths |
-| `[::2]` (slicing) | O(k) | k = slice length |
-
-## Space Complexity
-
-| Operation | Space |
-|-----------|-------|
-| `append()` | O(1) amortized; O(n) worst case on resize |
-| `extend()` | O(k); may trigger O(n) resize |
-| `sort()` | O(n) auxiliary |
-| `copy()` | O(n) |
-| `slice` | O(k) for new list |
+## Complexity Reference
+
+| Operation | Time | Space | Notes |
+|-----------|------|-------|-------|
+| `len()` | O(1) | O(1) | Direct lookup |
+| `access[i]` | O(1) | O(1) | Direct indexing |
+| `append(x)` | O(1) amortized | O(1) amortized | May resize; worst case O(n) when reallocation needed |
+| `insert(0, x)` | O(n) | O(1) | Must shift all elements |
+| `insert(i, x)` | O(n-i) | O(1) | Shift elements from index i |
+| `remove(x)` | O(n) | O(1) | Must search and shift |
+| `pop()` | O(1) | O(1) | Remove last element |
+| `pop(0)` | O(n) | O(1) | Shift remaining elements |
+| `pop(i)` | O(n-i) | O(1) | Shift elements after i |
+| `clear()` | O(n) | O(1) | Deallocate memory |
+| `index(x)` | O(n) | O(1) | Linear search |
+| `count(x)` | O(n) | O(1) | Linear scan |
+| `sort()` | O(n log n) avg/worst, O(n) best | O(n) | Timsort/Powersort; adaptive for partially sorted data |
+| `reverse()` | O(n) | O(1) | In-place reversal |
+| `copy()` | O(n) | O(n) | Shallow copy |
+| `extend(iterable)` | O(k) | O(k) | k = length of iterable; may trigger O(n) resize |
+| `in` (membership) | O(n) | O(1) | Linear search |
+| `x + y` (concatenation) | O(m+n) | O(m+n) | m, n are lengths |
+| `[::2]` (slicing) | O(k) | O(k) | k = slice length |
 
 ## Implementation Details
 

docs/builtins/range.md

@@ -2,30 +2,21 @@
 
 The `range` type is an immutable sequence of numbers used for iteration. It generates values lazily without storing all numbers in memory.
 
-## Time Complexity
-
-| Operation | Time | Notes |
-|-----------|------|-------|
-| `range(stop)` | O(1) | Create range object |
-| `range(start, stop)` | O(1) | Create range object |
-| `range(start, stop, step)` | O(1) | Create range object |
-| `len()` | O(1) | Calculated, not stored |
-| `access[i]` | O(1) | Direct calculation |
-| `in` (membership) | O(1) | Math check, not scan |
-| `index(value)` | O(1) | Solve equation |
-| `count(value)` | O(1) | Single check |
-| `iteration` | O(n) | n = number of items |
-| `reversed()` | O(1) | Iterator, not materialized |
-| `list(range(...))` | O(n) | Convert to list |
-
-## Space Complexity
-
-| Operation | Space | Notes |
-|-----------|-------|-------|
-| Range object | O(1) | Fixed overhead (stores start, stop, step) |
-| Iteration | O(1) | No buffering, yields values on demand |
-| `list()` conversion | O(n) | Creates list |
-| `reversed()` iterator | O(1) | No materialization |
+## Complexity Reference
+
+| Operation | Time | Space | Notes |
+|-----------|------|-------|-------|
+| `range(stop)` | O(1) | O(1) | Create range object |
+| `range(start, stop)` | O(1) | O(1) | Create range object |
+| `range(start, stop, step)` | O(1) | O(1) | Create range object |
+| `len()` | O(1) | O(1) | Calculated, not stored |
+| `access[i]` | O(1) | O(1) | Direct calculation |
+| `in` (membership) | O(1) | O(1) | Math check, not scan |
+| `index(value)` | O(1) | O(1) | Solve equation |
+| `count(value)` | O(1) | O(1) | Single check |
+| `iteration` | O(n) | O(1) | n = number of items; yields on demand |
+| `reversed()` | O(1) | O(1) | Iterator, not materialized |
+| `list(range(...))` | O(n) | O(n) | Convert to list |
 
 ## Implementation Details