def fvalidate_tickets(rules: dict, nearby: List[str]) -> Tuple:
# So much more verbose to not do this imperatively
validator = partial(validate_ticket, rules)
validated = lmap(validator, nearby)
invalid, valid = lmap(list, partition(lambda x: x[0], validated))
valid_tickets = [_[1] for _ in valid]
invalid_tickets = [_[1] + _[2] for _ in invalid]
invalid_nums = list(concat([_[2] for _ in invalid]))
valid_nums = list(concat([_[1] for _ in valid]))
return valid_tickets, invalid_tickets, valid_nums, invalid_nums
def lines_to_programs(lines: List[str]) -> List[Tuple[str, List[dict]]]:
"""
Programs will be represented as two-part tuples. The first part is the
mask, a string. The second part is a list of registers and values,
represented by a dict with the keys "r" and "v".
"""
return lmap(parse_group, split_before(lines, lambda s: s[:4] == "mask"))
def process_two(data: List[str]) -> Any:
ct = lambda x: count_trees(data, *x)
vals = [
(1, 1),
(3, 1),
(5, 1),
(7, 1),
(1, 2, 2),
]
return prod(lmap(ct, vals))
def parse_group(group: List[str]) -> Tuple[str, List[dict]]:
mask = splitstrip(group[0], " = ")[1]
commands = lmap(parsecommand, group[1:])
return mask, commands
def process_two(lines: List[str], answer_one) -> int:
new_b = f"{answer_one} -> b"
wires = lmap(lambda x: new_b if x == "19138 -> b" else x, lines)
return solver({}, wires)["a"]
def process_input(text: str) -> Tuple:
rules, yours, nearby = splitstrip(text, "\n\n")
drules = parse_rules(rules)
lyours = parse_ticket(yours.splitlines()[1])
lnearby = lmap(parse_ticket, nearby.splitlines()[1:])
return (drules, lyours, lnearby)
def validate_ticket(rules: dict, ticket: List[int]) -> Tuple[bool, List, List]:
check = partial(is_num_in_any_valid_range, rules)
invalid_nums, valid_nums = lmap(list, partition(check, ticket))
valid = not invalid_nums
return valid, valid_nums, invalid_nums
def parse_ticket(line: str) -> List[int]:
return lmap(int, splitstrip(line, ","))