133 lines
4.1 KiB
Python
133 lines
4.1 KiB
Python
import logging
|
|
import operator
|
|
import os
|
|
import sys
|
|
from math import prod
|
|
from typing import Literal, TypeAlias, cast
|
|
|
|
VERBOSE = os.getenv("AOC_VERBOSE") == "True"
|
|
|
|
logging.basicConfig(level=logging.INFO if VERBOSE else logging.WARNING)
|
|
|
|
Category: TypeAlias = Literal["x", "m", "a", "s"]
|
|
Part: TypeAlias = dict[Category, int]
|
|
PartWithBounds: TypeAlias = dict[Category, tuple[int, int]]
|
|
|
|
OPERATORS = {"<": operator.lt, ">": operator.gt}
|
|
|
|
# None if there is no check (last entry), otherwise (category, sense, value)
|
|
Check: TypeAlias = tuple[Category, Literal["<", ">"], int] | None
|
|
|
|
# workflow as a list of check, in specified order, with target
|
|
Workflow: TypeAlias = list[tuple[Check, str]]
|
|
|
|
|
|
def accept(workflows: dict[str, Workflow], part: Part) -> bool:
|
|
workflow = "in"
|
|
decision: bool | None = None
|
|
|
|
while decision is None:
|
|
for check, target in workflows[workflow]:
|
|
ok = check is None
|
|
if check is not None:
|
|
category, sense, value = check
|
|
ok = OPERATORS[sense](part[category], value)
|
|
|
|
if ok:
|
|
if target in workflows:
|
|
workflow = target
|
|
else:
|
|
decision = target == "A"
|
|
break
|
|
|
|
return decision
|
|
|
|
|
|
def propagate(workflows: dict[str, Workflow], start: PartWithBounds) -> int:
|
|
def transfer_or_accept(
|
|
target: str, meta: PartWithBounds, queue: list[tuple[PartWithBounds, str]]
|
|
) -> int:
|
|
if target in workflows:
|
|
logging.info(f" transfer to {target}")
|
|
queue.append((meta, target))
|
|
return 0
|
|
elif target == "A":
|
|
logging.info(" accepted")
|
|
return prod((high - low + 1) for low, high in meta.values())
|
|
else:
|
|
logging.info(" rejected")
|
|
return 0
|
|
|
|
accepted = 0
|
|
queue: list[tuple[PartWithBounds, str]] = [(start, "in")]
|
|
|
|
while queue:
|
|
meta, workflow = queue.pop()
|
|
logging.info(f"{workflow}: {meta}")
|
|
for check, target in workflows[workflow]:
|
|
if check is None:
|
|
accepted += transfer_or_accept(target, meta, queue)
|
|
continue
|
|
|
|
category, sense, value = check
|
|
bounds, op = meta[category], OPERATORS[sense]
|
|
|
|
logging.info(f" splitting {meta} into {category} {sense} {value}")
|
|
|
|
if not op(bounds[0], value) and not op(bounds[1], value):
|
|
logging.info(" reject, always false")
|
|
continue
|
|
|
|
if op(meta[category][0], value) and op(meta[category][1], value):
|
|
logging.info(" accept, always true")
|
|
accepted += transfer_or_accept(target, meta, queue)
|
|
break
|
|
|
|
meta2 = meta.copy()
|
|
if sense == "<":
|
|
meta2[category] = (meta[category][0], value - 1)
|
|
meta[category] = (value, meta[category][1])
|
|
else:
|
|
meta2[category] = (value + 1, meta[category][1])
|
|
meta[category] = (meta[category][0], value)
|
|
logging.info(f" split {meta2} ({target}), {meta}")
|
|
|
|
accepted += transfer_or_accept(target, meta2, queue)
|
|
|
|
return accepted
|
|
|
|
|
|
workflows_s, parts_s = sys.stdin.read().strip().split("\n\n")
|
|
|
|
workflows: dict[str, Workflow] = {}
|
|
for workflow_s in workflows_s.split("\n"):
|
|
name, block_s = workflow_s.split("{")
|
|
workflows[name] = []
|
|
|
|
for block in block_s[:-1].split(","):
|
|
check: Check
|
|
if (i := block.find(":")) >= 0:
|
|
check, target = (
|
|
cast(Category, block[0]),
|
|
cast(Literal["<", ">"], block[1]),
|
|
int(block[2:i]),
|
|
), block[i + 1 :]
|
|
else:
|
|
check, target = None, block
|
|
workflows[name].append((check, target))
|
|
|
|
# part 1
|
|
parts: list[Part] = [
|
|
{cast(Category, s[0]): int(s[2:]) for s in part_s[1:-1].split(",")}
|
|
for part_s in parts_s.split("\n")
|
|
]
|
|
answer_1 = sum(sum(part.values()) for part in parts if accept(workflows, part))
|
|
print(f"answer 1 is {answer_1}")
|
|
|
|
|
|
# part 2
|
|
answer_2 = propagate(
|
|
workflows, {cast(Category, c): (1, 4000) for c in ["x", "m", "a", "s"]}
|
|
)
|
|
print(f"answer 2 is {answer_2}")
|