def docking_data_1():
solution = 0
memory = dict()
mask = None
mask_value = None
input_data = read_and_load_input("DAY14")
for line in input_data:
if line.startswith("mask"):
mask = re.search(r"\s*=\s*([\S\s]+)", line).group(1)
elif line.startswith("mem"):
memory_address = re.search(r"\[([A-Za-z0-9_]+)\]", line).group(1)
value = int(re.search(r"\s*=\s*([\S\s]+)", line).group(1))
value_bin = f"{value:036b}"
value_after_mask = []
for index, bit in enumerate(mask):
if bit == "X":
value_after_mask.append(value_bin[index])
else:
value_after_mask.append(mask[index])
value_after_mask = "".join(value_after_mask)
value_after_mask = int(value_after_mask, 2)
memory[memory_address] = value_after_mask
for k, v in memory.items():
solution += v
return solution
def combo_breaker_1():
input_data = read_and_load_input("Day25")
card_public = int(input_data[0])
door_public = int(input_data[1])
MOD = 20201227
card_loop_size = find_loop_size(7, card_public, MOD)
return (pow(door_public, card_loop_size, MOD))
def ticket_translation_1():
input = read_and_load_input("DAY16")
valid_seq = set()
rules = True
nearby = False
solution = 0
for line in input:
if rules:
seq = re.findall('\d+', line)
round = 0
while round < 3 and len(seq) > 0:
for _ in range(int(seq[round]), int(seq[round + 1]) + 1):
valid_seq.add(_)
round += 2
sorted(valid_seq)
elif nearby:
numbers = line.split(",")
for number in numbers:
if int(number) not in valid_seq:
solution += int(number)
if len(line) == 0:
rules = False
if line.startswith("nearby"):
nearby = True
return solution
def crab_combat_1():
solution = 0
input_data = read_and_load_input("Day22")
players = generate_decks(input_data)
winner = play_game(players)
for index, val in enumerate(winner):
solution += (val * (len(winner) - index))
return solution
def crab_combat_2():
solution = 0
input_data = read_and_load_input("Day22")
players = generate_decks(input_data)
game = 1
winner = play_game_2(players, game)
print(winner[1])
for index, val in enumerate(winner[1]):
solution += (val * (len(winner[1]) - index))
return solution
def adapter_array_2(input):
input = read_and_load_input("DAY10")
numbers = sorted(input)
combination_count = {0: 1}
for num in numbers:
combination_count[num] = 0
combination_count[num] += combination_count.get(num - 1, 0)
combination_count[num] += combination_count.get(num - 2, 0)
combination_count[num] += combination_count.get(num - 3, 0)
return combination_count[numbers[-1]]
def allergen_assessment_1():
input = read_and_load_input("DAY21")
foods = []
ingredients = set()
allergens = set()
allergen_probable_map = defaultdict(list)
for line in input:
ingr_re = re.match(r"(.*?)\(contains (.*?)\)", line)
ingrs = [x for x in ingr_re.group(1).split(' ') if x]
allergs = [x for x in ingr_re.group(2).split(', ') if x]
ingredients.update(ingrs)
allergens.update(allergs)
food = Food(ingrs, allergs)
foods.append(food)
could_allergens = set()
for a in allergens:
ingr_sets = []
for f in foods:
if a in f.allerg:
ingr_sets.append(f.ing)
if len(ingr_sets) > 1:
could_allergens.update(ingr_sets[0].intersection(*ingr_sets[1:]))
else:
could_allergens.update(ingr_sets[0])
not_allergens = ingredients - could_allergens
ingr_occur_map = defaultdict(int)
for f in foods:
for ing in not_allergens:
if ing in f.ing:
ingr_occur_map[ing] += 1
solution = sum(list(ingr_occur_map.values()))
return solution, foods, not_allergens, allergens
from collections import deque
from utils import read_and_load_input
facing = deque('ESWN')
steps = {'N': 1j, 'E': 1, 'S': -1j, 'W': -1}
p1, p2 = 0, 0
waypoint = 10+1j
data = read_and_load_input("DAY12")
for line in data:
op, arg = line[0], int(line[1:].strip())
val = arg // 90
if op == 'L':
facing.rotate(val)
for _ in range(val):
waypoint = complex(-waypoint.imag, waypoint.real)
if op == 'R':
facing.rotate(-val)
for _ in range(val):
waypoint = complex(waypoint.imag, -waypoint.real)
if op == 'F':
step = steps.get(facing[0])
p1 += step * arg
p2 += waypoint * arg
if op in facing:
step = steps.get(op)
p1 += step * arg
waypoint += step * arg
def rain_risky_1():
print(f"Solution 1: {int(abs(p1.real) + abs(p1.imag))}")
def lobby_layout_2(blackTiles):
for day in range(100):
newTiles = set()
affectedTiles = blackTiles.copy()
for tile in blackTiles:
affectedTiles.update(neighbors(tile))
for tile in affectedTiles:
numNeighbors = sum(n in blackTiles for n in neighbors(tile))
if tile in blackTiles:
if numNeighbors in (1, 2):
newTiles.add(tile)
else:
if numNeighbors == 2:
newTiles.add(tile)
blackTiles = newTiles
return len(blackTiles)
if __name__ == '__main__':
input_data = read_and_load_input("Day24")
tiles = [parse(line.rstrip()) for line in input_data]
blackTiles = lobby_layout_1()
print(f"Solution 1: {len(blackTiles)}")
print(f"Solution 2: {lobby_layout_2(blackTiles)}")
def adapter_array_1(input):
numbers = read_and_load_input("DAY10")
numbers.append(0)
numbers.sort()
differences = [numbers[i + 1] - x for i, x in enumerate(numbers[:-1])]
return differences.count(1) * (differences.count(3) + 1)
import os
from utils import read_and_load_input
input = read_and_load_input("DAY10")
def adapter_array_1(input):
numbers = read_and_load_input("DAY10")
numbers.append(0)
numbers.sort()
differences = [numbers[i + 1] - x for i, x in enumerate(numbers[:-1])]
return differences.count(1) * (differences.count(3) + 1)
def adapter_array_2(input):
input = read_and_load_input("DAY10")
numbers = sorted(input)
combination_count = {0: 1}
for num in numbers:
combination_count[num] = 0
combination_count[num] += combination_count.get(num - 1, 0)
combination_count[num] += combination_count.get(num - 2, 0)
combination_count[num] += combination_count.get(num - 3, 0)
return combination_count[numbers[-1]]
if __name__ == '__main__':
print(adapter_array_1(input))
print(adapter_array_2(input))
def seating_system_2():
data = read_and_load_input("DAY11")
stabilized2 = run_till_stabilized2(text2chart(data))
return count_occupied(stabilized2)
def seating_system_1():
data = read_and_load_input("DAY11")
empty_chart = text2chart(data)
stabilized = run_till_stabilized(empty_chart)
return count_occupied(stabilized)
def conway_cubes_2():
input = read_and_load_input("DAY17")
return playLife(input, 4)
def operation_order_2():
input = read_and_load_input("DAY18")
return sum(evaluate_with_precedence(expression) for expression in input)
