def main() -> None:
all_ingredients = set()
all_allergens = set()
all_edges = set()
with open(Path(__file__).parent.joinpath("input.txt")) as file:
for line in file:
# First pass, just find the ingredients and allergens.
ingredients, allergens = line.split('(')
ingredients = ingredients.strip().split()
allergens = allergens.strip().replace(',', '')[:-1].split()[1:]
all_ingredients.update(ingredients)
all_allergens.update(allergens)
file.seek(0)
for line in file:
ingredients, allergens = line.split('(')
ingredients = ingredients.strip().split()
allergens = allergens.strip().replace(',', '')[:-1].split()[1:]
# Invert the graph so a->b means "a is definitely not in b', i.e., A subset Bc
for a in all_ingredients:
if a in ingredients:
continue
for b in allergens:
all_edges.add((a, b))
file.seek(0)
raw_file = file.read()
with timing("Part 1"):
solution = part1(all_edges, all_ingredients, all_allergens, raw_file)
print(solution)
with timing("Part 2"):
solution = part2(all_edges, all_ingredients, all_allergens)
print(solution)
def main() -> None:
with timing("Part 1"):
solution = part1()
print(solution)
with timing("Part 2"):
solution = part2()
print(solution)
def main() -> None:
numbers = [14, 3, 1, 0, 9, 5]
with timing("Part 1"):
solution = part1(numbers)
print(solution)
with timing("Part 2"):
solution = part2(numbers)
print(solution)
def main() -> None:
with open(Path(__file__).parent.joinpath("input.txt")) as file:
numbers = [int(line) for line in file]
with timing("Part 1"):
solution = part1(numbers)
print(solution)
with timing("Part 2"):
solution = part2(numbers)
print(solution)
def main() -> None:
with open(Path(__file__).parent.joinpath("input.txt")) as file:
ciphertext = [int(line) for line in file]
with timing("Part 1"):
solution1 = part1(ciphertext)
print(solution1)
with timing("Part 2"):
solution = part2(ciphertext, target_sum=solution1)
print(solution)
def main() -> None:
with open(Path(__file__).parent.joinpath("input.txt")) as file:
instructions = [(line[0], int(line[1:])) for line in file]
with timing("Part 1"):
solution = part1(instructions)
print(solution)
with timing("Part 2"):
solution = part2(instructions)
print(solution)
def main() -> None:
with open(Path(__file__).parent.joinpath("input.txt")) as file:
seat_map = [list(line.strip()) for line in file]
with timing("Part 1"):
solution = part1(seat_map)
print(solution)
with timing("Part 2"):
solution = part2(seat_map)
print(solution)
def main() -> None:
with open(Path(__file__).parent.joinpath("input.txt")) as file:
boarding_passes = [line.strip() for line in file]
with timing("Part 1"):
solution = max(map(_pass_to_seat, boarding_passes))
print(solution)
with timing("Part 2"):
solution = part2(set(map(_pass_to_seat, boarding_passes)))
print(solution)
def main() -> None:
# Hard code the tiny input instead of parsing it.
p1_pos, p2_pos = 2, 7
with timing("Part 1"):
solution = part1(p1_pos, p2_pos)
print(solution)
with timing("Part 2"):
solution = part2(p1_pos, p2_pos)
print(solution)
def main() -> None:
octopods: List[List[int]] = []
with open(Path(__file__).parent.joinpath("input.txt")) as file:
octopods = [[int(c) for c in line.strip()] for line in file]
with timing("Part 1"):
solution = part1(octopods)
print(solution)
with timing("Part 2"):
solution = part2(octopods)
print(solution)
def main() -> None:
with open(Path(__file__).parent.joinpath("input.txt")) as file:
codes: List[BinaryInt] = [[int(b) for b in line.strip()]
for line in file]
with timing("Part 1"):
solution = part1(codes)
print(solution)
with timing("Part 2"):
solution = part2(codes)
print(solution)
def main() -> None:
transmission: Transmission = ""
with open(Path(__file__).parent.joinpath("input.txt")) as file:
transmission = file.readline().strip()
with timing("Part 1"):
solution = part1(transmission)
print(solution)
with timing("Part 2"):
solution = part2(transmission)
print(solution)
def main() -> None:
with open(Path(__file__).parent.joinpath("input.txt")) as file:
directions = (line.split() for line in file)
directions = [(a, int(b)) for (a, b) in directions]
with timing("Part 1"):
solution = part1(directions)
print(solution)
with timing("Part 2"):
solution = part2(directions)
print(solution)
def main() -> None:
# test_cups = [3, 8, 9, 1, 2, 5, 4, 6, 7]
cups = [2, 4, 7, 8, 1, 9, 3, 5, 6]
with timing("Part 1"):
solution = part1(cups, 100)
# Must manually read out numbers from 1 "clockwise", excluding 1.
print(solution)
cups.extend(range(10, 1000000 + 1))
with timing("Part 2"):
solution = part2(cups, 10000000)
print(solution)
def main() -> None:
lines: List[LineSegment] = []
with open(Path(__file__).parent.joinpath("input.txt")) as file:
lines = list(map(str2line, file.readlines()))
with timing("Part 1"):
solution = part1(lines)
print(solution)
with timing("Part 2"):
solution = part2(lines)
print(solution)
def main() -> None:
lines = []
with open(Path(__file__).parent.joinpath("input.txt")) as file:
lines = [line.strip() for line in file]
with timing("Part 1"):
solution = part1(lines)
print(solution)
with timing("Part 2"):
solution = part2(lines)
print(solution)
def main() -> None:
crab_submarines: List[int] = []
with open(Path(__file__).parent.joinpath("input.txt")) as file:
crab_submarines = list(map(int, file.read().split(",")))
with timing("Part 1"):
solution = part1(crab_submarines)
print(solution)
with timing("Part 2"):
solution = part2(crab_submarines)
print(solution)
def main() -> None:
sf_numbers: List[SFNumber] = []
with open(Path(__file__).parent.joinpath("input.txt")) as file:
for line in file:
sf_numbers.append(SFNumber.from_str(line.strip()))
with timing("Part 1"):
solution = part1(sf_numbers)
print(solution)
with timing("Part 2"):
solution = part2(sf_numbers)
print(solution)
def main() -> None:
heights: List[List[int]] = []
with open(Path(__file__).parent.joinpath("input.txt")) as file:
for line in file:
heights.append(list(map(lambda x: int(x), line.strip())))
with timing("Part 1"):
solution = part1(heights)
print(solution)
with timing("Part 2"):
solution = part2(heights)
print(solution)
def main() -> None:
expressions: List[Expression] = []
with open(Path(__file__).parent.joinpath("input.txt")) as file:
for line in file:
expressions.append(line.strip())
with timing("Part 1"):
solution = part1(expressions)
print(solution)
with timing("Part 2"):
solution = part2(expressions)
print(solution)
def main() -> None:
passports = []
with open(Path(__file__).parent.joinpath("input.txt")) as file:
for kcv_list in map(lambda x: x.split(), file.read().split('\n\n')):
passports.append({k: v for k, v in map(lambda x: x.split(':'), kcv_list)})
with timing("Part 1"):
solution = part1(passports)
print(solution)
with timing("Part 2"):
solution = part2(passports)
print(solution)
def main() -> None:
cucumbers: List[List[str]] = []
with open(Path(__file__).parent.joinpath("input.txt")) as file:
for line in file:
cucumbers.append(list(line.strip()))
with timing("Part 1"):
solution = part1(cucumbers)
print(solution)
with timing("Part 2"):
solution = part2(cucumbers)
print(solution)
def main() -> None:
with open(Path(__file__).parent.joinpath("input.txt")) as file:
adaptors = [int(line) for line in file]
adaptors.extend([0, max(adaptors) + 3])
adaptors.sort()
with timing("Part 1"):
solution = part1(adaptors)
print(solution)
with timing("Part 2"):
solution = part2(adaptors)
print(solution)
def main() -> None:
grid: Grid = []
with open(Path(__file__).parent.joinpath("input.txt")) as file:
for line in file:
grid.append(list(map(int, line.strip())))
with timing("Part 1"):
solution = part1(grid)
print(solution)
with timing("Part 2"):
solution = part2(grid)
print(solution)
def main() -> None:
instructions: List[Instruction] = []
with open(Path(__file__).parent.joinpath("input.txt")) as file:
for line in file:
op, arg = line.strip().split(maxsplit=1)[:2]
instructions.append((op, int(arg)))
with timing("Part 1"):
solution = part1(instructions)[0]
print(solution)
with timing("Part 2"):
solution = part2(instructions)
print(solution)
def main() -> None:
initial_state: Dict[Coordinate, bool] = {}
with open(Path(__file__).parent.joinpath("input.txt")) as file:
for i, line in enumerate(file):
for j, c in enumerate(line.strip()):
initial_state[(i, j, 0)] = (c == '#')
with timing("Part 1"):
solution = part1(initial_state)
print(solution)
with timing("Part 2"):
solution = part2(initial_state)
print(solution)
def main() -> None:
passwords: List[Tuple[Rule, str]] = []
with open(Path(__file__).parent.joinpath("input.txt")) as file:
for line in file:
rule, password = line.split(':')
passwords.append((parse_rule(rule), password.lstrip()))
with timing("Part 1"):
solution = part1(passwords)
print(solution)
with timing("Part 2"):
solution = part2(passwords)
print(solution)
def main() -> None:
nodes = {}
with open(Path(__file__).parent.joinpath("input.txt")) as file:
for line in file:
a, b = line.strip().split("-")
nodes[a] = nodes.get(a, []) + [b]
nodes[b] = nodes.get(b, []) + [a]
with timing("Part 1"):
solution = part1(nodes)
print(solution)
with timing("Part 2"):
solution = part2(nodes)
print(solution)
def main() -> None:
with open(Path(__file__).parent.joinpath("input.txt")) as file:
lines = file.readlines()
earliest_time = int(lines[0])
buses: List[Bus] = [(index, int(bus_id))
for (index, bus_id) in enumerate(lines[1].split(","))
if bus_id != 'x']
with timing("Part 1"):
solution = part1(earliest_time, buses)
print(solution)
with timing("Part 2"):
solution = part2(buses)
print(solution)
def main() -> None:
input_lines: DigitLines = []
output_lines: DigitLines = []
with open(Path(__file__).parent.joinpath("input.txt")) as file:
for line in file:
in_str, out_str = line.split("|")
input_lines.append(in_str.split())
output_lines.append(out_str.split())
with timing("Part 1"):
solution = part1(output_lines)
print(solution)
with timing("Part 2"):
solution = part2(input_lines, output_lines)
print(solution)
