def solve2(ipt, **kwargs):
rules, messages = input_groups(ipt)
rules_dict = {}
for rule in rules:
parse_rule(rule, rules_dict)
@memoize
def build(num, depth=0):
rule = rules_dict[num]
if num == 8:
return f'{build(42)}+'
if num == 11 and depth < 10:
return f'({build(42)}({build(11, depth+1)})?{build(31)})'
elif num == 11:
return f'({build(42)}{build(31)})'
if type(rule) == str:
return rule
if type(rule) == tuple:
lhs, rhs = rule
lhs = ''.join(map(lambda r: build(int(r)), lhs))
rhs = ''.join(map(lambda r: build(int(r)), rhs))
return f'(({lhs})|({rhs}))'
if type(rule) == list:
built = ''.join(map(lambda r: build(int(r)), rule))
return f'({built})'
built = f'^{build(0)}$'
print(len(list(filter(lambda m: re.match(built, m), messages))))
def solve1(ipt, **kwargs):
rules, messages = input_groups(ipt)
rules_dict = {}
for rule in rules:
parse_rule(rule, rules_dict)
@memoize
def build(num):
rule = rules_dict[num]
if type(rule) == str:
return rule
if type(rule) == tuple:
lhs, rhs = rule
lhs = ''.join(map(lambda r: build(int(r)), lhs))
rhs = ''.join(map(lambda r: build(int(r)), rhs))
return f'(({lhs})|({rhs}))'
if type(rule) == list:
built = ''.join(map(lambda r: build(int(r)), rule))
return f'({built})'
built = f'^{build(0)}$'
print(len(list(filter(lambda m: re.match(built, m), messages))))
def solve1(ipt):
total = 0
for card in input_groups(ipt):
answered = 0
for q in qs:
if any(map(lambda p: q in p, card)):
answered += 1
total += answered
print(total)
def solve2(ipt):
valid = 0
for passport in input_groups(ipt):
is_valid = True
for f in fields:
if not validate(f, passport):
is_valid = False
break
if is_valid:
valid += 1
print(valid)
def solve1(ipt):
valid = 0
for passport in input_groups(ipt):
is_valid = True
for f in fields:
if f not in f' {" ".join(passport)} ':
is_valid = False
break
if is_valid:
valid += 1
print(valid)
def solve1(ipt, print_result=True, **kwargs):
rules, _, tickets = input_groups(ipt)
rules_dict = build_rules_dict(rules)
def is_val_invalid(val):
return all([
not (val in ranges[0] or val in ranges[1])
for _, ranges in rules_dict.items()
])
def add_invalids(ticket):
return sum(filter(is_val_invalid, [int(i) for i in ticket.split(',')]))
if print_result:
print(sum(map(add_invalids, tickets[1:])))
return filter(lambda t: add_invalids(t) == 0, tickets[1:])
def solve2(ipt):
total = 0
for card in input_groups(ipt):
answered = 0
counts = {i: 0 for i in qs}
for r in card:
for q in r:
counts[q] += 1
for _, v in counts.items():
if v == len(card):
answered += 1
total += answered
print(total)
def solve2(ipt, **kwargs):
rules, your_ticket, _ = input_groups(ipt)
your_ticket = [int(i) for i in your_ticket[1].split(',')]
valid_tickets = solve1(ipt, False, **kwargs)
valid_tickets = [[int(i) for i in t.split(',')] for t in valid_tickets]
rules_dict = build_rules_dict(rules)
candidates = {k: set() for k, _ in rules_dict.items()}
def valid_for_rule(v, rule):
range1, range2 = rules_dict[rule]
return v in range1 or v in range2
for rule in candidates.keys():
for i in range(len(your_ticket)):
if all([valid_for_rule(t[i], rule) for t in valid_tickets]):
candidates[rule].add(i)
while any([len(vals) > 1 for vals in candidates.values()]):
for rule, vals in candidates.items():
if len(vals) == 1:
candidates = {
r: v - vals if r != rule else vals
for r, v in candidates.items()
}
if 'is_test' in kwargs:
print(candidates)
else:
total = 1
for val in [
your_ticket[list(v)[0]] for r, v in candidates.items()
if 'departure' in r
]:
total *= val
print(total)