chore: initial sync

challenges.py

@@ -0,0 +1,892 @@
+"""
+challenges.py — Challenges de programación de nivel production.
+
+Inspirados en funciones reales del fn_registry. Prueban:
+- Programación funcional (pipe, compose, curry, combinators)
+- Procesamiento de datos (coercion, parsing, normalization)
+- Algoritmos no triviales (árboles, grafos, scheduling)
+- Patterns del mundo real (retry, rate limiting, schema validation)
+"""
+
+from eval_runner import Challenge
+
+# ══════════════════════════════════════════════════════════════
+#  FUNCTIONAL PROGRAMMING
+# ══════════════════════════════════════════════════════════════
+
+FUNCTIONAL = [
+    Challenge(
+        id="fn_pipe",
+        name="Pipe with error propagation",
+        category="functional",
+        difficulty="medium",
+        prompt="""Write a Python function:
+
+def pipe_safe(value, *fns):
+    \"\"\"Pipe a value through functions left-to-right. If any function raises,
+    return a tuple (None, error_string). On success return (result, None).\"\"\"
+
+Example:
+    pipe_safe(5, lambda x: x*2, lambda x: x+1) == (11, None)
+    pipe_safe(0, lambda x: 10/x) == (None, "division by zero")  # or similar
+""",
+        test_code="""
+# Success cases
+assert pipe_safe(5, lambda x: x*2, lambda x: x+1) == (11, None)
+assert pipe_safe("hello", str.upper, lambda s: s + "!") == ("HELLO!", None)
+assert pipe_safe(42) == (42, None)  # no functions
+assert pipe_safe([3,1,2], sorted, lambda x: x[0]) == (1, None)
+
+# Error propagation
+result, err = pipe_safe(0, lambda x: 10/x)
+assert result is None
+assert err is not None and "division" in err.lower()
+
+result, err = pipe_safe("abc", lambda x: x*2, int)
+assert result is None
+assert err is not None
+
+print("PASS: pipe_safe")
+""",
+    ),
+
+    Challenge(
+        id="fn_group_by_multi",
+        name="Group by with transform",
+        category="functional",
+        difficulty="medium",
+        prompt="""Write a Python function:
+
+def group_by_transform(xs: list, key_fn, value_fn=None) -> dict:
+    \"\"\"Group elements by key_fn. Optionally transform values with value_fn.
+    If value_fn is None, store raw elements. Preserves insertion order within groups.\"\"\"
+
+Example:
+    group_by_transform(["hello", "hi", "bye"], lambda s: s[0])
+    # => {"h": ["hello", "hi"], "b": ["bye"]}
+
+    group_by_transform(["hello", "hi", "bye"], lambda s: s[0], str.upper)
+    # => {"h": ["HELLO", "HI"], "b": ["BYE"]}
+""",
+        test_code="""
+# Basic grouping
+r = group_by_transform(["hello", "hi", "bye"], lambda s: s[0])
+assert r == {"h": ["hello", "hi"], "b": ["bye"]}
+
+# With value transform
+r = group_by_transform(["hello", "hi", "bye"], lambda s: s[0], str.upper)
+assert r == {"h": ["HELLO", "HI"], "b": ["BYE"]}
+
+# Numbers
+r = group_by_transform([1,2,3,4,5,6], lambda x: x % 2, lambda x: x**2)
+assert r == {1: [1, 9, 25], 0: [4, 16, 36]}
+
+# Empty
+assert group_by_transform([], lambda x: x) == {}
+
+# Single element
+assert group_by_transform([42], lambda x: "k") == {"k": [42]}
+
+print("PASS: group_by_transform")
+""",
+    ),
+
+    Challenge(
+        id="fn_memoize",
+        name="Memoize decorator with max size",
+        category="functional",
+        difficulty="hard",
+        prompt="""Write a Python function:
+
+def memoize(max_size: int = 128):
+    \"\"\"Decorator that memoizes function results. When cache exceeds max_size,
+    evict the oldest entry (FIFO). The key is (args, tuple(sorted(kwargs.items()))).
+    Must work with both positional and keyword arguments.\"\"\"
+
+Usage:
+    @memoize(max_size=3)
+    def add(a, b):
+        return a + b
+""",
+        test_code="""
+call_count = 0
+
+@memoize(max_size=3)
+def expensive(x, y=0):
+    global call_count
+    call_count += 1
+    return x + y
+
+# First call — computes
+call_count = 0
+assert expensive(1, 2) == 3
+assert call_count == 1
+
+# Cached — no recompute
+assert expensive(1, 2) == 3
+assert call_count == 1
+
+# Different args
+assert expensive(3, 4) == 7
+assert call_count == 2
+
+# Kwargs
+assert expensive(1, y=2) == 3
+assert call_count == 2  # same as (1, 2) via kwargs
+
+# Fill cache to max_size=3
+assert expensive(10) == 10   # call 3
+assert expensive(20) == 20   # call 4, evicts (1,2)
+assert call_count == 4
+
+# (1,2) was evicted, must recompute
+assert expensive(1, 2) == 3
+assert call_count == 5
+
+print("PASS: memoize")
+""",
+        max_tokens=1500,
+    ),
+
+    Challenge(
+        id="fn_compose_async",
+        name="Partition with multiple predicates",
+        category="functional",
+        difficulty="medium",
+        prompt="""Write a Python function:
+
+def multi_partition(xs: list, *predicates) -> list[list]:
+    \"\"\"Partition a list into N+1 buckets where N is the number of predicates.
+    Each element goes into the bucket of the FIRST predicate it satisfies.
+    Elements matching no predicate go into the last bucket.
+    Returns list of N+1 lists. Does not mutate input.\"\"\"
+
+Example:
+    multi_partition([1,2,3,4,5,6,7,8,9,10],
+                    lambda x: x % 3 == 0,
+                    lambda x: x % 2 == 0)
+    # => [[3,6,9], [2,4,8,10], [1,5,7]]
+    # 6 goes to first bucket (div by 3) even though also div by 2
+""",
+        test_code="""
+# Basic
+r = multi_partition([1,2,3,4,5,6,7,8,9,10], lambda x: x%3==0, lambda x: x%2==0)
+assert r == [[3,6,9], [2,4,8,10], [1,5,7]], f"got {r}"
+
+# No predicates — everything in remainder
+assert multi_partition([1,2,3]) == [[1,2,3]]
+
+# One predicate
+r = multi_partition(["a","bb","ccc"], lambda s: len(s) > 1)
+assert r == [["bb","ccc"], ["a"]]
+
+# All match first
+r = multi_partition([2,4,6], lambda x: x%2==0, lambda x: x>0)
+assert r == [[2,4,6], [], []]
+
+# Empty
+r = multi_partition([], lambda x: True)
+assert r == [[], []]
+
+print("PASS: multi_partition")
+""",
+    ),
+]
+
+# ══════════════════════════════════════════════════════════════
+#  DATA PROCESSING
+# ══════════════════════════════════════════════════════════════
+
+DATA_PROCESSING = [
+    Challenge(
+        id="dp_coerce",
+        name="Type coercion with schema",
+        category="data_processing",
+        difficulty="hard",
+        prompt="""Write a Python function:
+
+def coerce_types(data: dict, schema: dict[str, str]) -> tuple[dict, list[str]]:
+    \"\"\"Coerce dict values to types specified in schema. Never mutate original.
+
+    Schema maps field names to type strings: "int", "float", "str", "bool", "list[str]".
+
+    Rules:
+    - str → int: parse via float first (handle "3.0" → 3), warn if lossy ("3.7" → 3)
+    - str → float: standard float()
+    - str → bool: "true/1/yes" → True, "false/0/no" → False (case-insensitive)
+    - str → list[str]: split by "," and strip whitespace from each item
+    - Fields not in schema: pass through unchanged
+    - Fields in schema but not in data: skip
+    - Failed coercion: keep original value, add warning string to list
+
+    Returns (new_dict, warnings_list).\"\"\"
+""",
+        test_code="""
+# Basic coercions
+d, w = coerce_types({"age": "25", "score": "3.14", "active": "yes"}, {"age": "int", "score": "float", "active": "bool"})
+assert d == {"age": 25, "score": 3.14, "active": True}, f"got {d}"
+assert w == []
+
+# Lossy int coercion
+d, w = coerce_types({"x": "3.7"}, {"x": "int"})
+assert d["x"] == 3
+assert len(w) == 1 and "lossy" in w[0].lower() or "3.7" in w[0]
+
+# Bool variants
+d, _ = coerce_types({"a": "TRUE", "b": "0", "c": "no"}, {"a": "bool", "b": "bool", "c": "bool"})
+assert d == {"a": True, "b": False, "c": False}
+
+# list[str]
+d, _ = coerce_types({"tags": "a, b , c"}, {"tags": "list[str]"})
+assert d == {"tags": ["a", "b", "c"]}
+
+# Pass through unknown fields
+d, _ = coerce_types({"name": "test", "age": "5"}, {"age": "int"})
+assert d == {"name": "test", "age": 5}
+
+# Failed coercion
+d, w = coerce_types({"x": "not_a_number"}, {"x": "int"})
+assert d["x"] == "not_a_number"  # kept original
+assert len(w) == 1
+
+# No mutation
+original = {"x": "5"}
+d, _ = coerce_types(original, {"x": "int"})
+assert original["x"] == "5"
+assert d["x"] == 5
+
+print("PASS: coerce_types")
+""",
+        max_tokens=2048,
+    ),
+
+    Challenge(
+        id="dp_frontmatter",
+        name="Extract YAML frontmatter",
+        category="data_processing",
+        difficulty="medium",
+        prompt="""Write a Python function:
+
+def extract_frontmatter(content: str) -> tuple[str, dict | None]:
+    \"\"\"Extract YAML-like frontmatter delimited by '---' from start of markdown.
+
+    Frontmatter format:
+    ---
+    key: value
+    another: something
+    ---
+
+    Rest of content here.
+
+    Parse simple key:value pairs (no nested YAML needed). Values are always strings.
+    Do NOT use the yaml library.
+
+    Returns (content_without_frontmatter, parsed_dict_or_None).
+    If no frontmatter found, return (original_content, None).\"\"\"
+""",
+        test_code="""
+# Basic frontmatter
+content = "---\\nname: test\\nversion: 1.0\\n---\\n\\nHello world"
+body, meta = extract_frontmatter(content)
+assert meta == {"name": "test", "version": "1.0"}, f"got {meta}"
+assert body.strip() == "Hello world"
+
+# No frontmatter
+body, meta = extract_frontmatter("Just text")
+assert meta is None
+assert body == "Just text"
+
+# Empty frontmatter
+body, meta = extract_frontmatter("---\\n---\\nContent")
+assert meta == {} or meta is not None
+assert "Content" in body
+
+# Values with colons
+body, meta = extract_frontmatter("---\\nurl: http://example.com\\n---\\nBody")
+assert meta["url"] == "http://example.com"
+
+# Frontmatter must be at start
+body, meta = extract_frontmatter("Some text\\n---\\nkey: val\\n---")
+assert meta is None
+
+print("PASS: extract_frontmatter")
+""",
+    ),
+
+    Challenge(
+        id="dp_json_extract",
+        name="Extract JSON from LLM response",
+        category="data_processing",
+        difficulty="hard",
+        prompt="""Write a Python function:
+
+def extract_json_from_llm(content: str) -> dict:
+    \"\"\"Extract and parse JSON from messy LLM responses.
+
+    Must handle:
+    1. JSON inside ```json ... ``` code blocks
+    2. JSON inside ``` ... ``` blocks (no language tag)
+    3. Raw JSON with surrounding text
+    4. Trailing commas: {"a": 1,} or [1, 2,]
+    5. Python None instead of null
+    6. Single-quoted strings converted to double quotes
+
+    Returns parsed dict. Returns empty dict {} on failure.
+    Use only stdlib (json, re).\"\"\"
+""",
+        test_code="""
+import json
+
+# Clean JSON block
+assert extract_json_from_llm('```json\\n{"name": "test"}\\n```') == {"name": "test"}
+
+# Block without language tag
+assert extract_json_from_llm('```\\n{"x": 1}\\n```') == {"x": 1}
+
+# JSON with surrounding text
+r = extract_json_from_llm('Here is the result: {"count": 42} hope that helps!')
+assert r == {"count": 42}
+
+# Trailing commas
+assert extract_json_from_llm('{"a": 1, "b": 2,}') == {"a": 1, "b": 2}
+assert extract_json_from_llm('[1, 2, 3,]') == {} or extract_json_from_llm('{"items": [1,2,]}') == {"items": [1, 2]}
+
+# Python None → null
+assert extract_json_from_llm('{"value": None}') == {"value": None}
+
+# Garbage input
+assert extract_json_from_llm("no json here at all") == {}
+assert extract_json_from_llm("") == {}
+
+print("PASS: extract_json_from_llm")
+""",
+        max_tokens=1500,
+    ),
+
+    Challenge(
+        id="dp_smart_split",
+        name="Smart text splitter with token budget",
+        category="data_processing",
+        difficulty="hard",
+        prompt="""Write a Python function:
+
+def smart_split(text: str, max_chars: int = 500, overlap: int = 50) -> list[str]:
+    \"\"\"Split text into chunks respecting max_chars with overlap between chunks.
+
+    Rules:
+    - Split at paragraph boundaries (double newline) when possible
+    - If a single paragraph exceeds max_chars, split at sentence boundaries (. ! ?)
+    - If a single sentence exceeds max_chars, hard-cut at max_chars
+    - Each chunk (except the first) starts with the last `overlap` characters of the previous chunk
+    - Strip leading/trailing whitespace from each chunk
+    - Never return empty chunks
+
+    Returns list of string chunks.\"\"\"
+""",
+        test_code="""
+# Simple paragraphs within budget
+text = "First paragraph.\\n\\nSecond paragraph.\\n\\nThird paragraph."
+chunks = smart_split(text, max_chars=100)
+assert len(chunks) == 1
+assert text.strip() in chunks[0]
+
+# Force split between paragraphs
+text = "A" * 100 + "\\n\\n" + "B" * 100
+chunks = smart_split(text, max_chars=120, overlap=10)
+assert len(chunks) >= 2
+assert "A" * 100 in chunks[0]
+assert "B" * 100 in chunks[-1]
+
+# Overlap present
+text = "Hello world this is text.\\n\\nAnother paragraph here."
+chunks = smart_split(text, max_chars=30, overlap=5)
+assert len(chunks) >= 2
+for c in chunks:
+    assert len(c.strip()) > 0  # no empty chunks
+
+# Very long single paragraph splits at sentence
+text = "Short sentence. " * 50  # ~850 chars
+chunks = smart_split(text, max_chars=200, overlap=20)
+assert all(len(c) <= 220 for c in chunks)  # max_chars + overlap tolerance
+
+# Hard cut when no sentence boundary
+text = "A" * 600
+chunks = smart_split(text, max_chars=200, overlap=20)
+assert len(chunks) >= 3
+assert all(len(c) <= 220 for c in chunks)
+
+# Empty/whitespace
+assert smart_split("") == [] or smart_split("") == [""]
+assert smart_split("   \\n\\n   ") == [] or len(smart_split("   \\n\\n   ")) <= 1
+
+print("PASS: smart_split")
+""",
+        max_tokens=2048,
+    ),
+]
+
+# ══════════════════════════════════════════════════════════════
+#  ALGORITHMS
+# ══════════════════════════════════════════════════════════════
+
+ALGORITHMS = [
+    Challenge(
+        id="alg_topo_sort",
+        name="Topological sort with cycle detection",
+        category="algorithm",
+        difficulty="hard",
+        prompt="""Write a Python function:
+
+def topo_sort(graph: dict[str, list[str]]) -> tuple[list[str], bool]:
+    \"\"\"Topological sort of a directed acyclic graph using Kahn's algorithm.
+
+    graph is adjacency list: {"a": ["b", "c"]} means a → b, a → c.
+    Nodes with no edges should also be included.
+
+    Returns (sorted_list, has_cycle).
+    - If no cycle: (topologically_sorted_nodes, False)
+    - If cycle detected: (partial_result, True)
+
+    When multiple valid orderings exist, prefer lexicographic order.\"\"\"
+""",
+        test_code="""
+# Simple DAG
+order, cycle = topo_sort({"a": ["b", "c"], "b": ["d"], "c": ["d"], "d": []})
+assert not cycle
+assert order.index("a") < order.index("b")
+assert order.index("a") < order.index("c")
+assert order.index("b") < order.index("d")
+assert order.index("c") < order.index("d")
+
+# Lexicographic preference
+order, cycle = topo_sort({"c": [], "b": [], "a": []})
+assert not cycle
+assert order == ["a", "b", "c"]
+
+# Cycle detection
+_, cycle = topo_sort({"a": ["b"], "b": ["c"], "c": ["a"]})
+assert cycle
+
+# Single node
+order, cycle = topo_sort({"x": []})
+assert order == ["x"]
+assert not cycle
+
+# Empty graph
+order, cycle = topo_sort({})
+assert order == []
+assert not cycle
+
+# Linear chain
+order, cycle = topo_sort({"a": ["b"], "b": ["c"], "c": []})
+assert order == ["a", "b", "c"]
+assert not cycle
+
+print("PASS: topo_sort")
+""",
+    ),
+
+    Challenge(
+        id="alg_interval_merge",
+        name="Interval scheduler with priorities",
+        category="algorithm",
+        difficulty="hard",
+        prompt="""Write a Python function:
+
+def schedule_intervals(intervals: list[dict]) -> list[dict]:
+    \"\"\"Schedule non-overlapping intervals maximizing total priority.
+
+    Each interval is {"id": str, "start": int, "end": int, "priority": int}.
+    Intervals are half-open: [start, end). Two intervals [1,3) and [3,5) do NOT overlap.
+
+    Use weighted interval scheduling (dynamic programming).
+    Returns list of selected intervals sorted by start time.\"\"\"
+""",
+        test_code="""
+# Basic: pick higher priority
+result = schedule_intervals([
+    {"id": "a", "start": 0, "end": 3, "priority": 2},
+    {"id": "b", "start": 1, "end": 4, "priority": 5},
+    {"id": "c", "start": 3, "end": 6, "priority": 3},
+])
+ids = [r["id"] for r in result]
+assert "b" in ids  # highest single priority
+# b conflicts with a and c's start, so either [b] (5) or [a,c] (5) is valid
+total = sum(r["priority"] for r in result)
+assert total == 5, f"got total={total}"
+
+# Non-overlapping, take all
+result = schedule_intervals([
+    {"id": "a", "start": 0, "end": 2, "priority": 3},
+    {"id": "b", "start": 2, "end": 4, "priority": 3},
+    {"id": "c", "start": 4, "end": 6, "priority": 3},
+])
+assert len(result) == 3
+assert sum(r["priority"] for r in result) == 9
+
+# Empty
+assert schedule_intervals([]) == []
+
+# Single
+result = schedule_intervals([{"id": "x", "start": 0, "end": 10, "priority": 7}])
+assert len(result) == 1 and result[0]["id"] == "x"
+
+# Prefer two small over one big
+result = schedule_intervals([
+    {"id": "big", "start": 0, "end": 10, "priority": 5},
+    {"id": "s1", "start": 0, "end": 5, "priority": 3},
+    {"id": "s2", "start": 5, "end": 10, "priority": 3},
+])
+total = sum(r["priority"] for r in result)
+assert total == 6  # s1 + s2 beats big
+
+# Result sorted by start
+for i in range(len(result) - 1):
+    assert result[i]["start"] <= result[i+1]["start"]
+
+print("PASS: schedule_intervals")
+""",
+        max_tokens=2048,
+    ),
+
+    Challenge(
+        id="alg_tree_ops",
+        name="Tree operations suite",
+        category="algorithm",
+        difficulty="expert",
+        prompt="""Write three Python functions for tree manipulation:
+
+1. def flatten_tree(tree: dict) -> list[dict]:
+   \"\"\"Flatten nested tree to list. Each node is a dict with optional 'children' key.
+   DFS pre-order. Remove 'children' key from output nodes. Deep copy nodes.\"\"\"
+
+2. def find_path(tree: dict, target_id: str) -> list[str] | None:
+   \"\"\"Find path from root to node with given 'id' field. Returns list of ids
+   from root to target (inclusive), or None if not found.\"\"\"
+
+3. def map_tree(tree: dict, fn) -> dict:
+   \"\"\"Apply fn to each node (excluding 'children' key), return new tree with
+   same structure. fn receives a dict without 'children' and returns a new dict.
+   Must not mutate original.\"\"\"
+""",
+        test_code="""
+import copy
+
+tree = {
+    "id": "root", "name": "Root",
+    "children": [
+        {"id": "a", "name": "A", "children": [
+            {"id": "a1", "name": "A1"},
+            {"id": "a2", "name": "A2"},
+        ]},
+        {"id": "b", "name": "B"},
+    ]
+}
+original = copy.deepcopy(tree)
+
+# flatten_tree
+flat = flatten_tree(tree)
+ids = [n["id"] for n in flat]
+assert ids == ["root", "a", "a1", "a2", "b"], f"got {ids}"
+assert all("children" not in n for n in flat)
+assert tree == original  # no mutation
+
+# find_path
+assert find_path(tree, "a2") == ["root", "a", "a2"]
+assert find_path(tree, "root") == ["root"]
+assert find_path(tree, "b") == ["root", "b"]
+assert find_path(tree, "nonexistent") is None
+
+# map_tree
+result = map_tree(tree, lambda n: {**n, "name": n["name"].lower()})
+assert result["name"] == "root"
+assert result["children"][0]["name"] == "a"
+assert result["children"][0]["children"][0]["name"] == "a1"
+assert tree == original  # no mutation
+assert result["id"] == "root"
+
+# Edge: leaf node
+leaf = {"id": "solo", "val": 1}
+flat = flatten_tree(leaf)
+assert flat == [{"id": "solo", "val": 1}]
+assert find_path(leaf, "solo") == ["solo"]
+
+print("PASS: tree_ops")
+""",
+        max_tokens=2048,
+    ),
+]
+
+# ══════════════════════════════════════════════════════════════
+#  REAL-WORLD PATTERNS
+# ══════════════════════════════════════════════════════════════
+
+REAL_WORLD = [
+    Challenge(
+        id="rw_retry",
+        name="Retry with exponential backoff",
+        category="real_world",
+        difficulty="hard",
+        prompt="""Write a Python function:
+
+def compute_backoff_delays(max_retries: int, base_delay: float = 1.0,
+                           max_delay: float = 60.0, jitter: bool = False) -> list[float]:
+    \"\"\"Compute the sequence of backoff delays for retry logic.
+
+    Formula: delay = min(base_delay * 2^attempt, max_delay)
+    If jitter=True, multiply each delay by a factor between 0.5 and 1.0
+    (use deterministic half-jitter: factor = 0.75 for testability).
+
+    attempt starts at 0.
+    Returns list of `max_retries` delay values.\"\"\"
+
+Also write:
+
+def classify_error(status_code: int) -> str:
+    \"\"\"Classify HTTP status code for retry decisions.
+    Returns: 'permanent' (4xx except 429), 'transient' (5xx, 429, 408), or 'success' (2xx).
+    Any other code returns 'unknown'.\"\"\"
+""",
+        test_code="""
+# Basic exponential backoff
+delays = compute_backoff_delays(5, base_delay=1.0, max_delay=60.0)
+assert delays == [1.0, 2.0, 4.0, 8.0, 16.0], f"got {delays}"
+
+# Capped at max_delay
+delays = compute_backoff_delays(4, base_delay=10.0, max_delay=30.0)
+assert delays == [10.0, 20.0, 30.0, 30.0], f"got {delays}"
+
+# With jitter (deterministic 0.75 factor)
+delays = compute_backoff_delays(3, base_delay=4.0, jitter=True)
+assert delays == [3.0, 6.0, 12.0], f"got {delays}"
+
+# Zero retries
+assert compute_backoff_delays(0) == []
+
+# Error classification
+assert classify_error(200) == "success"
+assert classify_error(201) == "success"
+assert classify_error(400) == "permanent"
+assert classify_error(403) == "permanent"
+assert classify_error(404) == "permanent"
+assert classify_error(429) == "transient"  # rate limit
+assert classify_error(408) == "transient"  # timeout
+assert classify_error(500) == "transient"
+assert classify_error(503) == "transient"
+assert classify_error(100) == "unknown"
+assert classify_error(302) == "unknown"
+
+print("PASS: retry_backoff")
+""",
+    ),
+
+    Challenge(
+        id="rw_schema_validate",
+        name="Schema validator for dicts",
+        category="real_world",
+        difficulty="expert",
+        prompt="""Write a Python function:
+
+def validate(data: dict, schema: dict) -> list[str]:
+    \"\"\"Validate a dict against a schema. Return list of error strings (empty = valid).
+
+    Schema format — each key maps to a rule dict:
+    {
+        "field_name": {
+            "type": "str" | "int" | "float" | "bool" | "list" | "dict",
+            "required": True | False,  # default False
+            "min": number,             # minimum value (for int/float) or min length (for str/list)
+            "max": number,             # maximum value or max length
+            "choices": [...],          # allowed values
+            "pattern": "regex",        # regex pattern (for str only)
+        }
+    }
+
+    Error messages should be descriptive: "field_name: expected type str, got int"
+    Check in order: required → type → min/max → choices → pattern.\"\"\"
+""",
+        test_code="""
+import re
+
+schema = {
+    "name": {"type": "str", "required": True, "min": 1, "max": 50},
+    "age": {"type": "int", "required": True, "min": 0, "max": 150},
+    "email": {"type": "str", "pattern": r".+@.+\\..+"},
+    "role": {"type": "str", "choices": ["admin", "user", "guest"]},
+    "tags": {"type": "list", "max": 5},
+}
+
+# Valid data
+errors = validate({"name": "Alice", "age": 30, "email": "a@b.com", "role": "admin", "tags": ["a"]}, schema)
+assert errors == [], f"got {errors}"
+
+# Missing required
+errors = validate({"age": 25}, schema)
+assert any("name" in e and "required" in e.lower() for e in errors), f"got {errors}"
+
+# Wrong type
+errors = validate({"name": 123, "age": 25}, schema)
+assert any("name" in e and "type" in e.lower() for e in errors)
+
+# Min/max violation
+errors = validate({"name": "", "age": 25}, schema)
+assert any("name" in e for e in errors)  # min length 1
+
+errors = validate({"name": "Bob", "age": -5}, schema)
+assert any("age" in e for e in errors)  # min 0
+
+# Invalid choice
+errors = validate({"name": "X", "age": 1, "role": "superuser"}, schema)
+assert any("role" in e and "choices" in e.lower() for e in errors)
+
+# Pattern mismatch
+errors = validate({"name": "X", "age": 1, "email": "invalid"}, schema)
+assert any("email" in e and "pattern" in e.lower() for e in errors)
+
+# Extra fields ignored (no error)
+errors = validate({"name": "X", "age": 1, "extra": "ok"}, schema)
+assert not any("extra" in e for e in errors)
+
+# Optional missing is fine
+errors = validate({"name": "Test", "age": 50}, schema)
+assert not any("email" in e for e in errors)
+
+print("PASS: schema_validate")
+""",
+        max_tokens=2500,
+    ),
+
+    Challenge(
+        id="rw_rate_limiter",
+        name="Token bucket rate limiter",
+        category="real_world",
+        difficulty="expert",
+        prompt="""Write a Python class:
+
+class TokenBucket:
+    \"\"\"Token bucket rate limiter (non-threaded, for testing).
+
+    Args:
+        capacity: Maximum tokens in bucket.
+        refill_rate: Tokens added per second.
+
+    Methods:
+        consume(tokens: int = 1, current_time: float = None) -> bool:
+            Try to consume tokens. Returns True if allowed, False if not enough tokens.
+            current_time is injectable for testing (defaults to time.time()).
+            Before checking, refill based on elapsed time since last refill.
+
+        tokens_available(current_time: float = None) -> float:
+            Return current token count after refill.
+
+        wait_time(tokens: int = 1, current_time: float = None) -> float:
+            Return seconds to wait before `tokens` would be available.
+            Returns 0.0 if tokens are already available.
+    \"\"\"
+""",
+        test_code="""
+# Basic usage
+bucket = TokenBucket(capacity=10, refill_rate=1.0)
+
+# Starts full
+assert bucket.tokens_available(current_time=0) == 10
+
+# Consume some
+assert bucket.consume(3, current_time=0) == True
+assert bucket.tokens_available(current_time=0) == 7
+
+# Consume more than available
+assert bucket.consume(8, current_time=0) == False
+assert bucket.tokens_available(current_time=0) == 7  # unchanged
+
+# Refill over time
+assert bucket.tokens_available(current_time=2) == 9  # 7 + 2*1.0
+
+# Consume after refill
+assert bucket.consume(9, current_time=2) == True
+assert bucket.tokens_available(current_time=2) == 0
+
+# Don't exceed capacity
+assert bucket.tokens_available(current_time=100) == 10  # capped at capacity
+
+# Wait time
+bucket2 = TokenBucket(capacity=5, refill_rate=2.0)
+bucket2.consume(5, current_time=0)
+assert bucket2.tokens_available(current_time=0) == 0
+wt = bucket2.wait_time(4, current_time=0)
+assert abs(wt - 2.0) < 0.01  # need 4 tokens at 2/s = 2s
+
+# Already available
+bucket3 = TokenBucket(capacity=10, refill_rate=1.0)
+assert bucket3.wait_time(5, current_time=0) == 0.0
+
+# Consume more than capacity
+assert bucket3.consume(11, current_time=0) == False
+
+print("PASS: token_bucket")
+""",
+        max_tokens=1500,
+    ),
+
+    Challenge(
+        id="rw_diff",
+        name="Simple line differ",
+        category="real_world",
+        difficulty="expert",
+        prompt="""Write a Python function:
+
+def line_diff(old: str, new: str) -> list[str]:
+    \"\"\"Compute line-by-line diff between old and new text.
+
+    Returns list of diff lines:
+    - Lines only in old: prefixed with "- "
+    - Lines only in new: prefixed with "+ "
+    - Common lines: prefixed with "  " (two spaces)
+
+    Use longest common subsequence (LCS) to produce minimal diff.
+    Split input on newlines. Empty string = no lines.\"\"\"
+""",
+        test_code="""
+# No changes
+result = line_diff("a\\nb\\nc", "a\\nb\\nc")
+assert result == ["  a", "  b", "  c"]
+
+# Addition
+result = line_diff("a\\nc", "a\\nb\\nc")
+assert result == ["  a", "+ b", "  c"], f"got {result}"
+
+# Deletion
+result = line_diff("a\\nb\\nc", "a\\nc")
+assert result == ["  a", "- b", "  c"], f"got {result}"
+
+# Replacement
+result = line_diff("a\\nb\\nc", "a\\nX\\nc")
+assert result == ["  a", "- b", "+ X", "  c"], f"got {result}"
+
+# Complete change
+result = line_diff("a\\nb", "c\\nd")
+assert result == ["- a", "- b", "+ c", "+ d"]
+
+# Empty inputs
+assert line_diff("", "") == []
+assert line_diff("a", "") == ["- a"]
+assert line_diff("", "a") == ["+ a"]
+
+# Multiple additions and deletions
+result = line_diff("a\\nb\\nc\\nd", "a\\nc\\nd\\ne")
+assert "- b" in result
+assert "+ e" in result
+assert "  a" in result
+assert "  c" in result
+assert "  d" in result
+
+print("PASS: line_diff")
+""",
+        max_tokens=2048,
+    ),
+]
+
+
+# ── Todos ─────────────────────────────────────────────────
+
+ALL_CHALLENGES = FUNCTIONAL + DATA_PROCESSING + ALGORITHMS + REAL_WORLD