Add 2023/18 py

Author: erikw

2023/18/README.md

@@ -0,0 +1,12 @@
+# Advent of Code - 2023 Day 18
+Here are my solutions to this puzzle.
+
+* Problem instructions: [adventofcode.com/2023/day/18](https://adventofcode.com/2023/day/18)
+* Input: [adventofcode.com/2023/day/18/input](https://adventofcode.com/2023/day/18/input)
+
+Fetch input by exporting `$AOC_SESSION` in your shell and then:
+```bash
+curl -OJLsb session=$AOC_SESSION adventofcode.com/2023/day/18/input
+```
+
+or run `fetch_input.sh` in this directory.

2023/18/fetch_input.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env sh
+# Make sure $AOC_SESSION is exported before running this script.
+
+curl --remote-name --remote-header-name --silent --fail -A 'https://erikw.me/contact' --cookie "session=$AOC_SESSION" "https://adventofcode.com/2023/day/18/input"
+test "$?" -eq 0 && echo "Fetched input" && exit 0 || echo "Failed to fetch input" && exit 1

2023/18/input1.0

@@ -0,0 +1,14 @@
+R 6 (#70c710)
+D 5 (#0dc571)
+L 2 (#5713f0)
+D 2 (#d2c081)
+R 2 (#59c680)
+D 2 (#411b91)
+L 5 (#8ceee2)
+U 2 (#caa173)
+L 1 (#1b58a2)
+U 2 (#caa171)
+R 2 (#7807d2)
+U 3 (#a77fa3)
+L 2 (#015232)
+U 2 (#7a21e3)

2023/18/instructions.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL = https://adventofcode.com/2023/day/18

2023/18/output1.0

@@ -0,0 +1 @@
+62

2023/18/output2.0

@@ -0,0 +1 @@
+952408144115

2023/18/part1.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+import fileinput
+from pprint import pprint
+
+SYM_TRENCH = "#"
+SYM_TERRAIN = "."
+
+DIR_DELTA = {
+    "R": 1j,
+    "L": -1j,
+    "U": -1,
+    "D": 1,
+}
+
+
+def find_trench_loop():
+    pos = (
+        0  # Let's call the starting point origin, and make it at (0,0) for simplicity.
+    )
+    trench_loop: complex = {pos}
+    row_min, col_min = 0, 0
+    row_max, col_max = 0, 0
+    for line in fileinput.input():
+        dir, meters, rgb = line.rstrip("\n").split()
+        meters = int(meters)
+        rgb = rgb.strip("(#)")
+
+        delta = DIR_DELTA[dir]
+        for _ in range(meters):
+            pos += delta
+            trench_loop.add(pos)
+            row_min, row_max = min(row_min, pos.real), max(row_max, pos.real)
+            col_min, col_max = min(col_min, pos.imag), max(col_max, pos.imag)
+    return (
+        trench_loop,
+        (int(row_min), int(row_max) + 1),
+        (int(col_min), int(col_max) + 1),
+    )
+
+
+def raytrace_count(trench_loop, col_dim, pos):
+    count = 0
+    in_lagoon = False
+    found_trench_up = False
+    found_trench_down = False
+
+    # Save quite some CPU time by shooting ray in closest direction left or right.
+    if pos.imag < col_dim[0] + (col_dim[1] - col_dim[0]) / 2:
+        steps = range(int(pos.imag), col_dim[0] - 1, -1)
+        dir = DIR_DELTA["L"]
+    else:
+        steps = range(int(pos.imag), col_dim[1])
+        dir = DIR_DELTA["R"]
+
+    for _ in steps:
+        pos += dir
+
+        # It counts as crossing the shape (lagoon loop) only if the shape goes up and down from this line, otherwise it's not really crossing the edge like a "^" shape.
+        pos_up = pos + DIR_DELTA["U"]
+        pos_down = pos + DIR_DELTA["D"]
+        if pos_up in trench_loop:
+            found_trench_up = True
+        if pos_down in trench_loop:
+            found_trench_down = True
+
+        if pos in trench_loop:
+            in_lagoon = True
+        elif in_lagoon:
+            in_lagoon = False
+            if found_trench_up and found_trench_down:
+                count += 1
+                found_trench_up = False
+                found_trench_down = False
+    return count
+
+
+def dig_out_interior(trench_loop, row_dim, col_dim):
+    lagoon_map = trench_loop.copy()
+    for row in range(*row_dim):
+        for col in range(*col_dim):
+            pos = complex(row, col)
+            if (
+                pos not in trench_loop
+                and raytrace_count(trench_loop, col_dim, pos) % 2 == 1
+            ):
+                lagoon_map.add(pos)
+    return lagoon_map
+
+
+def print_map(dig_map, row_dim, col_dim):
+    for row in range(*row_dim):
+        for col in range(*col_dim):
+            pos = complex(row, col)
+            print(SYM_TRENCH if pos in dig_map else SYM_TERRAIN, end="")
+        print()
+
+
+def main():
+    trench_loop, row_dim, col_dim = find_trench_loop()
+    # print_map(trench_loop, row_dim, col_dim)
+
+    lagoon_map = dig_out_interior(trench_loop, row_dim, col_dim)
+    # print("\n\n==== After dig out")
+    # print_map(lagoon_map, row_dim, col_dim)
+
+    print(len(lagoon_map))
+
+
+if __name__ == "__main__":
+    main()

2023/18/part2.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+import fileinput
+
+DIR_DELTA = {
+    0: (0, 1),
+    1: (1, 0),
+    2: (0, -1),
+    3: (-1, 0),
+}
+
+
+def find_trench_loop():
+    trench_loop: list[complex] = []
+
+    x, y = 0, 0
+    for line in fileinput.input():
+        rgb = line.rstrip("\n").split()[-1].strip("(#)")
+        meters, dir = (int(x, 16) for x in (rgb[:-1], rgb[-1]))
+        delta = DIR_DELTA[dir]
+
+        x, y = x + delta[0] * meters, y + delta[1] * meters
+        trench_loop.append((x, y))
+
+    return trench_loop
+
+
+def loop_length(loop):
+    len = 0
+    pairs = tuple(zip(loop, loop[1:] + [loop[0]]))
+    for (x1, y1), (x2, y2) in pairs:
+        len += abs(x2 - x1) + abs(y2 - y1)  # Manhattan distance
+    return len
+
+
+def polygon_area(loop):
+    # https://en.wikipedia.org/wiki/Shoelace_formula
+    pairs = tuple(zip(loop, loop[1:] + [loop[0]]))
+    # abs() because of loop orientation might be backwards.
+    return 0.5 * abs(sum((y1 + y2) * (x1 - x2) for (x1, y1), (x2, y2) in pairs))
+
+
+def cubic_meters_contained(loop):
+    """
+    We can use https://en.wikipedia.org/wiki/Pick%27s_theorem.
+    A = i + b/2 - 1 (1)
+    Note that the result we look for is actually not the area A but the total number of points i.e.
+    i + b (2)
+    which we can get i with (1) as
+    i = A - b/2 + 1 (3)
+    Plugging (3) in to (2):
+    i + b = A - b/2 + 1 + b = A + b/2 + 1
+    We can use the shoelace area to find A, and b is just the loop length.
+    """
+    b = loop_length(loop)
+    A = polygon_area(loop)
+    return int(A + b / 2 + 1)
+
+
+def main():
+    trench_loop = find_trench_loop()
+    area = cubic_meters_contained(trench_loop)
+    print(area)
+
+
+if __name__ == "__main__":
+    main()

2023/18/part2_complex.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+# Version using complex coordinates.
+import fileinput
+
+DIR_RIGHT = 0
+DIR_DOWN = 1
+DIR_LEFT = 2
+DIR_UP = 3
+
+DIR_DELTA = {
+    DIR_RIGHT: 1j,
+    DIR_DOWN: 1,
+    DIR_LEFT: -1j,
+    DIR_UP: -1,
+}
+
+
+def find_trench_loop():
+    trench_loop: list[complex] = []
+
+    pos = 0
+    for line in fileinput.input():
+        rgb = line.rstrip("\n").split()[-1].strip("(#)")
+        meters, dir = (int(x, 16) for x in (rgb[:-1], rgb[-1]))
+        delta = DIR_DELTA[dir]
+
+        pos += delta * meters
+        trench_loop.append(pos)
+
+    return trench_loop
+
+
+def loop_length(loop):
+    len = 0
+    pairs = tuple(zip(loop, loop[1:] + [loop[0]]))
+    for p1, p2 in pairs:
+        len += abs(p2.real - p1.real) + abs(p2.imag - p1.imag)  # Manhattan distance
+    return len
+
+
+def polygon_area(loop):
+    # https://en.wikipedia.org/wiki/Shoelace_formula
+    pairs = tuple(zip(loop, loop[1:] + [loop[0]]))
+    # abs() because of loop orientation might be backwards.
+    return 0.5 * abs(sum((p1.imag + p2.imag) * (p1.real - p2.real) for p1, p2 in pairs))
+
+
+def cubic_meters_contained(loop):
+    """
+    We can use https://en.wikipedia.org/wiki/Pick%27s_theorem.
+    A = i + b/2 - 1 (1)
+    Note that the result we look for is actually not the area A but the total number of points i.e.
+    i + b (2)
+    which we can get i with (1) as
+    i = A - b/2 + 1 (3)
+    Plugging (3) in to (2):
+    i + b = A - b/2 + 1 + b = A + b/2 + 1
+    We can use the shoelace area to find A, and b is just the loop length.
+    """
+    b = loop_length(loop)
+    A = polygon_area(loop)
+    return int(A + b / 2 + 1)
+
+
+def main():
+    trench_loop = find_trench_loop()
+    area = cubic_meters_contained(trench_loop)
+    print(area)
+
+
+if __name__ == "__main__":
+    main()