def part_one():
train_rules, your_ticket, nearby_tickets = get_train_data()
error_rate = 0
for nearby_ticket in nearby_tickets:
error_rate_ticket, invalid = get_error_rate(nearby_ticket, train_rules)
error_rate += error_rate_ticket
ut.print_answer(error_rate)
def part_two():
repaired_instructions = get_repaired_instructions()
for instructions in repaired_instructions:
hgc = HandheldGameConsole(instructions)
hgc.run()
if hgc.pointer == len(instructions):
ut.print_answer(hgc.accumulator)
def part_two():
password_data = get_password_data()
count = 0
for policy in password_data:
if policy.is_valid_password_v2():
count += 1
ut.print_answer(count)
def part_one():
puzzle = Puzzle(get_puzzle_pieces())
puzzle.assemble()
answer = 1
for tile_id in puzzle.get_corner_pieces():
answer *= int(tile_id)
ut.print_answer(answer)
def part_two():
recursive_combat_game = RecursiveCombatGame({
"player_1": deck1,
"player_2": deck2
})
winner, loser = recursive_combat_game.play()
ut.print_answer(recursive_combat_game.calc_score(winner))
def part_one():
foods = get_food_data()
possible_allergens = get_possible_allergens(foods)
allergens = get_allergens(possible_allergens)
non_allergens = get_non_allergens(allergens, get_all_ingredients(foods))
answer = count_non_allergen_occurrences(foods, non_allergens)
ut.print_answer(answer)
def part_two():
passports = get_passports()
valid_passports = 0
for passport in passports:
valid = is_valid_v2(passport)
if valid:
valid_passports += 1
ut.print_answer(valid_passports)
def part_one():
jolt_diff = []
jolt = 0
for adapter in adapters:
jolt_diff.append(adapter - jolt)
jolt = adapter
one_diff_count = jolt_diff.count(1)
three_diff_count = jolt_diff.count(3)
ut.print_answer(one_diff_count * three_diff_count)
def part_two():
train_rules, your_ticket, nearby_tickets = get_train_data()
valid_tickets = get_valid_tickets(nearby_tickets, train_rules)
correct_rule_order = get_correct_rule_order(valid_tickets, train_rules)
answer = 1
for rule_index in correct_rule_order.keys():
rule_name = correct_rule_order[rule_index]
if rule_name.split()[0] == 'departure':
answer *= your_ticket[rule_index]
ut.print_answer(answer)
def part_one():
bus_id = 0
min_wait = math.inf
for bus in buses:
bus_cycle = bus[0]
wait_time = waiting_time(bus_cycle)
if wait_time < min_wait:
min_wait = wait_time
bus_id = bus[0]
ut.print_answer(bus_id * min_wait)
def part_two():
puzzle = Puzzle(get_puzzle_pieces())
puzzle.assemble()
final_image = puzzle.merge_image_pieces()
answer = math.inf
for i in range(4):
answer = min(match_sea_monster(copy.copy(final_image)), answer)
final_image.rotate()
final_image.flip()
for i in range(4):
answer = min(match_sea_monster(copy.copy(final_image)), answer)
final_image.rotate()
ut.print_answer(answer)
def part_two():
t_start = 0
t_offset = 1
for i in range(len(buses)):
bus_group = buses[0:i + 1]
t = t_start
while True:
if all([is_aligned(bus[0], bus[1], t) for bus in bus_group]):
ut.print_answer(t)
t_start = t
t_offset = ut.lcm([bus[0] for bus in bus_group])
break
else:
t += t_offset
def part_one():
ut.print_answer(play(2020))
def part_one():
instructions = [line.split() for line in ut.read_input().splitlines()]
hgc = HandheldGameConsole(instructions)
hgc.run()
ut.print_answer(hgc.accumulator)
def part_two():
answer = count_arrangements()
ut.print_answer(answer)
def part_one():
max_id = max([get_seat_id(b_pass) for b_pass in boarding_passes])
ut.print_answer(max_id)
def part_one():
combat_game = CombatGame(deck1, deck2)
ut.print_answer(combat_game.play())
def part_one():
valid_messages = dict.fromkeys(get_valid_messages('0'), 1)
answer = sum([valid_messages.get(message, 0) for message in messages])
ut.print_answer(answer)
def part_two():
answer = sum([count_answers_v2(group) for group in group_answers])
ut.print_answer(answer)
def part_one():
program = Program()
instructions = get_instructions()
program.initialize(instructions)
ut.print_answer(program.sum_memory())
def part_two():
answer = [is_valid_message(message) for message in messages].count(True)
ut.print_answer(answer)
def part_one():
slope = (3, 1)
trees = ride(slope)
ut.print_answer(trees)
def part_one():
seat_map = get_seat_map()
changes = True
while changes:
seat_map, changes = simulate(seat_map)
ut.print_answer(count_occupied_seats(seat_map))
def part_two():
slopes = [(1, 1), (3, 1), (5, 1), (7, 1), (1, 2)]
answer = 1
for slope in slopes:
answer *= ride(slope)
ut.print_answer(answer)
def part_two():
ut.print_answer(play(30000000))
def part_two():
boat = WayPointBoat()
boat.follow_instructions(boat_instructions)
ut.print_answer(boat.get_manhattan_distance_traveled())
def part_one():
hex_grid = HexGrid()
hex_grid.init_tiles(get_instructions())
ut.print_answer(hex_grid.count_black())
def part_one():
answer = sum([count_answers(group) for group in group_answers])
ut.print_answer(answer)
def part_two():
ut.print_answer(
sum([
int(ExpressionEvaluator(expression).evaluate_v2())
for expression in expressions
]))
def part_two():
conway_dimension = ConwayDimension(4)
cycles = 6
for i in range(cycles):
conway_dimension.cycle()
ut.print_answer(len(conway_dimension.active))
