From f66596c41b53624149cb2e2e025451655561bf31 Mon Sep 17 00:00:00 2001 From: Dazbo Date: Mon, 18 Dec 2023 10:00:02 +0000 Subject: [PATCH] 2023d18 p1 done --- .../Dazbo's_Advent_of_Code_2023.ipynb | 424 ++++++++++++++---- 1 file changed, 339 insertions(+), 85 deletions(-) diff --git a/src/AoC_2023/Dazbo's_Advent_of_Code_2023.ipynb b/src/AoC_2023/Dazbo's_Advent_of_Code_2023.ipynb index d54a14c..75e91e0 100644 --- a/src/AoC_2023/Dazbo's_Advent_of_Code_2023.ipynb +++ b/src/AoC_2023/Dazbo's_Advent_of_Code_2023.ipynb @@ -555,31 +555,31 @@ "class Vectors(Enum):\n", " \"\"\" Enumeration of 8 directions.\n", " Note: y axis increments in the North direction, i.e. N = (0, 1) \"\"\"\n", - " N = (0, 1)\n", - " NE = (1, 1)\n", + " N = (0, -1)\n", + " NE = (1, -1)\n", " E = (1, 0)\n", - " SE = (1, -1)\n", - " S = (0, -1)\n", - " SW = (-1, -1)\n", + " SE = (1, 1)\n", + " S = (0, 1)\n", + " SW = (-1, 1)\n", " W = (-1, 0)\n", - " NW = (-1, 1)\n", + " NW = (-1, -1)\n", "\n", - " @property\n", - " def y_inverted_vector(self):\n", - " \"\"\" Return Vector enum, but with y-axis inverted. I.e. N = (0, -1) \"\"\"\n", - " x, y = self.value\n", - " inverted_value = (x, -y)\n", + " # @property\n", + " # def y_inverted_vector(self):\n", + " # \"\"\" Return Vector enum, but with y-axis inverted. I.e. N = (0, -1) \"\"\"\n", + " # x, y = self.value\n", + " # inverted_value = (x, -y)\n", " \n", - " # Find the corresponding vector with the inverted value\n", - " for vector in Vectors:\n", - " if vector.value == inverted_value:\n", - " return vector\n", + " # # Find the corresponding vector with the inverted value\n", + " # for vector in Vectors:\n", + " # if vector.value == inverted_value:\n", + " # return vector\n", " \n", - " @property\n", - " def y_inverted_value(self):\n", - " \"\"\" Return vector value with y-axis inverted. I.e., invert_y of N = (0, -1) \"\"\"\n", - " x, y = self.value\n", - " return (x, -y)\n", + " # @property\n", + " # def y_inverted_value(self):\n", + " # \"\"\" Return vector value with y-axis inverted. I.e., invert_y of N = (0, -1) \"\"\"\n", + " # x, y = self.value\n", + " # return (x, -y)\n", "\n", "class VectorDicts():\n", " \"\"\" Contains constants for Vectors \"\"\"\n", @@ -3500,7 +3500,7 @@ " assert this_pipe in PipeGrid.directions_for_pipe, \"Point must be a pipe or S\" \n", " \n", " allowed_directions = PipeGrid.directions_for_pipe[this_pipe]\n", - " allowed_vectors = [Vectors[direction].y_inverted_vector for direction in allowed_directions]\n", + " allowed_vectors = [Vectors[direction] for direction in allowed_directions]\n", "\n", " assert allowed_vectors, \"We must be allowed to move in at least one direction\"\n", " \n", @@ -3517,7 +3517,7 @@ " if self.valid_location(neighbour) and neighbour not in loop:\n", " valid.append(neighbour)\n", "\n", - " return valid\n" + " return valid" ] }, { @@ -3776,7 +3776,7 @@ " logger.debug(\"Getting non_loop_tiles..\")\n", " non_loop_tiles = set()\n", " loop_path_set = set(loop_path) # converting to set makes a huge difference to performance\n", - " for point in tqdm(grid.all_points()): # if it's slow, we can watch the progres bar\n", + " for point in tqdm(grid.all_points()): # if it's slow, we can watch the progress bar\n", " if point not in loop_path_set:\n", " non_loop_tiles.add(point)\n", " \n", @@ -5529,21 +5529,21 @@ " depending on orientation. \"\"\"\n", " \n", " MIRROR_DIRECTION_MAP = { # { (current char, current direction): new direction }\n", - " (\"/\", Vectors.E.y_inverted_value): Vectors.N.y_inverted_value,\n", - " (\"/\", Vectors.S.y_inverted_value): Vectors.W.y_inverted_value,\n", - " (\"/\", Vectors.W.y_inverted_value): Vectors.S.y_inverted_value,\n", - " (\"/\", Vectors.N.y_inverted_value): Vectors.E.y_inverted_value,\n", - " (\"\\\\\", Vectors.E.y_inverted_value): Vectors.S.y_inverted_value,\n", - " (\"\\\\\", Vectors.S.y_inverted_value): Vectors.E.y_inverted_value,\n", - " (\"\\\\\", Vectors.W.y_inverted_value): Vectors.N.y_inverted_value,\n", - " (\"\\\\\", Vectors.N.y_inverted_value): Vectors.W.y_inverted_value,\n", + " (\"/\", Vectors.E.value): Vectors.N.value,\n", + " (\"/\", Vectors.S.value): Vectors.W.value,\n", + " (\"/\", Vectors.W.value): Vectors.S.value,\n", + " (\"/\", Vectors.N.value): Vectors.E.value,\n", + " (\"\\\\\", Vectors.E.value): Vectors.S.value,\n", + " (\"\\\\\", Vectors.S.value): Vectors.E.value,\n", + " (\"\\\\\", Vectors.W.value): Vectors.N.value,\n", + " (\"\\\\\", Vectors.N.value): Vectors.W.value,\n", " }\n", " \n", " VECTORS_TO_ARROWS = { # used for rendering a console representation\n", - " Vectors.N.y_inverted_value: \"^\",\n", - " Vectors.E.y_inverted_value: \">\",\n", - " Vectors.S.y_inverted_value: \"v\",\n", - " Vectors.W.y_inverted_value: \"<\",\n", + " Vectors.N.value: \"^\",\n", + " Vectors.E.value: \">\",\n", + " Vectors.S.value: \"v\",\n", + " Vectors.W.value: \"<\",\n", " }\n", " \n", " def __init__(self, *args, **kwargs) -> None:\n", @@ -5561,11 +5561,11 @@ " self.path_taken = []\n", " self.energised = defaultdict(set)\n", " \n", - " def bfs(self, start:tuple[Point,tuple[int,int]]=(Point(0,0), Vectors.E.y_inverted_value)):\n", + " def bfs(self, start:tuple[Point,tuple[int,int]]=(Point(0,0), Vectors.E.value)):\n", " \"\"\" Perform a BFS to build the path that light takes through the grid.\n", "\n", " Args:\n", - " start (tuple, optional): (point, vector value). Defaults to (Point(0,0), Vectors.E.invert_y\n", + " start (tuple, optional): (point, vector value). Defaults to (Point(0,0), Vectors.E\n", " \"\"\"\n", " frontier = deque() # ideal for FIFO\n", " frontier.append(start)\n", @@ -5602,8 +5602,8 @@ " curr_val = self.value_at_point(posn) # where are we now\n", "\n", " # First, check our \"pass through\" conditions...\n", - " if (curr_val == \".\" or (curr_val == \"|\" and dirn in (Vectors.N.y_inverted_value, Vectors.S.y_inverted_value))\n", - " or (curr_val == \"-\" and dirn in (Vectors.E.y_inverted_value, Vectors.W.y_inverted_value))):\n", + " if (curr_val == \".\" or (curr_val == \"|\" and dirn in (Vectors.N.value, Vectors.S.value))\n", + " or (curr_val == \"-\" and dirn in (Vectors.E.value, Vectors.W.value))):\n", " next_dirn = dirn \n", " next_posn = posn + Point(*next_dirn)\n", " yield (next_posn, dirn) \n", @@ -5612,14 +5612,14 @@ " next_posn = posn + Point(*next_dirn)\n", " yield (next_posn, next_dirn) \n", " elif curr_val == \"|\": # split at |, yielding two directions\n", - " assert dirn in (Vectors.E.y_inverted_value, Vectors.W.y_inverted_value), \"We must be going E or W\"\n", - " for next_dirn in (Vectors.N.y_inverted_value, Vectors.S.y_inverted_value):\n", + " assert dirn in (Vectors.E.value, Vectors.W.value), \"We must be going E or W\"\n", + " for next_dirn in (Vectors.N.value, Vectors.S.value):\n", " next_posn = posn + Point(*next_dirn)\n", " yield (next_posn, next_dirn)\n", " else: # split at -, yielding two directions\n", " assert curr_val == \"-\", \"We should be at -\"\n", - " assert dirn in (Vectors.N.y_inverted_value, Vectors.S.y_inverted_value), \"We must be going N or S\"\n", - " for next_dirn in (Vectors.E.y_inverted_value, Vectors.W.y_inverted_value):\n", + " assert dirn in (Vectors.N.value, Vectors.S.value), \"We must be going N or S\"\n", + " for next_dirn in (Vectors.E.value, Vectors.W.value):\n", " next_posn = posn + Point(*next_dirn)\n", " yield (next_posn, next_dirn) \n", " \n", @@ -5816,15 +5816,15 @@ " starts = [] # to store all possible starting locations and directions\n", " for col in range(0, grid.width): \n", " # points on top edge pointing down\n", - " starts.append((Point(col, 0), Vectors.S.y_inverted_value))\n", + " starts.append((Point(col, 0), Vectors.S.value))\n", " # points on bottom edge, pointing up\n", - " starts.append((Point(0, grid.height-1), Vectors.N.y_inverted_value))\n", + " starts.append((Point(0, grid.height-1), Vectors.N.value))\n", " \n", " for row in range(0, grid.height):\n", " # points on left edge, pointing right\n", - " starts.append((Point(0, row), Vectors.E.y_inverted_value))\n", + " starts.append((Point(0, row), Vectors.E.value))\n", " # points on right edge, pointing left\n", - " starts.append((Point(grid.width-1, row), Vectors.W.y_inverted_value))\n", + " starts.append((Point(grid.width-1, row), Vectors.W.value))\n", " \n", " energised = {} # { (start, direction), count_energised, ... }\n", " for start in tqdm(starts): # let's view a progress bar\n", @@ -6157,7 +6157,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 59, "metadata": {}, "outputs": [ { @@ -6181,16 +6181,15 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 60, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32m06:57:25.688:aoc2023 - INF: Session cookie retrieved: 53616c...ff33e0\u001b[39m\n", - "\u001b[34m06:57:26.549:aoc2023 - DBG: Writing input file input.txt\u001b[39m\n", - "\u001b[32m06:57:26.552:aoc2023 - INF: Input data:\n", + "\u001b[34m07:27:42.454:aoc2023 - DBG: input.txt already exists\u001b[39m\n", + "\u001b[32m07:27:42.455:aoc2023 - INF: Input data:\n", " 1: L 7 (#2ac8e2)\n", " 2: D 5 (#14b771)\n", " 3: L 14 (#302602)\n", @@ -6254,62 +6253,301 @@ "\n", "Each trench is also listed with the color that the edge of the trench should be painted as an RGB hexadecimal color code.\n", "\n", - "**If they follow their dig plan, how many cubic meters of lava could it hold?**\n" + "**If they follow their dig plan, how many cubic meters of lava could it hold?**\n", + "\n", + "**My solution:**\n", + "\n", + "Assumptions:\n", + "\n", + "1. That the perimeter we dig never intersects with itself. Thus, the interior region is one expanse.\n", + "1. That the perimeter digging ends where we started.\n", + "\n", + "Approach:\n", + "\n", + "- Create a list to represent the squares of the perimeter - i.e. the what we'll dig with the instructions.\n", + "- Start at `(0,0)` and add it to the list.\n", + "- For each instruction, iterate over the required number of squares. For each iteration, add the current direction to the current square. This gives us the new current square. Add it to the list.\n", + "- When we reach the first turn, we can use this to determine a `.` that is inside the trench.\n", + "- We can then use this `.` as the starting point for a BFS flood fill, to get the interior region.\n" ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 144, "metadata": {}, "outputs": [], "source": [ - "def solve_part1(data):\n", + "def parse_plan(data) -> list[tuple]:\n", " plan = []\n", " for line in data:\n", " dirn, path_len, hex_code = line.split()\n", - " hex_code = hex_code.replace(\"(\", \"\")\n", - " hex_code = hex_code.replace(\")\", \"\")\n", - " plan.append((dirn, int(path_len), hex_code))\n", + " plan.append((dirn, int(path_len)))\n", + " \n", + " return plan\n", + "\n", + "def flood_fill(perimeter_set, interior_candidates: set[tuple], bounds: tuple[tuple, tuple]) -> set[tuple]:\n", + " regions = []\n", + " min_x, min_y = bounds[0]\n", + " max_x, max_y = bounds[1]\n", + " exterior = set()\n", + " all_interior = set()\n", + "\n", + " logger.debug(f\"Processing {len(interior_candidates)} interior candidates.\") \n", + " for point in interior_candidates:\n", + " if point in all_interior or point in exterior:\n", + " continue # this point is in a region we've done already\n", + " \n", + " region = set()\n", + " queue = deque()\n", + " queue.append(point)\n", + " explored = set()\n", + " explored.add(point)\n", + " interior = True # assume interior point\n", + " \n", + " while queue and interior:\n", + " current = queue.popleft()\n", + " \n", + " if current in all_interior:\n", + " break\n", + " \n", + " if current not in perimeter_set:\n", + " region.add(current)\n", + " \n", + " neighbours = [(current[0]+dx, current[1]+dy) for dx,dy in (VectorDicts.DIRS.values())]\n", + " for neighbour in neighbours:\n", + " if min_x <= neighbour[0] <= max_x and min_y <= neighbour[1] <= max_y: # within bounds\n", + " if neighbour not in perimeter_set: # this is a valid region point\n", + " if neighbour not in explored:\n", + " queue.append(neighbour)\n", + " explored.add(neighbour)\n", + " else: # outside of bounds so mark the region as external\n", + " interior = False\n", + " break\n", + " \n", + " if interior: \n", + " regions.append(region)\n", + " all_interior.update(region)\n", + " logger.debug(f\"Updated all_interior with {len(region)} points.\")\n", + " else:\n", + " exterior.update(region)\n", + " logger.debug(f\"Updated exterior with {len(region)} points.\")\n", + " \n", + " return all_interior \n", + "\n", + "def plot_path(path: list[tuple], inside: set[tuple]=set()):\n", + " # Extract x and y values from the path\n", + " loop_x_values = [point[0] for point in path]\n", + " loop_y_values = [point[1] for point in path]\n", + " \n", + " # Extract x and y values from the inside set\n", + " inside_x_values = [point[0] for point in inside]\n", + " inside_y_values = [point[1] for point in inside]\n", + "\n", + " # Plot the line and scatter graphs\n", + " plt.plot(loop_x_values, loop_y_values, \n", + " marker=MarkerStyle('o'), linestyle='-', color=\"blue\", label=\"Loop\")\n", + " \n", + " plt.scatter(inside_x_values, inside_y_values, \n", + " marker=MarkerStyle('x'), color=\"red\", label=\"Inside\")\n", " \n", - " for instr in plan:\n", - " logger.debug(f\"{instr}\")" + " plt.title('Path Plot')\n", + " plt.xlabel('X-axis')\n", + " plt.ylabel('Y-axis')\n", + " plt.gca().invert_yaxis() # Invert the y-axis\n", + " plt.grid(True)\n", + " plt.show()" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 145, + "metadata": {}, + "outputs": [], + "source": [ + "def solve_part1(data) -> int:\n", + " plan = parse_plan(data)\n", + " \n", + " perimeter_path = []\n", + " current = (0,0)\n", + " perimeter_path.append(current)\n", + " interior_candidates = set()\n", + " \n", + " for instr_num, (dirn_char, path_len) in enumerate(plan):\n", + " # logger.debug(f\"[{instr_num}]: {(dirn_char, path_len, hex_code)}\")\n", + " dirn = VectorDicts.DIRS[dirn_char]\n", + " for step in range(path_len):\n", + " current = (current[0]+dirn[0], current[1]+dirn[1])\n", + " perimeter_path.append(current)\n", + " \n", + " if instr_num>0 and step==0: # turn executed\n", + " # After the turn, the last three moves will represent three squares in a 2x2 grid.\n", + " # The remaining square will represent an interior point\n", + " assert len(perimeter_path) >= 3, \"We must have at least three squares if we've made a turn\"\n", + " last_three = perimeter_path[-3:]\n", + " \n", + " for y in range(min(y for x, y in last_three), max(y for x, y in last_three)+1):\n", + " for x in range(min(x for x, y in last_three), max(x for x, y in last_three)+1):\n", + " if (x, y) not in perimeter_path:\n", + " interior_candidates.add((x, y))\n", + " break\n", + "\n", + " min_x = min(perimeter_path, key=lambda p: p[0])[0]\n", + " max_x = max(perimeter_path, key=lambda p: p[0])[0]\n", + " min_y = min(perimeter_path, key=lambda p: p[1])[1]\n", + " max_y = max(perimeter_path, key=lambda p: p[1])[1]\n", + " \n", + " bounds = ((min_x, min_y), (max_x, max_y)) # tl, br\n", + " \n", + " plot_path(perimeter_path)\n", + "\n", + " perimeter_set = set(perimeter_path)\n", + " all_interior = flood_fill(perimeter_set, interior_candidates, bounds)\n", + " plot_path(perimeter_path, all_interior)\n", + " \n", + " return len(perimeter_set) + len(all_interior)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 146, "metadata": {}, "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "name": "stderr", "output_type": "stream", "text": [ - "\u001b[34m07:07:54.781:aoc2023 - DBG: ('R', 6, '#70c710')\u001b[39m\n", - "\u001b[34m07:07:54.782:aoc2023 - DBG: ('D', 5, '#0dc571')\u001b[39m\n", - "\u001b[34m07:07:54.782:aoc2023 - DBG: ('L', 2, '#5713f0')\u001b[39m\n", - "\u001b[34m07:07:54.783:aoc2023 - DBG: ('D', 2, '#d2c081')\u001b[39m\n", - "\u001b[34m07:07:54.783:aoc2023 - DBG: ('R', 2, '#59c680')\u001b[39m\n", - "\u001b[34m07:07:54.783:aoc2023 - DBG: ('D', 2, '#411b91')\u001b[39m\n", - "\u001b[34m07:07:54.784:aoc2023 - DBG: ('L', 5, '#8ceee2')\u001b[39m\n", - "\u001b[34m07:07:54.784:aoc2023 - DBG: ('U', 2, '#caa173')\u001b[39m\n", - "\u001b[34m07:07:54.784:aoc2023 - DBG: ('L', 1, '#1b58a2')\u001b[39m\n", - "\u001b[34m07:07:54.784:aoc2023 - DBG: ('U', 2, '#caa171')\u001b[39m\n", - "\u001b[34m07:07:54.785:aoc2023 - DBG: ('R', 2, '#7807d2')\u001b[39m\n", - "\u001b[34m07:07:54.785:aoc2023 - DBG: ('U', 3, '#a77fa3')\u001b[39m\n", - "\u001b[34m07:07:54.785:aoc2023 - DBG: ('L', 2, '#015232')\u001b[39m\n", - "\u001b[34m07:07:54.786:aoc2023 - DBG: ('U', 2, '#7a21e3')\u001b[39m\n" + "\u001b[34m09:59:41.439:aoc2023 - DBG: Processing 10 interior candidates.\u001b[39m\n", + "\u001b[34m09:59:41.439:aoc2023 - DBG: Updated all_interior with 24 points.\u001b[39m\n", + "\u001b[34m09:59:41.440:aoc2023 - DBG: Updated exterior with 3 points.\u001b[39m\n", + "\u001b[34m09:59:41.440:aoc2023 - DBG: Updated exterior with 2 points.\u001b[39m\n", + "\u001b[34m09:59:41.440:aoc2023 - DBG: Updated exterior with 1 points.\u001b[39m\n" ] }, { - "ename": "AssertionError", - "evalue": "None != 62", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mAssertionError\u001b[0m Traceback (most recent call last)", - "File \u001b[1;32m:19\u001b[0m\n", - "Cell \u001b[1;32mIn[9], line 8\u001b[0m, in \u001b[0;36mvalidate\u001b[1;34m(test, answer)\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 3\u001b[0m \u001b[38;5;124;03mArgs:\u001b[39;00m\n\u001b[0;32m 4\u001b[0m \u001b[38;5;124;03m test: the answer given by our solution\u001b[39;00m\n\u001b[0;32m 5\u001b[0m \u001b[38;5;124;03m answer: the expected answer, e.g. from instructions\u001b[39;00m\n\u001b[0;32m 6\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 7\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m test \u001b[38;5;241m!=\u001b[39m answer:\n\u001b[1;32m----> 8\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mAssertionError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtest\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m != \u001b[39m\u001b[38;5;132;01m{\u001b[39;00manswer\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n", - "\u001b[1;31mAssertionError\u001b[0m: None != 62" + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m09:59:41.541:aoc2023 - INF: Tests passed!\u001b[39m\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34m09:59:41.777:aoc2023 - DBG: Processing 692 interior candidates.\u001b[39m\n", + "\u001b[34m09:59:41.783:aoc2023 - DBG: Updated exterior with 3191 points.\u001b[39m\n", + "\u001b[34m09:59:41.964:aoc2023 - DBG: Updated all_interior with 101645 points.\u001b[39m\n", + "\u001b[34m09:59:41.970:aoc2023 - DBG: Updated exterior with 2153 points.\u001b[39m\n", + "\u001b[34m09:59:41.979:aoc2023 - DBG: Updated exterior with 4665 points.\u001b[39m\n", + "\u001b[34m09:59:41.980:aoc2023 - DBG: Updated exterior with 47 points.\u001b[39m\n", + "\u001b[34m09:59:41.993:aoc2023 - DBG: Updated exterior with 6778 points.\u001b[39m\n", + "\u001b[34m09:59:41.999:aoc2023 - DBG: Updated exterior with 2824 points.\u001b[39m\n", + "\u001b[34m09:59:42.001:aoc2023 - DBG: Updated exterior with 1481 points.\u001b[39m\n", + "\u001b[34m09:59:42.005:aoc2023 - DBG: Updated exterior with 2103 points.\u001b[39m\n", + "\u001b[34m09:59:42.010:aoc2023 - DBG: Updated exterior with 2397 points.\u001b[39m\n", + "\u001b[34m09:59:42.015:aoc2023 - DBG: Updated exterior with 2047 points.\u001b[39m\n", + "\u001b[34m09:59:42.015:aoc2023 - DBG: Updated exterior with 105 points.\u001b[39m\n", + "\u001b[34m09:59:42.020:aoc2023 - DBG: Updated exterior with 1604 points.\u001b[39m\n", + "\u001b[34m09:59:42.022:aoc2023 - DBG: Updated exterior with 1009 points.\u001b[39m\n", + "\u001b[34m09:59:42.031:aoc2023 - DBG: Updated exterior with 4278 points.\u001b[39m\n", + "\u001b[34m09:59:42.033:aoc2023 - DBG: Updated exterior with 242 points.\u001b[39m\n", + "\u001b[34m09:59:42.036:aoc2023 - DBG: Updated exterior with 1431 points.\u001b[39m\n", + "\u001b[34m09:59:42.040:aoc2023 - DBG: Updated exterior with 1947 points.\u001b[39m\n", + "\u001b[34m09:59:42.051:aoc2023 - DBG: Updated exterior with 4837 points.\u001b[39m\n", + "\u001b[34m09:59:42.056:aoc2023 - DBG: Updated exterior with 1844 points.\u001b[39m\n", + "\u001b[34m09:59:42.059:aoc2023 - DBG: Updated exterior with 1021 points.\u001b[39m\n", + "\u001b[34m09:59:42.066:aoc2023 - DBG: Updated exterior with 3662 points.\u001b[39m\n", + "\u001b[34m09:59:42.070:aoc2023 - DBG: Updated exterior with 966 points.\u001b[39m\n", + "\u001b[34m09:59:42.076:aoc2023 - DBG: Updated exterior with 3090 points.\u001b[39m\n", + "\u001b[34m09:59:42.077:aoc2023 - DBG: Updated exterior with 92 points.\u001b[39m\n", + "\u001b[34m09:59:42.079:aoc2023 - DBG: Updated exterior with 569 points.\u001b[39m\n", + "\u001b[34m09:59:42.080:aoc2023 - DBG: Updated exterior with 322 points.\u001b[39m\n", + "\u001b[34m09:59:42.084:aoc2023 - DBG: Updated exterior with 1882 points.\u001b[39m\n", + "\u001b[34m09:59:42.085:aoc2023 - DBG: Updated exterior with 84 points.\u001b[39m\n", + "\u001b[34m09:59:42.086:aoc2023 - DBG: Updated exterior with 237 points.\u001b[39m\n", + "\u001b[34m09:59:42.088:aoc2023 - DBG: Updated exterior with 702 points.\u001b[39m\n", + "\u001b[34m09:59:42.088:aoc2023 - DBG: Updated exterior with 36 points.\u001b[39m\n", + "\u001b[34m09:59:42.091:aoc2023 - DBG: Updated exterior with 1427 points.\u001b[39m\n", + "\u001b[34m09:59:42.093:aoc2023 - DBG: Updated exterior with 108 points.\u001b[39m\n", + "\u001b[34m09:59:42.099:aoc2023 - DBG: Updated exterior with 2865 points.\u001b[39m\n", + "\u001b[34m09:59:42.100:aoc2023 - DBG: Updated exterior with 88 points.\u001b[39m\n", + "\u001b[34m09:59:42.100:aoc2023 - DBG: Updated exterior with 71 points.\u001b[39m\n", + "\u001b[34m09:59:42.106:aoc2023 - DBG: Updated exterior with 2849 points.\u001b[39m\n", + "\u001b[34m09:59:42.110:aoc2023 - DBG: Updated exterior with 1672 points.\u001b[39m\n", + "\u001b[34m09:59:42.110:aoc2023 - DBG: Updated exterior with 67 points.\u001b[39m\n", + "\u001b[34m09:59:42.111:aoc2023 - DBG: Updated exterior with 10 points.\u001b[39m\n", + "\u001b[34m09:59:42.111:aoc2023 - DBG: Updated exterior with 15 points.\u001b[39m\n", + "\u001b[34m09:59:42.112:aoc2023 - DBG: Updated exterior with 117 points.\u001b[39m\n", + "\u001b[34m09:59:42.113:aoc2023 - DBG: Updated exterior with 15 points.\u001b[39m\n", + "\u001b[34m09:59:42.113:aoc2023 - DBG: Updated exterior with 52 points.\u001b[39m\n", + "\u001b[34m09:59:42.117:aoc2023 - DBG: Updated exterior with 1768 points.\u001b[39m\n", + "\u001b[34m09:59:42.118:aoc2023 - DBG: Updated exterior with 307 points.\u001b[39m\n", + "\u001b[34m09:59:42.120:aoc2023 - DBG: Updated exterior with 207 points.\u001b[39m\n", + "\u001b[34m09:59:42.120:aoc2023 - DBG: Updated exterior with 56 points.\u001b[39m\n", + "\u001b[34m09:59:42.121:aoc2023 - DBG: Updated exterior with 84 points.\u001b[39m\n", + "\u001b[34m09:59:42.123:aoc2023 - DBG: Updated exterior with 990 points.\u001b[39m\n", + "\u001b[34m09:59:42.125:aoc2023 - DBG: Updated exterior with 39 points.\u001b[39m\n", + "\u001b[34m09:59:42.126:aoc2023 - DBG: Updated exterior with 14 points.\u001b[39m\n", + "\u001b[34m09:59:42.127:aoc2023 - DBG: Updated exterior with 241 points.\u001b[39m\n", + "\u001b[34m09:59:42.127:aoc2023 - DBG: Updated exterior with 7 points.\u001b[39m\n", + "\u001b[34m09:59:42.128:aoc2023 - DBG: Updated exterior with 19 points.\u001b[39m\n", + "\u001b[34m09:59:42.128:aoc2023 - DBG: Updated exterior with 87 points.\u001b[39m\n", + "\u001b[34m09:59:42.134:aoc2023 - DBG: Updated exterior with 2526 points.\u001b[39m\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m09:59:42.761:aoc2023 - INF: Part 1 soln=106459\u001b[39m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: total: 828 ms\n", + "Wall time: 1.42 s\n" ] } ], @@ -6347,7 +6585,23 @@ "source": [ "### Day 18 Part 2\n", "\n", - "Overview..." + "Uh oh. The colour and instruction parameters need to be swapped!! We need to extract the correct instructions from the hex codes.\n", + "\n", + "For each hex code:\n", + "\n", + "- First five digits = hex value of distance in m\n", + "- Last digit = direction, where `0 = R`, `1 = D`, `2 = L`, ` 3 = U` " + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "metadata": {}, + "outputs": [], + "source": [ + "def parse_plan_hex(data) -> list[tuple]:\n", + " plan = [line[-7:-1] for line in data]\n", + " return plan" ] }, {