List of Posts on Jules Tamagnan

Advent of Code 2024 - Day 14

Sun, 22 Dec 2024 09:58:22 +0000

# Part 1

 1from __future__ import annotations
 2
 3import typing
 4import dataclasses
 5import re
 6import collections
 7
 8@dataclasses.dataclass
 9class Vector:
10 x: int
11 y: int
12
13 def __add__(self, b: typing.Self):
14 return Vector(self.x + b.x, self.y + b.y)
15
16@dataclasses.dataclass
17class Guard:
18 pos: Vector
19 vel: Vector
20
21 def move(self, shape: Vector):
22 self.pos.x = (self.pos.x + self.vel.x) % shape.x
23 self.pos.y = (self.pos.y + self.vel.y) % shape.y
24
25
26 def get_quadrant(self, shape: Vector):
27 if self.pos.x < shape.x // 2:
28 x = 0
29 elif shape.x - shape.x // 2 <= self.pos.x:
30 x = 1
31 else:
32 return None
33
34 if self.pos.y < shape.y // 2:
35 y = 0
36 elif shape.y - shape.y // 2 <= self.pos.y:
37 y = 1
38 else:
39 return None
40
41 return (x, y)
42
43def get_data(path):
44 with open(path) as f:
45 data = f.read()
46
47 for guard_line in data.strip().splitlines():
48 if m := re.search(r"p=(-?\d+),(-?\d+) v=(-?\d+),(-?\d+)", guard_line):
49 pos = Vector(int(m.group(1)), int(m.group(2)))
50 vel = Vector(int(m.group(3)), int(m.group(4)))
51 yield Guard(pos, vel)
52 else:
53 raise Exception("Could not parse line `{line}`")
54
55
56def main(guards: list[Guard], shape: Vector, iterations=100):
57 for _ in range(iterations):
58 for guard in guards:
59 guard.move(shape)
60
61 counter = collections.Counter(g.get_quadrant(shape) for g in guards)
62 total = 1
63 for k, v in counter.items():
64 if k is not None:
65 total *= v
66 return total
67
68if __name__ == "__main__":
69 # print(main(list(get_data("day_14_input_test.txt")), Vector(11, 7)))
70 print(main(list(get_data("day_14_input.txt")), Vector(101, 103)))

# Part 2

 1from __future__ import annotations
 2
 3import typing
 4import dataclasses
 5import re
 6import collections
 7
 8@dataclasses.dataclass
 9class Vector:
10 x: int
11 y: int
12
13 def __add__(self, b: typing.Self):
14 return Vector(self.x + b.x, self.y + b.y)
15
16@dataclasses.dataclass
17class Guard:
18 pos: Vector
19 vel: Vector
20
21 def move(self, shape: Vector):
22 self.pos.x = (self.pos.x + self.vel.x) % shape.x
23 self.pos.y = (self.pos.y + self.vel.y) % shape.y
24
25
26 def get_quadrant(self, shape: Vector):
27 if self.pos.x < shape.x // 2:
28 x = 0
29 elif shape.x - shape.x // 2 <= self.pos.x:
30 x = 1
31 else:
32 return None
33
34 if self.pos.y < shape.y // 2:
35 y = 0
36 elif shape.y - shape.y // 2 <= self.pos.y:
37 y = 1
38 else:
39 return None
40
41 return (x, y)
42
43def get_data(path):
44 with open(path) as f:
45 data = f.read()
46
47 for guard_line in data.strip().splitlines():
48 if m := re.search(r"p=(-?\d+),(-?\d+) v=(-?\d+),(-?\d+)", guard_line):
49 pos = Vector(int(m.group(1)), int(m.group(2)))
50 vel = Vector(int(m.group(3)), int(m.group(4)))
51 yield Guard(pos, vel)
52 else:
53 raise Exception("Could not parse line `{line}`")
54
55
56def format_grid(guards, shape):
57 grid = [["." for _ in range(shape.x)] for _ in range(shape.y)]
58 for g in guards:
59 grid[g.pos.y][g.pos.x] = "x"
60
61 return "\n".join("".join(row) for row in grid)
62
63def main(guards: list[Guard], shape: Vector, iterations=10000):
64 for i in range(iterations):
65 for guard in guards:
66 guard.move(shape)
67 grid_str = format_grid(guards, shape)
68 if "x" * 10 in grid_str:
69 print(i + 1)
70 print(grid_str)
71
72if __name__ == "__main__":
73 # print(main(list(get_data("day_14_input_test.txt")), Vector(11, 7)))
74 print(main(list(get_data("day_14_input.txt")), Vector(101, 103)))

Advent of Code 2024 - Day 13

Sun, 22 Dec 2024 09:57:58 +0000

# Part 1

 1from __future__ import annotations
 2
 3import typing
 4import dataclasses
 5import re
 6import heapq
 7
 8@dataclasses.dataclass(order=True)
 9class Vector:
10 x: int
11 y: int
12
13 def __add__(self, b: typing.Self):
14 return Vector(self.x + b.x, self.y + b.y)
15
16
17@dataclasses.dataclass
18class Problem:
19 a: Vector
20 b: Vector
21 solution: Vector
22
23def get_data(path):
24 with open(path) as f:
25 data = f.read()
26
27 problem_data = data.split("\n\n")
28 for problem_datum in problem_data:
29 problem_components = []
30 for line in problem_datum.splitlines():
31 x, y = re.findall(r"(\d+)", line)
32 problem_components.append(Vector(int(x), int(y)))
33 yield Problem(*problem_components)
34
35
36def find_problem_cost(problem: Problem) -> int:
37 pqueue = [(0, 0, 0, Vector(0, 0))]
38
39 visited = set()
40 while pqueue:
41 cost, a_presses, b_presses, pos = heapq.heappop(pqueue)
42
43 key = (a_presses, b_presses)
44 if key in visited:
45 continue
46 visited.add(key)
47
48 if pos == problem.solution:
49 return cost
50
51 if pos.x > problem.solution.x or pos.y > problem.solution.y:
52 continue
53
54 if a_presses > 100 or b_presses > 100:
55 continue
56
57 heapq.heappush(pqueue, (cost + 3, a_presses + 1, b_presses, problem.a + pos))
58 heapq.heappush(pqueue, (cost + 1, a_presses, b_presses + 1, problem.b + pos))
59 return 0
60
61def main(problems):
62 output = 0
63 for problem in problems:
64 cost = find_problem_cost(problem)
65 output += cost
66 return output
67
68if __name__ == "__main__":
69 print(main(get_data("day_13_input_test.txt")))
70 print(main(get_data("day_13_input.txt")))

# Part 2

 1from __future__ import annotations
 2
 3import typing
 4import dataclasses
 5import re
 6
 7@dataclasses.dataclass(order=True)
 8class Vector:
 9 x: int
10 y: int
11
12 def __add__(self, b):
13 if isinstance(b, Vector):
14 return Vector(self.x + b.x, self.y + b.y)
15 elif isinstance(b, int):
16 return Vector(self.x + b, self.y + b)
17 raise Exception(f"Cannot handle {b=}")
18
19 def __sub__(self, b: typing.Self):
20 return Vector(self.x - b.x, self.y - b.y)
21
22
23@dataclasses.dataclass
24class Problem:
25 a: Vector
26 b: Vector
27 solution: Vector
28
29def get_data(path):
30 with open(path) as f:
31 data = f.read()
32
33 problem_data = data.split("\n\n")
34 for problem_datum in problem_data:
35 problem_components = []
36 for line in problem_datum.splitlines():
37 x, y = re.findall(r"(\d+)", line)
38 problem_components.append(Vector(int(x), int(y)))
39 yield Problem(problem_components[0], problem_components[1], problem_components[2] + 10000000000000)
40 # yield Problem(problem_components[0], problem_components[1], problem_components[2])
41
42
43def find_problem_cost(problem: Problem) -> int:
44 numerator = problem.solution.x * problem.a.y - problem.a.x * problem.solution.y
45 denominator = problem.b.x * problem.a.y - problem.b.y * problem.a.x
46 b_presses = numerator / denominator
47 a_presses = (problem.solution.y - b_presses * problem.b.y) / problem.a.y
48 if b_presses != int(b_presses):
49 return 0
50 elif a_presses != int(a_presses):
51 return 0
52 else:
53 return int(a_presses * 3 + b_presses)
54
55def main(problems):
56 output = 0
57 for problem in problems:
58 cost = find_problem_cost(problem)
59 output += cost
60 return output
61
62if __name__ == "__main__":
63 # print(main(get_data("day_13_input_test.txt")))
64 print(main(get_data("day_13_input.txt")))

Advent of Code 2024 - Day 12

Sun, 22 Dec 2024 09:57:46 +0000

# Part 1

 1from __future__ import annotations
 2
 3import dataclasses
 4
 5
 6@dataclasses.dataclass(frozen=True)
 7class Vector:
 8 y: int
 9 x: int
 10
 11 def __add__(self, b):
 12 return Vector(self.y + b.y, self.x + b.x)
 13
 14 def is_valid(self, grid: list[list[int]]) -> bool:
 15 if self.x < 0:
 16 return False
 17 elif self.y < 0:
 18 return False
 19 elif self.x >= len(grid[0]):
 20 return False
 21 elif self.y >= len(grid):
 22 return False
 23 else:
 24 return True
 25
 26
 27def get_data(path: str) -> list[str]:
 28 output = []
 29 with open(path) as f:
 30 for line in f:
 31 output.append(line.strip())
 32 return output
 33
 34
 35def region_search(grid, starting_point: Vector) -> tuple[int, int, set[Vector]]:
 36 """
 37 A function that flows through a given region and returns the
 38 region's area, perimeter, and the (y,x) positions of all plots in
 39 it.
 40 """
 41 area = 0
 42 perimeter = 0
 43
 44 crop = grid[starting_point.y][starting_point.x]
 45
 46 stack = [starting_point]
 47 counted_plots = set()
 48 while stack:
 49 pos = stack.pop()
 50
 51 if pos in counted_plots:
 52 continue
 53
 54 counted_plots.add(pos)
 55
 56 area += 1
 57 perimeter += 4
 58
 59 for delta in [
 60 Vector(1, 0),
 61 Vector(-1, 0),
 62 Vector(0, 1),
 63 Vector(0, -1),
 64 ]:
 65 next_position = pos + delta
 66 if not next_position.is_valid(grid):
 67 continue
 68
 69 if grid[next_position.y][next_position.x] == crop:
 70 perimeter -= 1
 71 stack.append(next_position)
 72
 73 return area, perimeter, counted_plots
 74
 75
 76def main(grid: list[str]) -> int:
 77 checked_plots = set()
 78
 79 area_perimeter = 0
 80 for y, row in enumerate(grid):
 81 for x, _ in enumerate(row):
 82 starting_point = Vector(y, x)
 83 if starting_point in checked_plots:
 84 # If this plot was already contained in a previously
 85 # checked region then skip it.
 86 continue
 87
 88 #
 89 # Find the data about the region starting at this point
 90 #
 91 area, perimeter, region_plots = region_search(grid, starting_point)
 92 area_perimeter += area * perimeter
 93 checked_plots |= region_plots
 94
 95 return area_perimeter
 96
 97
 98if __name__ == "__main__":
 99 # print(main(get_data("day_12_input_test.txt")))
100 print(main(get_data("day_12_input.txt")))

# Part 2

 1from __future__ import annotations
 2
 3import dataclasses
 4
 5
 6@dataclasses.dataclass(frozen=True)
 7class Vector:
 8 y: int
 9 x: int
 10
 11 def __add__(self, b):
 12 return Vector(self.y + b.y, self.x + b.x)
 13
 14 def is_valid(self, grid: list[list[int]]) -> bool:
 15 if self.x < 0:
 16 return False
 17 elif self.y < 0:
 18 return False
 19 elif self.x >= len(grid[0]):
 20 return False
 21 elif self.y >= len(grid):
 22 return False
 23 else:
 24 return True
 25
 26
 27DELTAS = [
 28 Vector(1, 0),
 29 Vector(0, 1),
 30 Vector(-1, 0),
 31 Vector(0, -1)
 32]
 33
 34
 35def rotate(vector):
 36 return DELTAS[(DELTAS.index(vector) + 1) % len(DELTAS)]
 37
 38
 39def get_data(path: str) -> list[str]:
 40 output = []
 41 with open(path) as f:
 42 for line in f:
 43 output.append(line.strip())
 44 return output
 45
 46
 47def region_search(grid, starting_point) -> tuple[int, int, set[Vector]]:
 48 counted_plots = set()
 49 area = 0
 50 sides = set()
 51
 52 stack = [starting_point]
 53 while stack:
 54 pos = stack.pop()
 55 crop = grid[pos.y][pos.x]
 56
 57 if pos in counted_plots:
 58 continue
 59
 60 counted_plots.add(pos)
 61
 62 area += 1
 63
 64 potential_sides = {(pos, delta) for delta in DELTAS}
 65 for delta in DELTAS:
 66 next_position = pos + delta
 67 if not next_position.is_valid(grid):
 68 continue
 69
 70 if grid[next_position.y][next_position.x] == crop:
 71 stack.append(next_position)
 72 if delta.x:
 73 potential_sides.remove((pos, delta))
 74 else:
 75 potential_sides.remove((pos, delta))
 76
 77
 78 sides |= potential_sides
 79
 80 bad_sides = set()
 81 for side in sides:
 82 pos, direction = side
 83 if (pos + rotate(direction), direction) in sides:
 84 bad_sides.add(side)
 85
 86 return area, len(sides - bad_sides), counted_plots
 87
 88
 89def main(grid: list[str]) -> int:
 90 checked_plots = set()
 91
 92 area_perimeter = 0
 93 for y, row in enumerate(grid):
 94 for x, _ in enumerate(row):
 95 starting_point = Vector(y, x)
 96 if starting_point in checked_plots:
 97 # If this plot was already contained in a previously
 98 # checked region then skip it.
 99 continue
100
101 # Find the data about the region starting at this point
102 #
103 area, sides, region_plots = region_search(grid, starting_point)
104 area_perimeter += area * sides
105 checked_plots |= region_plots
106
107 return area_perimeter
108
109
110if __name__ == "__main__":
111 # print(main(get_data("day_12_input_test.txt")))
112 print(main(get_data("day_12_input.txt")))

Advent of Code 2024 - Day 11

Sun, 22 Dec 2024 09:57:31 +0000

# Part 1

 1from __future__ import annotations
 2
 3import math
 4import dataclasses
 5import typing
 6
 7@dataclasses.dataclass
 8class Node:
 9 value: int
10 nxt: Node | None = None
11
12
13def get_data(path: str) -> typing.Iterator[int]:
14 with open(path) as f:
15 yield from (int(x) for x in f.read().strip().split())
16
17def blink(node):
18 while node:
19 match node.value:
20 case 0:
21 node.value = 1
22 case it if int(math.log(it, 10)) % 2 == 1:
23 digits = int(math.log(it, 10)) + 1
24 leading_digits = int(str(it)[:digits // 2])
25 trailing_digits = int(str(it)[digits // 2:])
26
27 new_node = Node(trailing_digits, node.nxt)
28 node.nxt = new_node
29 node.value = leading_digits
30 node = new_node
31 case _:
32 node.value *= 2024
33 node = node.nxt
34
35def main(data: typing.Iterator[int]) -> int:
36 front_node = Node(next(data))
37 last_node = front_node
38 for datum in data:
39 last_node.nxt = Node(datum)
40 last_node = last_node.nxt
41
42 for _ in range(25):
43 blink(front_node)
44
45 node_count = 0
46 node = front_node
47 while node:
48 node_count += 1
49 node = node.nxt
50
51 return node_count
52
53
54if __name__ == "__main__":
55 print(main(get_data("day_11_input.txt")))

# Part 2

 1from __future__ import annotations
 2
 3import math
 4import collections
 5import typing
 6
 7def get_data(path: str) -> typing.Iterator[int]:
 8 with open(path) as f:
 9 yield from (int(x) for x in f.read().strip().split())
10
11def blink(counter: dict[int, int]) -> dict[int, int]:
12 next_counter = collections.defaultdict(int)
13 for k, count in counter.items():
14 match k:
15 case 0:
16 next_counter[1] += count
17 case it if int(math.log(it, 10)) % 2 == 1:
18 digits = int(math.log(it, 10)) + 1
19 leading_digits = int(str(it)[:digits // 2])
20 trailing_digits = int(str(it)[digits // 2:])
21 next_counter[leading_digits] += count
22 next_counter[trailing_digits] += count
23 case _:
24 next_counter[k * 2024] += count
25
26 return next_counter
27
28def main(data: typing.Iterator[int]) -> int:
29 counter = collections.defaultdict(int)
30
31 for datum in data:
32 counter[datum] += 1
33
34 for _ in range(75):
35 counter = blink(counter)
36
37 return sum(counter.values())
38
39
40if __name__ == "__main__":
41 print(main(get_data("day_11_input.txt")))

Advent of Code 2024 - Day 10

Sun, 22 Dec 2024 09:57:23 +0000

# Part 1

from future import annotations

import dataclasses import typing

@dataclasses.dataclass(frozen=True) class Vector: y: int x: int

def __add__(self, b):
return Vector(self.y + b.y, self.x + b.x)
def is_valid(self, grid: list[list[int]]) -> bool:
if self.x < 0:
return False
elif self.y < 0:
return False
elif self.x >= len(grid[0]):
return False
elif self.y >= len(grid):
return False
else:
return True

def get_data(path: str) -> typing.Iterator[list[int]]: with open(path) as f: for line in f: yield [int(x) for x in line.strip()]

Advent of Code 2024 - Day 9

Sun, 22 Dec 2024 09:57:16 +0000

# Part 1

 1from __future__ import annotations
 2
 3def get_data(path: str) -> str:
 4 with open(path) as f:
 5 return f.read().strip()
 6
 7def main(data: str):
 8 intermediate = []
 9 is_disk = False
10 counter = -1
11 for char in data:
12 is_disk = not(is_disk)
13 if is_disk:
14 counter += 1
15 intermediate.extend([str(counter)] * int(char))
16 else:
17 intermediate.extend(['.'] * int(char))
18
19 left = 0
20 right = len(intermediate) - 1
21 while True:
22 while intermediate[left] != ".":
23 left += 1
24 while intermediate[right] == ".":
25 right -= 1
26 if left >= right:
27 break
28 intermediate[left] = intermediate[right]
29 intermediate[right] = "."
30
31 total = 0
32 for base, char in enumerate(intermediate):
33 if char == ".":
34 break
35 total += int(char) * base
36
37 return total
38
39
40
41if __name__ == "__main__":
42 # print(main(get_data("day_9_input_test.txt")))
43 print(main(get_data("day_9_input.txt")))

# Part 2

 1from __future__ import annotations
 2
 3import dataclasses
 4
 5
 6def get_data(path: str) -> str:
 7 with open(path) as f:
 8 return f.read().strip()
 9
10@dataclasses.dataclass
11class Region:
12 is_disk: bool
13 size: int
14 name: str = "."
15
16def main(data: str):
17 intermediate: list[Region] = []
18 is_disk = False
19 counter = -1
20 for datum in data:
21 is_disk = not(is_disk)
22 if is_disk:
23 counter += 1
24 intermediate.append(Region(True, int(datum), str(counter)))
25 else:
26 intermediate.append(Region(False, int(datum)))
27
28 for i in range(len(intermediate) - 1, -1, -1):
29 disk_region = intermediate[i]
30 if disk_region.is_disk:
31 for j in range(i):
32 free_region = intermediate[j]
33 if not free_region.is_disk and free_region.size >= disk_region.size:
34 intermediate.insert(j, disk_region)
35 free_region.size -= disk_region.size
36 intermediate[i + 1] = Region(False, disk_region.size)
37 break
38
39 final_intermediate = []
40 for region in intermediate:
41 if region.size:
42 final_intermediate.extend([region.name] * region.size)
43 print("".join(final_intermediate))
44
45 total = 0
46 for base, char in enumerate(final_intermediate):
47 if char == ".":
48 continue
49 total += int(char) * base
50
51 return total
52
53
54
55if __name__ == "__main__":
56 print(main(get_data("day_9_input_test.txt")))
57 # print(main(get_data("day_9_input.txt")))

# Part 2 Linked List

 1from __future__ import annotations
 2
 3import dataclasses
 4
 5
 6def get_data(path: str) -> str:
 7 with open(path) as f:
 8 return f.read().strip()
 9
10@dataclasses.dataclass
11class Region:
12 is_disk: bool
13 size: int
14 name: str = "."
15 prev_r: Region | None = None
16 next_r: Region | None = None
17
18def main(data: str):
19 first_region = None
20 last_region = None
21 is_disk = False
22 counter = -1
23
24 for datum in data:
25 is_disk = not(is_disk)
26 if is_disk:
27 counter += 1
28 if first_region and last_region:
29 last_region.next_r = Region(True, int(datum), str(counter), last_region)
30 last_region = last_region.next_r
31 else:
32 first_region = Region(True, int(datum), str(counter))
33 last_region = first_region
34 else:
35 assert last_region
36 last_region.next_r = Region(False, int(datum), prev_r=last_region)
37 last_region = last_region.next_r
38
39 assert first_region
40 assert last_region
41
42 right = last_region
43 while right:
44 next_right = right.prev_r
45
46 if right.is_disk:
47 left = first_region
48 while left and left != right:
49 #
50 # We've found a spot where an insertion works
51 #
52 if not left.is_disk and left.size >= right.size:
53 left.size -= right.size
54
55 #
56 # Insert a new empty region where the right region was
57 #
58 new_region = Region(False, right.size, prev_r=right.prev_r, next_r=right.next_r)
59 if right.next_r:
60 right.next_r.prev_r = new_region
61 if right.prev_r:
62 right.prev_r.next_r = new_region
63
64 #
65 # Insert the right_region before the left_region
66 #
67 right.next_r = left
68 right.prev_r = left.prev_r
69 if left.prev_r:
70 left.prev_r.next_r = right
71 left.prev_r = right
72
73 break
74 left = left.next_r
75
76 right = next_right
77
78
79 final_intermediate = []
80 region = first_region
81 while region:
82 if region.size:
83 final_intermediate.extend([region.name] * region.size)
84 region = region.next_r
85
86 total = 0
87 for base, char in enumerate(final_intermediate):
88 if char == ".":
89 continue
90 total += int(char) * base
91
92 return total
93
94
95
96if __name__ == "__main__":
97 # print(main(get_data("day_9_input_test.txt")))
98 print(main(get_data("day_9_input.txt")))

Advent of Code 2024 - Day 8

Wed, 18 Dec 2024 12:42:01 +0000

# Part 1

 1from __future__ import annotations
 2
 3import typing
 4import collections
 5import dataclasses
 6import itertools
 7
 8
 9@dataclasses.dataclass(frozen=True)
10class Vector:
11 y: int
12 x: int
13
14 def __sub__(self, b):
15 return Vector(self.y - b.y, self.x - b.x)
16
17 def __add__(self, b):
18 return Vector(self.y + b.y, self.x + b.x)
19
20 def is_valid(self, grid: list[str]) -> bool:
21 if self.x < 0:
22 return False
23 elif self.y < 0:
24 return False
25 elif self.x >= len(grid[0]):
26 return False
27 elif self.y >= len(grid):
28 return False
29 else:
30 return True
31
32
33def get_data(path: str) -> typing.Iterable[str]:
34 with open(path) as f:
35 for line in f:
36 yield line.strip()
37
38
39def find_anode(node1: Vector, node2: Vector) -> typing.Iterable[Vector]:
40 difference = node1 - node2
41 yield node1 + difference
42 yield node2 - difference
43
44
45def find_anodes(nodes: set) -> typing.Iterable[Vector]:
46 for chosen_nodes in itertools.combinations(nodes, 2):
47 yield from find_anode(*chosen_nodes)
48
49def main(grid: list[str]) -> int:
50 #
51 # Find and group all similar nodes
52 #
53 nodes = collections.defaultdict(set)
54 for y, row in enumerate(grid):
55 for x, char in enumerate(row):
56 if char != ".":
57 nodes[char].add(Vector(y, x))
58
59 #
60 # Calculate all anodes
61 #
62 all_nodes = set()
63 anodes = set()
64 for _, node_positions in nodes.items():
65 all_nodes.update(node_positions)
66 for anode in find_anodes(node_positions):
67 if anode.is_valid(grid):
68 anodes.add(anode)
69
70 #
71 # Find all anodes where there is not already a node
72 #
73 return len(anodes - all_nodes | anodes)
74
75
76if __name__ == '__main__':
77 print(main(list(get_data("day_8_input.txt"))))

# Part 2

 1from __future__ import annotations
 2
 3import typing
 4import collections
 5import dataclasses
 6import itertools
 7
 8
 9@dataclasses.dataclass(frozen=True)
10class Vector:
11 y: int
12 x: int
13
14 def __sub__(self, b):
15 return Vector(self.y - b.y, self.x - b.x)
16
17 def __add__(self, b):
18 return Vector(self.y + b.y, self.x + b.x)
19
20 def is_valid(self, grid: list[str]) -> bool:
21 if self.x < 0:
22 return False
23 elif self.y < 0:
24 return False
25 elif self.x >= len(grid[0]):
26 return False
27 elif self.y >= len(grid):
28 return False
29 else:
30 return True
31
32
33def get_data(path: str) -> typing.Iterable[str]:
34 with open(path) as f:
35 for line in f:
36 yield line.strip()
37
38
39def find_anode(grid: list[str], node1: Vector, node2: Vector) -> typing.Iterable[Vector]:
40 difference = node1 - node2
41
42 #
43 # The node itself is an anode
44 #
45 yield node1
46
47 #
48 # All nodes that are in the _positive_ line of the difference
49 #
50 new_node = node1 + difference
51 while new_node.is_valid(grid):
52 yield new_node
53 new_node += difference
54
55 #
56 # All nodes that are in the _negative_ line of the difference
57 #
58 new_node = node1 - difference
59 while new_node.is_valid(grid):
60 yield new_node
61 new_node -= difference
62
63
64def find_anodes(grid: list[str], nodes: set) -> typing.Iterable[Vector]:
65 for chosen_nodes in itertools.combinations(nodes, 2):
66 yield from find_anode(grid, *chosen_nodes)
67
68
69def main(grid: list[str]) -> int:
70 #
71 # Find and group all similar nodes
72 #
73 nodes = collections.defaultdict(set)
74 for y, row in enumerate(grid):
75 for x, char in enumerate(row):
76 if char != ".":
77 nodes[char].add(Vector(y, x))
78
79 #
80 # Calculate all anodes
81 #
82 all_nodes = set()
83 anodes = set()
84 for _, node_positions in nodes.items():
85 all_nodes.update(node_positions)
86 for anode in find_anodes(grid, node_positions):
87 anodes.add(anode)
88
89 #
90 # Count all anodes even those that are on top of existing nodes
91 #
92 return len(anodes)
93
94
95if __name__ == '__main__':
96 print(main(list(get_data("day_8_input.txt"))))

Advent of Code 2024 - Day 7

Tue, 17 Dec 2024 22:07:20 +0000

# Part 1

 1from __future__ import annotations
 2
 3import typing
 4
 5
 6def get_data(path: str) -> typing.Iterable[tuple[int, list[int]]]:
 7 with open(path) as f:
 8 for line in f:
 9 line = line.strip()
10 goal, nums = line.split(":")
11 yield int(goal), [int(n) for n in nums.strip().split()]
12
13
14def is_match(goal: int, inputs: list[int]) -> bool:
15 #
16 # Set the initial start point
17 #
18 stack: list[tuple[int, int]]= [(inputs[0], 1)]
19 while stack:
20 cur, depth = stack.pop()
21 #
22 # We've exhausted the inputs
23 #
24 if depth == len(inputs):
25 # We've reach our goal, celebrate
26 if cur == goal:
27 return True
28 # We aren't yet at the goal, this path was a failure
29 else:
30 continue
31
32 #
33 # We've overshot no point in continuing down this path.
34 #
35 if cur > goal:
36 continue
37
38 stack.append((cur * inputs[depth], depth + 1))
39 stack.append((cur + inputs[depth], depth + 1))
40
41 return False
42
43
44def main(data: typing.Iterable[tuple[int, list[int]]]) -> int:
45 output = 0
46 for goal, inputs in data:
47 if is_match(goal, inputs):
48 output += goal
49
50 return output
51
52
53if __name__ == '__main__':
54 print(main(get_data("day_7_input.txt")))

# Part 2

 1def get_data(path):
 2 with open(path) as f:
 3 for line in f:
 4 line = line.strip()
 5 goal, nums = line.split(":")
 6 yield int(goal), [int(n) for n in nums.strip().split()]
 7
 8
 9def is_match(goal, inputs):
10 stack = [(inputs[0], 1)]
11 while stack:
12 cur, depth = stack.pop()
13 if depth == len(inputs):
14 if cur == goal:
15 return True
16 else:
17 continue
18 if cur > goal:
19 continue
20
21 stack.append((cur * inputs[depth], depth + 1))
22 stack.append((cur + inputs[depth], depth + 1))
23 stack.append((int(str(cur) + str(inputs[depth])), depth + 1))
24
25 return False
26
27
28def main(data) -> int:
29 output = 0
30 for goal, inputs in data:
31 if is_match(goal, inputs):
32 output += goal
33 return output
34
35
36if __name__ == '__main__':
37 print(main(get_data("day_7_input.txt")))

Advent of Code 2024 - Day 6

Tue, 17 Dec 2024 22:07:12 +0000

# Part 1

 1import dataclasses
 2
 3
 4@dataclasses.dataclass
 5class Vector:
 6 y: int
 7 x: int
 8
 9
10ROTATE = [
11 Vector(-1, 0),
12 Vector(0, 1),
13 Vector(1, 0),
14 Vector(0, -1),
15]
16
17
18def get_data(path):
19 with open(path) as f:
20 return [list(row) for row in f.read().strip().split()]
21
22
23def main(grid) -> int:
24 #
25 # Find the dude's starting position
26 #
27 pos = Vector(0, 0)
28 for y, row in enumerate(grid):
29 for x, c in enumerate(row):
30 if c == "^":
31 pos = Vector(y, x)
32
33 #
34 # Have the starting tile be considered marked
35 #
36 checked_tiles = 1
37 grid[pos.y][pos.x] = "X"
38
39 #
40 # Have the dude walk
41 #
42 direction = Vector(-1, 0)
43 while True:
44 next_pos = Vector(pos.y + direction.y, pos.x + direction.x)
45 if not (next_pos.x >= 0 and next_pos.y >= 0 and next_pos.x < len(grid[0]) and next_pos.y < len(grid)):
46 break
47 next_tile = grid[next_pos.y][next_pos.x]
48
49 if next_tile == "#":
50 direction = ROTATE[(ROTATE.index(direction) + 1) % len(ROTATE)]
51 continue
52 elif next_tile == ".":
53 grid[next_pos.y][next_pos.x] = "X"
54 checked_tiles += 1
55 pos = next_pos
56
57 for row in grid:
58 print("".join(row))
59 return checked_tiles
60
61
62
63if __name__ == '__main__':
64 print(main(get_data("day_6_input.txt")))

# Part 2

 1import dataclasses
 2import copy
 3
 4@dataclasses.dataclass(frozen=True)
 5class Vector:
 6 y: int
 7 x: int
 8
 9ROTATE = [
10 Vector(-1, 0),
11 Vector(0, 1),
12 Vector(1, 0),
13 Vector(0, -1),
14]
15
16
17def get_data(path):
18 with open(path) as f:
19 return [list(row) for row in f.read().strip().split()]
20
21
22def is_loop(grid) -> bool:
23 #
24 # Find the dude's starting position
25 #
26 pos = Vector(0, 0)
27 for y, row in enumerate(grid):
28 for x, c in enumerate(row):
29 if c == "^":
30 pos = Vector(y, x)
31
32
33 #
34 # Have the dude walk
35 #
36 visited = set()
37 direction = Vector(-1, 0)
38 grid[pos.y][pos.x] = "."
39
40 while True:
41 #
42 # If the guard has walked here before then quit
43 #
44 if (pos, direction) in visited:
45 return True
46 visited.add((pos, direction))
47
48 #
49 # If we'd walk off the edge then we ain't looping
50 #
51 next_pos = Vector(pos.y + direction.y, pos.x + direction.x)
52 if not (next_pos.x >= 0 and next_pos.y >= 0 and next_pos.x < len(grid[0]) and next_pos.y < len(grid)):
53 return False
54
55 #
56 # Decide what to do next by looking at the next tile
57 #
58 next_tile = grid[next_pos.y][next_pos.x]
59 if next_tile == "#":
60 direction = ROTATE[(ROTATE.index(direction) + 1) % len(ROTATE)]
61 else:
62 pos = next_pos
63
64
65def main(grid):
66 output = 0
67 #
68 # Place an obstacle at every single grid position and check if it
69 # leads to a looping guard
70 #
71 for y in range(len(grid)):
72 for x in range(len(grid[0])):
73 if grid[y][x] == "#":
74 continue
75 new_grid = copy.deepcopy(grid)
76 new_grid[y][x] = "#"
77 output += int(is_loop(new_grid))
78 return output
79
80
81if __name__ == '__main__':
82 print(main(get_data("day_6_input_test_2.txt")))

Advent of Code 2024 - Day 5

Tue, 17 Dec 2024 22:07:05 +0000

# Part 1

 1from __future__ import annotations
 2
 3import collections
 4
 5
 6def get_data() -> tuple[dict[str, list[str]], list[list[str]]]:
 7 with open("day_5_input.txt") as f:
 8 data = f.read()
 9
10 raw_rules, raw_rows = data.split("\n\n")
11
12 rules = collections.defaultdict(list)
13 for rule_line in raw_rules.strip().split():
14 k, y = rule_line.split("|")
15 rules[k].append(y)
16
17 rows = []
18 for row in raw_rows.strip().split():
19 rows.append(row.split(","))
20
21 return rules, rows
22
23
24def valid_row(rules: dict[str, list[str]], row: list[str]) -> bool:
25 row_data = {}
26 for i, page in enumerate(row):
27 row_data[page] = i
28
29 for before, afters in rules.items():
30 for after in afters:
31 if before in row_data and after in row_data:
32 if row_data[before] > row_data[after]:
33 return False
34 return True
35
36
37def main(rules: dict[str, list[str]], rows: list[list[str]]) -> int:
38 output = 0
39 for row in rows:
40 if valid_row(rules, row):
41 output += int(row[len(row) // 2])
42 return output
43
44
45if __name__ == "__main__":
46 print(main(*get_data()))

# Part 2

 1from __future__ import annotations
 2
 3import collections
 4
 5
 6def get_data() -> tuple[dict[str, list[str]], list[list[str]]]:
 7 with open("day_5_input_test.txt") as f:
 8 data = f.read()
 9
10 raw_rules, raw_rows = data.split("\n\n")
11
12 rules = collections.defaultdict(list)
13 for rule_line in raw_rules.strip().split():
14 k, y = rule_line.split("|")
15 rules[k].append(y)
16
17 rows = []
18 for row in raw_rows.strip().split():
19 rows.append(row.split(","))
20
21 return rules, rows
22
23
24def valid_row(rules: dict[str, list[str]], row: list[str]) -> bool:
25 row_data = {}
26 for i, page in enumerate(row):
27 row_data[page] = i
28
29 for before, afters in rules.items():
30 for after in afters:
31 if before in row_data and after in row_data:
32 if row_data[before] > row_data[after]:
33 return False
34 return True
35
36
37def fix_row(rules: dict[str, list[str]], row: list[str]) -> list[str]:
38 while not valid_row(rules, row):
39 row_data = {}
40 for i, page in enumerate(row):
41 row_data[page] = i
42
43 for before, afters in rules.items():
44 for after in afters:
45 if before in row_data and after in row_data:
46 if row_data[before] > row_data[after]:
47 row[row_data[before]], row[row_data[after]] = row[row_data[after]], row[row_data[before]]
48 row_data[before], row_data[after] = row_data[after], row_data[before]
49 return row
50
51
52def main(rules: dict[str, list[str]], rows: list[list[str]]) -> int:
53 output = 0
54 for row in rows:
55 if not valid_row(rules, row):
56 row = fix_row(rules, row)
57 output += int(row[len(row) // 2])
58 return output
59
60
61if __name__ == "__main__":
62 print(main(*get_data()))

Advent of Code 2024 - Day 4

Tue, 17 Dec 2024 22:06:56 +0000

# Part 1

 1from __future__ import annotations
 2
 3import collections
 4import dataclasses
 5
 6@dataclasses.dataclass
 7class TentativeMatch:
 8 desired_letter: str
 9 y: int
10 x: int
11 dy: int
12 dx: int
13
14def get_data():
15 data = []
16 with open("day_4_input.txt") as f:
17 for line in f:
18 data.append(line.strip())
19 return data
20
21def main(grid):
22 queue = collections.deque()
23 for y, row in enumerate(grid):
24 for x, _ in enumerate(row):
25 queue.append(TentativeMatch("X", y, x, 0, 0))
26
27 total = 0
28 while queue:
29 tm = queue.popleft()
30 if tm.y < 0 or tm.y >= len(grid):
31 continue
32 if tm.x < 0 or tm.x >= len(grid[0]):
33 continue
34
35 current_char = grid[tm.y][tm.x]
36
37 if current_char != tm.desired_letter:
38 continue
39
40 match current_char:
41 case 'X':
42 for dy, dx in [
43 [-1, -1],
44 [-1, 0],
45 [-1, 1],
46 [0, -1],
47 [0, 1],
48 [1, -1],
49 [1, 0],
50 [1, 1],
51 ]:
52 queue.append(TentativeMatch("M", tm.y + dy, tm.x + dx, dy, dx))
53 case 'M':
54 queue.append(TentativeMatch("A", tm.y + tm.dy, tm.x + tm.dx, tm.dy, tm.dx))
55 case "A":
56 queue.append(TentativeMatch("S", tm.y + tm.dy, tm.x + tm.dx, tm.dy, tm.dx))
57 case "S":
58 total += 1
59 case _:
60 pass
61
62 return total
63
64
65if __name__ == "__main__":
66 print(f"{main(get_data()) = }")

# Part 2

 1from __future__ import annotations
 2
 3import collections
 4import dataclasses
 5
 6@dataclasses.dataclass
 7class TentativeMatch:
 8 desired_letter: str
 9 y: int
10 x: int
11
12def get_data():
13 data = []
14 with open("day_4_input_2.txt") as f:
15 for line in f:
16 data.append(line.strip())
17 return data
18
19def main(grid):
20 queue = collections.deque()
21 for y in range(1, len(grid) - 1):
22 for x in range(1, len(grid[0]) - 1):
23 queue.append(TentativeMatch("A", y, x))
24
25 total = 0
26 while queue:
27 tm = queue.popleft()
28
29 current_char = grid[tm.y][tm.x]
30
31 if current_char != tm.desired_letter:
32 continue
33
34 valid_1 = (grid[tm.y - 1][tm.x - 1], grid[tm.y + 1][tm.x + 1]) in [("M", "S"), ("S", "M")]
35 valid_2 = (grid[tm.y - 1][tm.x + 1], grid[tm.y + 1][tm.x - 1]) in [("M", "S"), ("S", "M")]
36
37 if valid_1 and valid_2:
38 total += 1
39
40 return total
41
42
43if __name__ == "__main__":
44 print(f"{main(get_data()) = }")

Advent of Code 2024 - Day 3

Tue, 17 Dec 2024 22:06:49 +0000

# Part 1

 1import re
 2
 3def get_data():
 4 with open("day_3_input.txt") as f:
 5 return f.read().strip()
 6
 7def get_mults(data):
 8 regex = r"mul\((\d+),(\d+)\)"
 9 for match in re.finditer(regex, data):
10 yield [int(match[0]), int(match[1])]
11
12def main(data):
13 output = 0
14 for x, y in get_mults(data):
15 output += x * y
16 return output
17
18if __name__ == "__main__":
19 print(f"{main(get_data()) = }")

# Part 2

 1import re
 2
 3def get_data():
 4 with open("day_3_input.txt") as f:
 5 return f.read().strip()
 6
 7def get_mults(data):
 8 regex = r"mul\((\d+),(\d+)\)|do\(\)|don't\(\)"
 9 enabled = True
10 for m in re.finditer(regex, data):
11 match m.group(0):
12 case "do()":
13 enabled = True
14 case "don't()":
15 enabled = False
16 case _:
17 if enabled:
18 yield [int(m.group(1)), int(m.group(2))]
19
20def main(data):
21 output = 0
22 for x, y in get_mults(data):
23 output += x * y
24 return output
25
26if __name__ == "__main__":
27 print(f"{main(get_data()) = }")

Advent of Code 2024 - Day 2

Tue, 17 Dec 2024 20:16:06 +0000

# Part 1

 1def get_data(path):
 2 with open(path) as f:
 3 for line in f:
 4 line = line.strip()
 5 yield [int(x) for x in line.split()]
 6
 7
 8def is_safe(report):
 9 is_decending = report[0] > report[1]
10
11 for i, j in zip(report[:-1], report[1:]):
12 if is_decending:
13 if not (1 <= i - j <= 3):
14 return False
15 else:
16 if not (1 <= j - i <= 3):
17 return False
18
19 return True
20
21def main(data):
22 safe_reports = 0
23 for report in data:
24 if is_safe(report):
25 safe_reports += 1
26 return safe_reports
27
28
29if __name__ == '__main__':
30 print(main(get_data("day_2_input.txt")))

# Part 2

 1def get_data():
 2 with open("day_2_input.txt") as f:
 3 for line in f:
 4 line = line.strip()
 5 yield [int(x) for x in line.split()]
 6
 7
 8def is_safe(report):
 9 is_decending = report[0] > report[1]
10
11 for i, j in zip(report[:-1], report[1:]):
12 if is_decending:
13 if not (1 <= i - j <= 3):
14 return False
15 else:
16 if not (1 <= j - i <= 3):
17 return False
18
19 return True
20
21def any_safe(report):
22 for i in range(len(report)):
23 new_report = report[:i] + report[i + 1:]
24 if is_safe(new_report):
25 return True
26 return False
27
28def main(data):
29 safe_reports = 0
30 for report in data:
31 if any_safe(report):
32 safe_reports += 1
33 return safe_reports
34
35
36if __name__ == '__main__':
37 print(main(get_data()))

Advent of Code 2024 - Day 1

Tue, 17 Dec 2024 20:14:50 +0000

# Part 1

 1def get_data(path):
 2 list_1 = []
 3 list_2 = []
 4 with open(path) as f:
 5 for line in f:
 6 item_1, item_2 = line.split()
 7 list_1.append(int(item_1))
 8 list_2.append(int(item_2))
 9 return list_1, list_2
10
11def main(list_1, list_2):
12 output = 0
13 for element_1, element_2 in zip(sorted(list_1), sorted(list_2)):
14 output += abs(element_2 - element_1)
15 return output
16
17if __name__ == "__main__":
18 print(main(*get_data("day_1_input.txt")))

# Part 2

 1import collections
 2
 3def get_data(path):
 4 list_1 = []
 5 list_2 = []
 6 with open(path) as f:
 7 for line in f:
 8 item_1, item_2 = line.split()
 9 list_1.append(int(item_1))
10 list_2.append(int(item_2))
11 return list_1, list_2
12
13def main(list_1, list_2):
14 counter = collections.Counter(list_2)
15
16 output = 0
17 for element_1 in list_1:
18 if element_1 in counter:
19 output += element_1 * counter[element_1]
20 return output
21
22if __name__ == "__main__":
23 print(main(*get_data("day_1_input.txt")))

À la Mode - corfu, cape, and completion-preview

Thu, 27 Jun 2024 11:28:20 +0000

Over the last few years there has been an ever greater push towards making smaller Emacs packages that are more tightly integrated with the core Emacs ecosystem. In large part this is due to the massive ongoing efforts of the Emacs maintainers and the community whose enhancements make these packages easier to write and integrate without needing to reinvent the wheel.

Some of the changes that have happened include: