feat(benchmarks): Add auto-generated benchmark tables with tabulate

- Add benchmark data collection scripts (collect_benchmarks.py, collect_large_n.py)
- Add table generation script using tabulate for proper column widths
- Generate benchmark documentation with 127 problems, 24 large n comparisons
- Update README with ASCII benchmark table showing up to 66,000x speedups
- Include time and space complexity comparisons (Fast vs Slow)

Key features:
- Descriptive method names (e.g., "Top-down Memo" instead of "recursive")
- Human-readable time formatting (5.3s instead of 5268ms)
- Filtered entries with complete complexity data only
- Simplified verbose complexity strings

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: lufftw

README.md

@@ -65,21 +65,38 @@ quickselect     96.06ms         3/3  O(n) average time, O(1) space
 heap           107.34ms         3/3  O(n log k) time, O(k) space
 ```
 
-**See why algorithm complexity matters:**
+**Why algorithm choice matters — real data from 100+ problems:**
 
-```bash
-python runner/test_runner.py 0011_container --all --estimate
+```
+Benchmark Results (n = 5,000)
+┌──────────────────────┬────────────────────────┬─────────────────────┬───────────┬───────────────────┬────────────────────┐
+│ Problem              │ Fast                   │ Slow                │ Speedup   │ Time Complexity   │ Space Complexity   │
+├──────────────────────┼────────────────────────┼─────────────────────┼───────────┼───────────────────┼────────────────────┤
+│ 0010 Regex Matching  │ Top-down Memo 0.08ms   │ Bottom-up DP 5.3s   │ 66,000×   │ O(mn) vs O(mn)    │ O(m*n) vs O(m*n)   │
+├──────────────────────┼────────────────────────┼─────────────────────┼───────────┼───────────────────┼────────────────────┤
+│ 0044 Wildcard Match  │ Greedy Backtrack 1.4ms │ 2D DP Table 10.0s   │ 7,000×    │ O(mn) vs O(mn)    │ O(1) vs O(m*n)     │
+├──────────────────────┼────────────────────────┼─────────────────────┼───────────┼───────────────────┼────────────────────┤
+│ 0011 Container Water │ Two Pointers 0.75ms    │ Nested Loops 4.9s   │ 7,000×    │ O(n) vs O(n^2)    │ O(1) vs O(1)       │
+├──────────────────────┼────────────────────────┼─────────────────────┼───────────┼───────────────────┼────────────────────┤
+│ 0016 3Sum Closest    │ Two Ptr+Prune 1.1ms    │ Two Ptr Basic 1.4s  │ 1,000×    │ O(n²) vs O(n²)    │ O(1) vs O(1)       │
+├──────────────────────┼────────────────────────┼─────────────────────┼───────────┼───────────────────┼────────────────────┤
+│ 0001 Two Sum         │ Hash Map 0.66ms        │ Nested Loops 70.1ms │ 106×      │ O(n) vs O(n²)     │ O(n) vs O(1)       │
+├──────────────────────┼────────────────────────┼─────────────────────┼───────────┼───────────────────┼────────────────────┤
+│ 0055 Jump Game       │ Greedy 1.7ms           │ DP Array 10.9ms     │ 7×        │ O(n) vs O(n^2)    │ O(1) vs O(n)       │
+├──────────────────────┼────────────────────────┼─────────────────────┼───────────┼───────────────────┼────────────────────┤
+│ 0033 Search Rotated  │ Binary Search 0.48ms   │ Linear Scan 1.1ms   │ 2×        │ O(log n) vs O(n)  │ O(1) vs O(1)       │
+├──────────────────────┼────────────────────────┼─────────────────────┼───────────┼───────────────────┼────────────────────┤
+│ 0042 Trapping Rain   │ Two Pointers 1.8ms     │ Prefix Arrays 3.7ms │ 2×        │ O(n) vs O(n)      │ O(1) vs O(n)       │
+└──────────────────────┴────────────────────────┴─────────────────────┴───────────┴───────────────────┴────────────────────┘
 ```
 
-| n | O(n) Two Pointers | O(n²) Brute Force | Speedup |
-|--:|------------------:|------------------:|--------:|
-| 500 | 0.27ms | 554ms | **2,052x** |
-| 1000 | 0.52ms | 2,544ms | **4,892x** |
-| 5000 | 2.78ms | 68,291ms | **24,565x** |
+📊 [Full benchmark: 100+ problems, 300+ solutions →](docs/benchmarks.md)
 
-At n=5000, the O(n) algorithm finishes in **3ms** while O(n²) takes **68 seconds**.
+**Try it yourself:**
 
-> 📖 [More examples with interpretation guide →](docs/runner/README.md#examples-gallery)
+```bash
+python runner/test_runner.py 0011_container --all --estimate
+```
 
 **Auto-save failing cases for debugging:**
 
@@ -188,6 +205,7 @@ Each pattern provides Intuition + Templates. Start with intuition, use templates
 |:---------|:------------|
 | [Pattern Guides](docs/patterns/README.md) | All 25+ patterns with Intuition + Templates |
 | [Test Runner](docs/runner/README.md) | Testing, benchmarking, and validation |
+| [Benchmarks](docs/benchmarks.md) | 100+ problems compared: speedups up to 65,000x |
 
 ### Advanced
 

docs/benchmark_ascii_table.txt

@@ -0,0 +1,20 @@
+Benchmark Results (n = 5,000)
+┌──────────────────────┬────────────────────────┬─────────────────────┬───────────┬───────────────────┬────────────────────┐
+│ Problem              │ Fast                   │ Slow                │ Speedup   │ Time Complexity   │ Space Complexity   │
+├──────────────────────┼────────────────────────┼─────────────────────┼───────────┼───────────────────┼────────────────────┤
+│ 0010 Regex Matching  │ Top-down Memo 0.08ms   │ Bottom-up DP 5.3s   │ 66,000×   │ O(mn) vs O(mn)    │ O(m*n) vs O(m*n)   │
+├──────────────────────┼────────────────────────┼─────────────────────┼───────────┼───────────────────┼────────────────────┤
+│ 0044 Wildcard Match  │ Greedy Backtrack 1.4ms │ 2D DP Table 10.0s   │ 7,000×    │ O(mn) vs O(mn)    │ O(1) vs O(m*n)     │
+├──────────────────────┼────────────────────────┼─────────────────────┼───────────┼───────────────────┼────────────────────┤
+│ 0011 Container Water │ Two Pointers 0.75ms    │ Nested Loops 4.9s   │ 7,000×    │ O(n) vs O(n^2)    │ O(1) vs O(1)       │
+├──────────────────────┼────────────────────────┼─────────────────────┼───────────┼───────────────────┼────────────────────┤
+│ 0016 3Sum Closest    │ Two Ptr+Prune 1.1ms    │ Two Ptr Basic 1.4s  │ 1,000×    │ O(n²) vs O(n²)    │ O(1) vs O(1)       │
+├──────────────────────┼────────────────────────┼─────────────────────┼───────────┼───────────────────┼────────────────────┤
+│ 0001 Two Sum         │ Hash Map 0.66ms        │ Nested Loops 70.1ms │ 106×      │ O(n) vs O(n²)     │ O(n) vs O(1)       │
+├──────────────────────┼────────────────────────┼─────────────────────┼───────────┼───────────────────┼────────────────────┤
+│ 0055 Jump Game       │ Greedy 1.7ms           │ DP Array 10.9ms     │ 7×        │ O(n) vs O(n^2)    │ O(1) vs O(n)       │
+├──────────────────────┼────────────────────────┼─────────────────────┼───────────┼───────────────────┼────────────────────┤
+│ 0033 Search Rotated  │ Binary Search 0.48ms   │ Linear Scan 1.1ms   │ 2×        │ O(log n) vs O(n)  │ O(1) vs O(1)       │
+├──────────────────────┼────────────────────────┼─────────────────────┼───────────┼───────────────────┼────────────────────┤
+│ 0042 Trapping Rain   │ Two Pointers 1.8ms     │ Prefix Arrays 3.7ms │ 2×        │ O(n) vs O(n)      │ O(1) vs O(n)       │
+└──────────────────────┴────────────────────────┴─────────────────────┴───────────┴───────────────────┴────────────────────┘