Spaces:
Running
Running
| """Levels and task generation. | |
| The levels follow the video: the 24 game with four cards, then "once that got too easy, you take | |
| eight cards and you make the current year", then nine cards for any four-digit number someone | |
| names. Three-digit with six cards sits between the two as a step up from 24. | |
| Every generated task is solvable: the deal is checked with the solver and redealt if it fails. | |
| """ | |
| from __future__ import annotations | |
| import datetime as _dt | |
| import random | |
| from dataclasses import dataclass | |
| from .cards import Card, cards_from_ranks, deal | |
| from .expr import Tree, steps, to_text | |
| from .solver import solve | |
| CURRENT_YEAR = _dt.date.today().year | |
| class Level: | |
| name: str | |
| title: str | |
| n_cards: int | |
| low: int | |
| high: int | |
| LEVELS = { | |
| "24": Level("24", "24", 4, 24, 24), | |
| "three-digit": Level("three-digit", "Three-digit", 6, 100, 999), | |
| "year": Level("year", "Year", 8, 1900, 2100), | |
| "four-digit": Level("four-digit", "Four-digit", 9, 1000, 9999), | |
| } | |
| DEFAULT_LEVEL = "year" | |
| def cards_for_target(target: int) -> int: | |
| """How many cards a custom target gets: 4 for up to 99, 6 for three digits, 8 for 1000-2999, then 9.""" | |
| if target < 100: | |
| return 4 | |
| if target < 1000: | |
| return 6 | |
| if target < 3000: | |
| return 8 | |
| return 9 | |
| def make_task( | |
| rng: random.Random, | |
| level: str | None = None, | |
| target: int | None = None, | |
| n_cards: int | None = None, | |
| ranks: list[int] | None = None, | |
| task_id: str | None = None, | |
| time_limit: float = 2.0, | |
| max_deals: int = 50, | |
| ) -> dict: | |
| """Deal a solvable task. | |
| With no `target`, the level picks one from its range. A given `target` keeps the level's card | |
| count, or without a level picks one by size (`cards_for_target`). Given `ranks` are dealt as | |
| they are and may have no solution (then `solution` is None). | |
| """ | |
| if level is not None and level not in LEVELS: | |
| raise ValueError(f"unknown level {level!r}; choose one of {', '.join(LEVELS)}") | |
| if target is None: | |
| lvl = LEVELS[level or DEFAULT_LEVEL] | |
| level, target = lvl.name, rng.randint(lvl.low, lvl.high) | |
| target = int(target) | |
| if not 0 <= target <= 1_000_000: | |
| raise ValueError("target must be a whole number from 0 to 1,000,000") | |
| if ranks is not None: | |
| cards = cards_from_ranks(list(ranks), rng) | |
| tree = solve([c.rank for c in cards], target, time_limit) | |
| return _task(cards, target, tree, level or "custom", task_id) | |
| n = n_cards or (LEVELS[level].n_cards if level else cards_for_target(target)) | |
| if not 2 <= n <= 12: | |
| raise ValueError("deal between 2 and 12 cards") | |
| for _ in range(max_deals): | |
| cards = deal(n, rng) | |
| tree = solve([c.rank for c in cards], target, time_limit) | |
| if tree is not None: | |
| return _task(cards, target, tree, level or "custom", task_id) | |
| raise RuntimeError(f"no solvable deal of {n} cards for {target} in {max_deals} tries") | |
| def _task(cards: list[Card], target: int, tree: Tree | None, level: str, task_id: str | None) -> dict: | |
| return { | |
| "id": task_id or f"{level}-{target}-" + "".join(c.label for c in cards), | |
| "level": level, | |
| "target": target, | |
| "cards": [c.to_dict() for c in cards], | |
| "solution": None if tree is None else to_text(tree), | |
| "solution_steps": [] if tree is None else steps(tree), | |
| } | |
| def public(task: dict) -> dict: | |
| """The task as an agent may see it: no reference solution.""" | |
| return {k: v for k, v in task.items() if k not in ("solution", "solution_steps")} | |