diff --git a/ipynb/Advent-2021.ipynb b/ipynb/Advent-2021.ipynb index c23845a..c433853 100644 --- a/ipynb/Advent-2021.ipynb +++ b/ipynb/Advent-2021.ipynb @@ -10,9 +10,9 @@ "\n", "I'm doing [Advent of Code](https://adventofcode.com/) (AoC) this year. I'm not competing for points\\, just for fun.\n", "\n", - "To fully understand each puzzle you'll have to click on each day's link (e.g. [Day 1](https://adventofcode.com/2021/day/1)); I'll give only a partial description of the puzzles. \n", + "To fully understand the puzzles, click on each day's link (e.g. [Day 1](https://adventofcode.com/2021/day/1)) and read the instructions; I give only a brief summary. \n", "\n", - "Part of the idea of AoC is that you have to make some design choices to solve part 1 *before* you get to see the description of part 2. So there is a tension of wanting the solution to part 1 to provide general components that might be re-used in part 2, without falling victim to [YAGNI](https://en.wikipedia.org/wiki/You_aren%27t_gonna_need_it). In this notebook I won't refactor the code for part 1 based on what I see in part 2 (although I may edit the code for clarity, without changing the initial approach).\n", + "Part of the idea of AoC is that you have to make some design choices to solve part 1 *before* you get to see the instructions for part 2. So there is a tension of wanting the solution to part 1 to provide components that can be re-used in part 2, without falling victim to [YAGNI](https://en.wikipedia.org/wiki/You_aren%27t_gonna_need_it). In this notebook I won't refactor the code for part 1 after I see what is in part 2 (although I may edit the code for clarity, without changing the initial approach).\n", "\n", "# Day 0: Preparations\n", "\n", @@ -41,9 +41,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Each day's work will consist of three tasks:\n", - "- **Input**: Parse the day's input file with the function `parse(day, parser, sep)`, which treats the input as a sequence of *entries*, separated by `sep` (default newline); applies `parser` to each entry; and returns the results as a tuple. (Note: `ints` and `atoms` are useful `parser` functions (as are `int` and `str`).)\n", - "- **Part 1**: Write code to compute the answer to Part 1, and submit the answer to the AoC site. Use the function `answer` to record the correct answer and serve as a regression test when I re-run the notebook.\n", + "Each day's work will consist of three tasks, denoted by three bulleted section:\n", + "- **Input**: Parse the day's input file. I will use the function `parse(day, parser, sep)`, which:\n", + " - Reads the input file for `day`.\n", + " - Prints out the first few lines of the file (to remind me, and the notebook reader, what's there).\n", + " - Breaks the file into a sequence of *entries* separated by `sep` (default newline).\n", + " - Applies `parser` to each entry and returns the results as a tuple.\n", + " - Useful parser functions include `ints`, `digits`, `atoms`, `words`, and the built-ins `int` and `str`.\n", + "- **Part 1**: Write code to compute the answer to Part 1, and submit the answer to the AoC site. Use the function `answer` to record the correct answer here in the notebook and serve as a regression test when the notebook is re-run.\n", "- **Part 2**: Repeat coding and `answer` for Part 2.\n" ] }, @@ -53,20 +58,33 @@ "metadata": {}, "outputs": [], "source": [ - "def parse(day, parser=str, sep='\\n') -> tuple:\n", - " \"\"\"Split the day's input file into entries separated by `sep`, and apply `parser` to each.\"\"\"\n", - " entries = open(f'AOC2021/input{day}.txt').read().rstrip().split(sep)\n", - " return mapt(parser, entries)\n", - "\n", "def answer(puzzle_number, got, expected) -> bool:\n", " \"\"\"Verify the answer we got was expected.\"\"\"\n", " assert got == expected, f'For {puzzle_number}, expected {expected} but got {got}.'\n", " return True\n", "\n", + "def parse(day, parser=str, sep='\\n', show=6) -> tuple:\n", + " \"\"\"Split the day's input file into entries separated by `sep`, and apply `parser` to each.\"\"\"\n", + " text = open(f'AOC2021/input{day}.txt').read()\n", + " if show > 0:\n", + " lines = text.splitlines()[:show]\n", + " print(f'First {len(lines)} lines of Day {day} input:\\n{\"-\"*29}')\n", + " for line in lines:\n", + " print(line if len(line) <= 100 else line[:100] + ' ...')\n", + " return mapt(parser, text.rstrip().split(sep))\n", + "\n", "def ints(text: str) -> Tuple[int]:\n", " \"\"\"A tuple of all the integers in text, ignoring non-number characters.\"\"\"\n", " return mapt(int, re.findall('-?[0-9]+', text))\n", "\n", + "def digits(text: str) -> Tuple[int]:\n", + " \"\"\"A tuple of all the digits in text (as ints 0–9), ignoring non-digit characters.\"\"\"\n", + " return mapt(int, re.findall('[0-9]', text))\n", + "\n", + "def words(text: str) -> List[str]:\n", + " \"\"\"A list of all the alphabetic words in text.\"\"\"\n", + " return re.findall('[a-zA-Z]+', text)\n", + "\n", "Atom = Union[float, int, str]\n", "\n", "def atoms(text: str, sep=None) -> Tuple[Atom]:\n", @@ -101,48 +119,29 @@ "outputs": [], "source": [ "def quantify(iterable, pred=bool) -> int:\n", - " \"Count the number of items in iterable for which pred is true.\"\n", + " \"\"\"Count the number of items in iterable for which pred is true.\"\"\"\n", " return sum(1 for item in iterable if pred(item))\n", "\n", - "def multimap(items: Iterable[Tuple]) -> dict:\n", - " \"Given (key, val) pairs, return {key: [val, ....], ...}.\"\n", - " result = defaultdict(list)\n", - " for (key, val) in items:\n", - " result[key].append(val)\n", - " return result\n", + "class multimap(defaultdict):\n", + " def __init__(self, pairs: Iterable[tuple], symmetric=False):\n", + " \"\"\"Given (key, val) pairs, return {key: [val, ...], ...}.\n", + " If `symmetric` is True, treat (key, val) as (key, val) plus (val, key).\"\"\"\n", + " self.default_factory = list\n", + " for (key, val) in pairs:\n", + " self[key].append(val)\n", + " if symmetric:\n", + " self[val].append(key)\n", "\n", "def prod(numbers) -> float: # Will be math.prod in Python 3.8\n", - " \"The product of an iterable of numbers.\" \n", + " \"\"\"The product formed by multiplying numbers together.\"\"\"\n", " result = 1\n", " for n in numbers:\n", " result *= n\n", " return result\n", "\n", - "def total(counts: Counter) -> int: \n", + "def total(counter: Counter) -> int: \n", " \"\"\"The sum of all the counts in a Counter.\"\"\"\n", - " return sum(counts.values())\n", - "\n", - "Point = Tuple[int, int] # (x, y) points on a grid\n", - "\n", - "class Grid(dict):\n", - " \"\"\"A 2D grid, indexed by (x, y) Points.\"\"\"\n", - " def __init__(self, mapping):\n", - " \"\"\"Initialize with a mapping of {(0, 0): val0, (0, 1): val1, ...}\"\"\"\n", - " self.update(mapping)\n", - " self.width = max(x for x, y in self)\n", - " self.height = max(y for x, y in self)\n", - " \n", - " def neighbors(self, point):\n", - " \"\"\"The 4 orthogonal neighbors of a point, not going over edge.\"\"\"\n", - " x, y = point\n", - " return [p for p in ((x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)) \n", - " if p in self]\n", - " \n", - " def neighbors8(self, point):\n", - " \"\"\"The 8 orthogonal and diagonal neighbors of a point, not going over edge.\"\"\"\n", - " x, y = point\n", - " return [p for p in ((x + 1, y + 1), (x + 1, y - 1), (x - 1, y + 1), (x - 1, y - 1))\n", - " if p in self] + self.neighbors(point)\n", + " return sum(counter.values())\n", "\n", "def sign(x) -> int: return (0 if x == 0 else +1 if x > 0 else -1)\n", " \n", @@ -159,14 +158,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This year's AoC theme involves Santa's Elves on a submarine. [Gary J Grady](https://twitter.com/GaryJGrady/) has some nice drawings to set the scene:\n", - "\n", - "\n", - "\n", - "# [Day 1](https://adventofcode.com/2021/day/1): Sonar Sweep\n", - "\n", - "\n", - "- **Input**: Each entry in the input is an integer depth measurement, such as \"`148`\".\n" + "A lot of puzzles seem to involve (x, y) points on a rectangular grid, so I'll define `Point` and `Grid`:" ] }, { @@ -174,6 +166,68 @@ "execution_count": 4, "metadata": {}, "outputs": [], + "source": [ + "Point = Tuple[int, int] # (x, y) points on a grid\n", + "\n", + "neighbors4 = ((0, 1), (1, 0), (0, -1), (-1, 0)) \n", + "neighbors8 = ((1, 1), (1, -1), (-1, 1), (-1, -1)) + neighbors4\n", + "\n", + "class Grid(dict):\n", + " \"\"\"A 2D grid, implemented as a mapping of {(x, y): cell_contents}.\"\"\"\n", + " def __init__(self, mapping=(), rows=(), neighbors=neighbors4):\n", + " \"\"\"Initialize with, e.g., either `mapping={(0, 0): 1, (1, 0): 2, ...}`,\n", + " or `rows=[(1, 2, 3), (4, 5, 6)].\n", + " `neighbors` is a collection of (dx, dy) deltas to neighboring points.`\"\"\"\n", + " self.update(mapping if mapping else\n", + " {(x, y): val \n", + " for y, row in enumerate(rows) \n", + " for x, val in enumerate(row)})\n", + " self.width = max(x for x, y in self) + 1\n", + " self.height = max(y for x, y in self) + 1\n", + " self.deltas = neighbors\n", + " \n", + " def neighbors(self, point) -> List[Point]:\n", + " \"\"\"Points that neighbor `point` on the grid.\"\"\"\n", + " x, y = point\n", + " return [(x+dx, y+dy) for (dx, dy) in self.deltas if (x+dx, y+dy) in self]\n", + " \n", + " def copy(self) -> Grid: return Grid(self, neighbors=self.deltas)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This year's AoC theme involves Santa's Elves on a submarine. [Gary J Grady](https://twitter.com/GaryJGrady/) has some nice drawings to set the scene:\n", + "\n", + "\n", + "\n", + "# [Day 1](https://adventofcode.com/2021/day/1): Sonar Sweep\n", + "\n", + "\n", + "- **Input**: Each entry in the input is an integer depth measurement.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First 6 lines of Day 1 input:\n", + "-----------------------------\n", + "148\n", + "167\n", + "168\n", + "169\n", + "182\n", + "188\n" + ] + } + ], "source": [ "in1 = parse(1, int)" ] @@ -185,38 +239,6 @@ "- **Part 1**: How many measurements are larger than the previous measurement?" ] }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "def increases(nums: List[int]) -> int:\n", - " \"\"\"How many numbers are bigger than the previous one?\"\"\"\n", - " return quantify(nums[i] > nums[i - 1] \n", - " for i in range(1, len(nums)))\n", - "\n", - "answer(1.1, increases(in1), 1400)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "- **Part 2**: Consider sums of a three-measurement sliding window. How many sums are larger than the previous sum?" - ] - }, { "cell_type": "code", "execution_count": 6, @@ -233,31 +255,114 @@ "output_type": "execute_result" } ], + "source": [ + "def increases(nums: List[int]) -> int:\n", + " \"\"\"How many measurements are larger than the previous measurement?\"\"\"\n", + " return quantify(nums[i] > nums[i - 1] \n", + " for i in range(1, len(nums)))\n", + "\n", + "answer(1.1, increases(in1), 1400)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **Part 2**: Consider sums of a three-measurement sliding window. How many sums are larger than the previous sum?" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "def window_increases(nums: List[int], w=3) -> int:\n", - " \"\"\"How many sliding windows of w numbers have a sum bigger than the previous window?\"\"\"\n", + " \"\"\"How many sliding windows of `w` numbers have a sum larger than the previous window?\"\"\"\n", " return quantify(sum(nums[i:i+w]) > sum(nums[i-1:i-1+w])\n", " for i in range(1, len(nums) + 1 - w))\n", "\n", "answer(1.2, window_increases(in1), 1429)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's take a look at where the depths are taking us:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(in1, 'b.'); plt.ylabel('Depth'); plt.gca().invert_yaxis();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It looks like Gary Grady was right; the submarine is descending at a steep angle." + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ "# [Day 2](https://adventofcode.com/2021/day/2): Dive! \n", "\n", - "- **Input**: Each entry in the input is a command, like \"`forward 1`\", \"`down 2`\", or \"`up 3`\".\n", + "- **Input**: Each entry in the input is a command name (\"forward\", \"down\", or \"up\") followed by an integer.\n", "\n", "I'll parse a command into a tuple like `('forward', 1)`." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First 6 lines of Day 2 input:\n", + "-----------------------------\n", + "forward 2\n", + "down 7\n", + "down 8\n", + "forward 9\n", + "down 8\n", + "forward 9\n" + ] + } + ], "source": [ "in2 = parse(2, atoms)" ] @@ -271,7 +376,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -280,7 +385,7 @@ "True" ] }, - "execution_count": 8, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -295,7 +400,7 @@ " if op == 'up': depth -= n\n", " return pos * depth\n", "\n", - "answer(2.1, drive(in2), 1670340)" + "answer(2.1, drive(in2), 1_670_340)" ] }, { @@ -309,7 +414,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -318,7 +423,7 @@ "True" ] }, - "execution_count": 9, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -334,7 +439,14 @@ " if op == 'up': aim -= n\n", " return pos * depth\n", "\n", - "answer(2.2, drive2(in2), 1954293920)" + "answer(2.2, drive2(in2), 1_954_293_920)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The puzzle didn't say what the units are, but I'm guessing micrometers. That gives a depth of almost 2 km; a depth that only specialized research submarines can reach." ] }, { @@ -343,30 +455,45 @@ "source": [ "# [Day 3](https://adventofcode.com/2021/day/3): Binary Diagnostic\n", "\n", - "- **Input**: Each entry in the input is a bit string, such as \"`101000111100`\".\n", + "- **Input**: Each entry in the input is a bit string of `0`s and `1`s.\n", "\n", "I'll parse them as strings; I won't convert them into ints." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First 6 lines of Day 3 input:\n", + "-----------------------------\n", + "101000111100\n", + "000011111101\n", + "011100000100\n", + "100100010000\n", + "011110010100\n", + "101001100000\n" + ] + } + ], "source": [ - "in3 = parse(3, str)" + "in3 = parse(3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "- **Part 1**: What is the power consumption of the submarine (product of gamma and epsilon rates)?" + "- **Part 1**: Use the binary numbers in your diagnostic report to calculate the gamma rate and epsilon rate, then multiply them together. What is the power consumption of the submarine?" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -375,7 +502,7 @@ "True" ] }, - "execution_count": 11, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -409,12 +536,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "- **Part 2**: What is the life support rating of the submarine (product of oxygen and CO2)?" + "- **Part 2**: Use the binary numbers in your diagnostic report to calculate the oxygen generator rating and CO2 scrubber rating, then multiply them together. What is the life support rating of the submarine?" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -423,7 +550,7 @@ "True" ] }, - "execution_count": 12, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -452,18 +579,35 @@ "source": [ "# [Day 4](https://adventofcode.com/2021/day/4): Giant Squid\n", "\n", - "- **Input**: The first entry of the input is a permutation of the integers 0-99. Subsequent entries are bingo boards: 5 lines of 5 ints each. Entries are separated by *two* newlines. (Bingo games will be played against a giant squid.)\n", + "- **Input**: The first entry of the input is a permutation of the integers 0-99. Subsequent entries are bingo boards: 5 lines of 5 ints each. Entries are separated by *two* newlines. \n", "\n", - "I'll represent a board as a tuple of 25 ints; that makes `parse` easy: the permutation of integers and the bingo boards can both be parsed by `ints`. " + "I'll represent a board as a tuple of 25 ints; that makes `parse` easy: the permutation of integers and the bingo boards can both be parsed by `ints`. (Bingo games will be played against a giant squid; we get to choose which board we want to play.)" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First 8 lines of Day 4 input:\n", + "-----------------------------\n", + "73,42,95,35,13,40,99,92,33,30,83,1,36,93,59,90,55,25,77,44,37,62,41,47,80,23,51,61,21,20,76,8,71,34, ...\n", + "\n", + "91 5 64 81 34\n", + "15 99 31 63 65\n", + "45 39 54 93 83\n", + "51 14 23 86 32\n", + "19 22 16 13 3\n", + "\n" + ] + } + ], "source": [ - "order, *boards = in4 = parse(4, ints, sep='\\n\\n')" + "order, *boards = in4 = parse(4, ints, sep='\\n\\n', show=8)" ] }, { @@ -482,7 +626,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -491,19 +635,19 @@ "True" ] }, - "execution_count": 14, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "Board = Tuple[int]\n", - "Line = List[int]\n", - "B = 5\n", - "def sq(x, y) -> int: \"The index number of the square at (x, y)\"; return x + B * y\n", + "B = 5 # Bingo board is size B by B.\n", + "Board = Tuple[int] # B * B ints\n", + "Line = List[int] # B ints\n", "\n", "def lines(square) -> Tuple[Line, Line]:\n", - " \"\"\"The two lines through square number `square`.\"\"\"\n", + " \"\"\"The two lines (horizontal and vertical) through square number `square`.\"\"\"\n", + " def sq(x, y) -> int: return x + B * y\n", " return ([sq(x, square // B) for x in range(B)], \n", " [sq(square % B, y) for y in range(B)])\n", "\n", @@ -540,7 +684,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -549,7 +693,7 @@ "True" ] }, - "execution_count": 15, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -557,13 +701,13 @@ "source": [ "def bingo_last(boards, order) -> int: \n", " \"\"\"What is the final score of the last winning board?\"\"\"\n", - " boards = set(boards)\n", + " remaining_boards = set(boards)\n", " drawn = set()\n", " for num in order:\n", " drawn.add(num)\n", - " winners = bingo_winners(boards, drawn, num)\n", - " boards -= set(winners)\n", - " if not boards:\n", + " winners = bingo_winners(remaining_boards, drawn, num)\n", + " remaining_boards -= set(winners)\n", + " if not remaining_boards:\n", " return bingo_score(winners[-1], drawn, num)\n", " \n", "answer(4.2, bingo_last(boards, order), 26936)" @@ -582,14 +726,31 @@ "source": [ "# [Day 5](https://adventofcode.com/2021/day/5): Hydrothermal Venture\n", "\n", - "- **Input**: Each entry in the input is a \"line\" denoted by start and end x,y points, e.g. \"`0,9 -> 5,9`\". I'll represent a line as a 4-tuple of integers, e.g. `(0, 9, 5, 9)`." + "- **Input**: Each entry in the input is a \"line\" denoted by start and end x,y points, e.g. \"`0,9 -> 5,9`\". \n", + "\n", + "I'll represent a line as a 4-tuple of integers, e.g. `(0, 9, 5, 9)`." ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First 6 lines of Day 5 input:\n", + "-----------------------------\n", + "409,872 -> 409,963\n", + "149,412 -> 281,280\n", + "435,281 -> 435,362\n", + "52,208 -> 969,208\n", + "427,265 -> 884,265\n", + "779,741 -> 779,738\n" + ] + } + ], "source": [ "in5 = parse(5, ints)" ] @@ -603,7 +764,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -612,13 +773,13 @@ "True" ] }, - "execution_count": 17, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "def points(line) -> bool:\n", + "def points(line) -> List[Point]:\n", " \"\"\"All the (integer) points on a line.\"\"\"\n", " x1, y1, x2, y2 = line\n", " if x1 == x2:\n", @@ -651,12 +812,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "For part 2 I'll redefine `points` and `overlaps` in a way that doesn't break part 1:" + "For Part 2 I'll redefine `points` and `overlaps` in a way that doesn't break Part 1:" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -665,7 +826,7 @@ "True" ] }, - "execution_count": 18, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -701,14 +862,24 @@ "source": [ "# [Day 6](https://adventofcode.com/2021/day/6): Lanternfish\n", "\n", - "- **Input**: The input is a single line of comma-separated integers, each one the age of a lanternfish. Over time, the lanternfish age and reproduce in a specified way." + "- **Input**: The input is comma-separated integers, each the age of a lanternfish. Over time, the lanternfish age and reproduce in a specified way." ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 21, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First 1 lines of Day 6 input:\n", + "-----------------------------\n", + "5,4,3,5,1,1,2,1,2,1,3,2,3,4,5,1,2,4,3,2,5,1,4,2,1,1,2,5,4,4,4,1,5,4,5,2,1,2,5,5,4,1,3,1,4,2,4,2,5,1, ...\n" + ] + } + ], "source": [ "in6 = parse(6, int, sep=',')" ] @@ -719,12 +890,12 @@ "source": [ "- **Part 1**: Find a way to simulate lanternfish. How many lanternfish would there be after 80 days?\n", "\n", - "Although the puzzle description treats each fish individually, I won't take the bait (pun intended). Instead, I'll use a `Counter` of fish, and treat all the fish of each age group together. I have a hunch that part 2 will involve a ton-o'-fish." + "Although the puzzle instructions treats each fish individually, I won't take the bait (pun intended). Instead, I'll use a `Counter` of fish, and treat all the fish of each age group together. I have a hunch that part 2 will involve a ton-o'-fish." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -733,7 +904,7 @@ "True" ] }, - "execution_count": 20, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -768,7 +939,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -777,7 +948,7 @@ "True" ] }, - "execution_count": 21, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -799,14 +970,24 @@ "source": [ "# [Day 7](https://adventofcode.com/2021/day/7): The Treachery of Whales\n", "\n", - "- **Input**: The input is a single line of comma-separated integers, each one the horizontal position of a crab (in its own submarine)." + "- **Input**: The input is a single line of comma-separated integers, each the horizontal position of a crab (in its own submarine)." ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 24, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First 1 lines of Day 7 input:\n", + "-----------------------------\n", + "1101,1,29,67,1102,0,1,65,1008,65,35,66,1005,66,28,1,67,65,20,4,0,1001,65,1,65,1106,0,8,99,35,67,101, ...\n" + ] + } + ], "source": [ "in7 = parse(7, int, sep=',')" ] @@ -815,12 +996,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "- **Part 1**: Determine the horizontal position that the crabs can align to using the least fuel possible. How much fuel must they spend to align to that position? (Each unit of travel costs one unit of fuel.)" + "- **Part 1**: Determine the horizontal position that the crabs can align to using the least fuel possible. How much fuel must they spend to align to that position? (Each unit of horizontal travel costs one unit of fuel.)" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -829,7 +1010,7 @@ "True" ] }, - "execution_count": 23, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -853,7 +1034,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -862,7 +1043,7 @@ "True" ] }, - "execution_count": 24, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -892,7 +1073,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -901,7 +1082,7 @@ "490.543" ] }, - "execution_count": 25, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -920,7 +1101,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -929,7 +1110,7 @@ "{490: 95519693, 491: 95519725, 490.543: 95519083.0}" ] }, - "execution_count": 26, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -943,53 +1124,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We see that rounding down gives the right answer, rounding up does a bit worse, and using the exact mean gives a total fuel cost that is *better* than the correct answer (but is apparently not a legal alignment point)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# [Day 8](https://adventofcode.com/2021/day/8): Seven Segment Search\n", + "We see that rounding down gives the right answer, rounding up does a bit worse, and using the exact mean gives a total fuel cost that is *better* than the correct answer (but is apparently not a legal alignment point). A reddit user with the name CrashAndSideburns looked more carefully into the use of the mean, and wrote [a paper](https://www.reddit.com/r/adventofcode/comments/rawxad/2021_day_7_part_2_i_wrote_a_paper_on_todays/) showing that the best alignment point must be within ±0.5 from the mean.\n", "\n", - "- **Input**: Each entry in the input is 10 patterns followed by 4 output values, in the form:\n", - "\n", - " be cfbegad cbdgef fgaecd cgeb fdcge agebfd fecdb fabcd edb | edb cefdb eb gcbe\n", - " \n", - "Each pattern and output value represents a digit, with each letter representing one of the segments in a [7-segment display](https://en.wikipedia.org/wiki/Seven-segment_display). The mapping of letters to segments is unknown, but is consistent within each entry." - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "def segment_parser(line) -> tuple: return mapt(atoms, line.split('|'))\n", - "\n", - "in8 = parse(8, segment_parser)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "assert (segment_parser('be cfbegad cbdgef fgaecd cgeb fdcge agebfd fecdb fabcd edb | edb cefdb eb gcbe')\n", - " == (('be', 'cfbegad', 'cbdgef', 'fgaecd', 'cgeb', 'fdcge', 'agebfd', 'fecdb', 'fabcd', 'edb'), \n", - " ('edb', 'cefdb', 'eb', 'gcbe')))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "\n", - "- **Part 1**: In the output values, how many times do digits 1, 4, 7, or 8 appear?\n", - "\n", - "That's the same as asking *how many values have 2, 4, 3, or 7 segments?*" + "Below I show a histogram of the number of crabs at each range of horizontal positions, along with red stars for the two alignment points (median and mean)." ] }, { @@ -1000,18 +1137,116 @@ { "data": { "text/plain": [ - "True" + "376.0" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(in7, bins=33, rwidth=0.8); \n", + "plt.plot([median(in7), mean(in7)], [50, 50], 'r*')\n", + "plt.ylabel('Number of Crabs'); plt.xlabel('Position'); median(in7)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# [Day 8](https://adventofcode.com/2021/day/8): Seven Segment Search\n", + "\n", + "- **Input**: Each entry in the input consists of 10 patterns followed by a \"`|`\", followed by 4 output values.\n", + " \n", + "Each pattern and output value represents a digit on a [7-segment display](https://en.wikipedia.org/wiki/Seven-segment_display), with each letter a–g representing one of the 7 segments. The mapping of letters to segments is unknown, but is consistent within each entry." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First 6 lines of Day 8 input:\n", + "-----------------------------\n", + "daegb gadbcf cgefda edcfagb dfg acefbd fdgab fg bdcfa fcgb | cdfgba fgbc dbfac gfadbc\n", + "bdfc dcbegf bf egfbcda gebad cfgaed bfe edfgc aegfcb gebdf | fb fb bcdfaeg fcgdeb\n", + "cebdgaf bfcd gceab bf bfcea gceafd ecdfa fegdab bfcade fba | dfcb dagfbe fbaged bfa\n", + "efabcg aegcdb fgaed fac dgafbc becf eadcgbf aegfc fc cagbe | ecgfa agdef eagfc gdceab\n", + "fcdae cdeabf fga gf gabfde cgadb gadebfc cgfe aegcdf afgcd | fbgadce gadefb fag bafegd\n", + "gecadbf bgc dacgf gaecbf cbeda dbfg bgdca bg bafcgd gdacef | cdgfa fceabg dgfb dgabc\n" + ] + } + ], + "source": [ + "in8 = parse(8, lambda line: mapt(atoms, line.split('|')))" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "assert in8[0] == (('daegb', 'gadbcf', 'cgefda', 'edcfagb', 'dfg', 'acefbd', 'fdgab', 'fg', 'bdcfa', 'fcgb'), \n", + " ('cdfgba', 'fgbc', 'dbfac', 'gfadbc'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "- **Part 1**: In the output values, how many times do digits 1, 4, 7, or 8 appear?\n", + "\n", + "That's the same as asking *how many output values have 2, 4, 3, or 7 segments?*" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ "def count1478(entries) -> int:\n", - " \"\"\"How many of the rhs digits in all the entries are a 1, 4, 7, or 8?\"\"\"\n", - " return sum(len(value) in (2, 4, 3, 7) for (lhs, rhs) in entries for value in rhs)\n", + " \"\"\"How many of the rhs digits in the entries are a 1, 4, 7, or 8?\"\"\"\n", + " return quantify(len(value) in (2, 4, 3, 7) \n", + " for (lhs, rhs) in entries for value in rhs)\n", "\n", "answer(8.1, count1478(in8), 493)" ] @@ -1027,16 +1262,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Part 2 is *tricky*. The value `'cefdb'` could be either a 2, 3, or 5. To figure out which one it is I could do some fancy constraint satisfaction, but that sounds hard. Or I could exhaustively try all permutations of the seven segments. That sounds easy! Here's my plan:\n", + "Part 2 is *tricky*. The first output value `'cdfgba'` could be either a 0, 6, or 9. To figure out which one it is I could do some fancy constraint satisfaction. That sounds hard. Or I could exhaustively try all permutations of the 7 letters. That sounds easy! Here's my plan:\n", "- Make a list of the 7! = 5,040 possible string translators that permute `'abcdefg'`.\n", - "- Decode an entry by trying all translators and keeping the one that maps all of the ten lhs patterns to a valid digit. `decode` then applies the translator to the rhs and forms it into an `int`.\n", - " - Note that `get_digit` must sort the translated letters to get a key that can be looked up in `segment_map`.\n", + "- Decode an entry by trying all translators and keeping the one that maps all of the ten lhs patterns to a valid digit. `decode` then applies the translator to the four rhs values, concatenates them, and converts the result into an `int`.\n", + " - Note that `get_digit` must *sort* the translated letters to get a key that can be looked up in `segment_map`.\n", "- Finally, sum up the decoding of each entry." ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -1045,7 +1280,7 @@ "True" ] }, - "execution_count": 30, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -1079,34 +1314,45 @@ "\n", "- **Input:** The input is a *heightmap*: a 2D array of characters '0'–'9' representing the heights on the ocean floor. \n", "\n", - "I'll use `parse` to get a tuple of strings such as `\"2199943210\"`, and then use `Grid` to define `g9` as a grid of `{location: height}` where `location` is an `(x, y)` Point and `height` is an int from 0 to 9." + "I'll use `parse` to get a tuple of rows (where each row is a tuple of digits), and turn that into a `Grid`." ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 34, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First 6 lines of Day 9 input:\n", + "-----------------------------\n", + "9897656789865467895698765469899988672134598894345689864101378965457932349943210987654789653198789434\n", + "8789542499996878954329984398789976561012987789245678953212567892345791998899329899765678969997668912\n", + "7678943978987989965998993297649875432129876567956789864487678991056899877778939769886789998766457899\n", + "4578999868998996899867894976532986543299876476897899987569899989167898766567898654998898998655345678\n", + "2456987657679535679756799988643498657987654345789978899789998878998919954349997543219967987543237889\n", + "1234896545568986798645678999754989767898765456998769759899987765789329863238898659301256798793156891\n" + ] + } + ], "source": [ - "in9 = parse(9)\n", - "\n", - "g9 = Grid({(x, y): int(height) \n", - " for x, row in enumerate(in9) \n", - " for y, height in enumerate(row)})" + "in9 = Grid(rows=parse(9, digits))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "- **Part 1**: Find all of the low points on your heightmap. What is the sum of the risk levels of all low points on your heightmap?\n", + "- **Part 1**: Find all of the *low points* on your heightmap. What is the sum of the risk levels of all low points on your heightmap?\n", "\n", "A low point is a point where all the neighbors are higher. The risk level is 1 more than the height of the low point." ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 35, "metadata": {}, "outputs": [ { @@ -1115,22 +1361,22 @@ "True" ] }, - "execution_count": 32, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def low_points(grid) -> List[Point]:\n", - " \"\"\"All low points on map M.\"\"\"\n", + " \"\"\"All low points on grid.\"\"\"\n", " return [p for p in grid \n", " if all(grid[p] < grid[nbr] for nbr in grid.neighbors(p))]\n", "\n", "def total_risk(grid) -> int:\n", - " \"\"\"Sum of height + 1 for all low points on map M.\"\"\"\n", + " \"\"\"Sum of height + 1 for all low points on grid.\"\"\"\n", " return sum(grid[p] + 1 for p in low_points(grid))\n", "\n", - "answer(9.1, total_risk(g9), 607)" + "answer(9.1, total_risk(in9), 607)" ] }, { @@ -1139,14 +1385,14 @@ "source": [ "- **Part 2**: What do you get if you multiply together the sizes of the three largest basins?\n", " \n", - "I thought there was an ambiguity in the definition of *basin*: what happens if there is a high point that is not of height 9? The puzzle description says *Locations of height 9 do not count as being in any basin, and all other locations will always be part of exactly one basin.* I decided this must mean that basins are surrounded by either edges or height 9 locations.\n", + "I thought there was an ambiguity in the definition of *basin*: what happens if there is a high point that is not of height 9, but has low points on either side of it? Wouldn't that high point be part of both basins? The puzzle instructions says *Locations of height 9 do not count as being in any basin, and all other locations will always be part of exactly one basin.* I decided this must mean that the heightmap is carefully arranged so that every basin has only one low point, and every basin is surrounded by either edges or height 9 locations.\n", "\n", - "Given that definition of *basin,* I can associate each location with its low point using a [flood fill](https://en.wikipedia.org/wiki/Flood_fill) from each low point, and then get the sizes of the three largest (most common) basins." + "Given that definition of *basin,* I can associate each location with its low point using a [flood fill](https://en.wikipedia.org/wiki/Flood_fill) that starts from each low point. I can then get the sizes of the three largest (most common) basins and multiply them together." ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 36, "metadata": {}, "outputs": [ { @@ -1155,7 +1401,7 @@ "True" ] }, - "execution_count": 33, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } @@ -1165,22 +1411,22 @@ " \"\"\"Compute `basins` as a map of {point: low_point} for each point in grid.\"\"\"\n", " basins = {} # A dict mapping each non-9 location to its low point.\n", " def flood(p, low):\n", - " \"\"\"Spread from p in all directions until hitting a 9 or an edge;\n", - " mark each point p as being part of the basin starting at `low` point.\"\"\"\n", + " \"\"\"Spread from p in all directions until hitting a 9;\n", + " mark each point p as being part of the basin with `low` point.\"\"\"\n", " if grid[p] < 9 and p not in basins:\n", " basins[p] = low\n", " for p2 in grid.neighbors(p):\n", " flood(p2, low)\n", " for p in low_points(grid):\n", - " flood(p, p)\n", + " flood(p, low=p)\n", " return basins\n", "\n", - "def flood_size_products(grid, k=3) -> int:\n", - " \"\"\"The product of the sizes of the `k` largest basins.\"\"\"\n", + "def flood_size_products(grid, b=3) -> int:\n", + " \"\"\"The product of the sizes of the `b` largest basins.\"\"\"\n", " basins = flood_fill(grid)\n", - " return prod(c for _, c in Counter(basins.values()).most_common(k))\n", + " return prod(c for _, c in Counter(basins.values()).most_common(b))\n", "\n", - "answer(9.2, flood_size_products(g9), 900864)" + "answer(9.2, flood_size_products(in9), 900864)" ] }, { @@ -1192,7 +1438,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 37, "metadata": {}, "outputs": [ { @@ -1201,32 +1447,32 @@ "249" ] }, - "execution_count": 34, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "assert set(low_points(g9)) == set(flood_fill(g9).values())\n", + "assert set(low_points(in9)) == set(flood_fill(in9).values())\n", "\n", - "len(low_points(g9))" + "len(low_points(in9))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "I would like to visualize the basins. I'll use a scatter plot with a color map that displays the 9 heights in yellow and the 0 heights in deep purple, with a gradient in between:" + "I would like to visualize the basins. I'll use a scatter plot that displays the height 9 locations in yellow and the height 0 locations in deep purple, with a gradient in between:" ] }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 38, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1238,14 +1484,14 @@ } ], "source": [ - "def show(g9, low=None):\n", + "def show(in9, low=None):\n", " plt.figure(figsize=(10, 10))\n", - " C = [g9[p] for p in g9]\n", - " plt.scatter(*transpose(g9), marker='s', s=10, c=C, cmap=plt.get_cmap('plasma'))\n", - " if low: plt.plot(*transpose(low_points(g9)), low, markersize=4)\n", + " C = [in9[p] for p in in9]\n", + " plt.scatter(*transpose(in9), marker='s', s=10, c=C, cmap=plt.get_cmap('plasma'))\n", + " if low: plt.plot(*transpose(low_points(in9)), low, markersize=4)\n", " plt.axis('square'); plt.axis('off')\n", " \n", - "show(g9)" + "show(in9)" ] }, { @@ -1257,12 +1503,12 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 39, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1274,7 +1520,7 @@ } ], "source": [ - "show(g9, 'kD')" + "show(in9, 'kD')" ] }, { @@ -1292,18 +1538,29 @@ "source": [ "# [Day 10](https://adventofcode.com/2021/day/10): Syntax Scoring\n", "\n", - "- **Input**: Each entry in the input is a supposedly balanced string, but it may be:\n", - " - Corrupted: \"`{{([]<>)]}`\" should end in `}}`, not `]}`\n", - " - Incomplete: \"`{{([]<>)`\" needs to have `}}` added to be complete.\n", - "\n", - "I'll parse the entries as strs:" + "- **Input**: Each entry in the input is a string of opening and closing brackets: `[({<` and `>})]`.\n" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 40, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First 6 lines of Day 10 input:\n", + "-----------------------------\n", + "[(([{<{(<{{[({{}{}}{[]()})<{{}()}>]}}(([{{{}[]}[[]()]}[<{}[]]{()()}]](({{}{}}{{}()}))){[{({}())[[\n", + "<(({[<([{({[{{<>()}}[{<>()}({}{})]]<{<()<>>{[]()}}(((){}>[[][]])>}([{<[]{}>(<>[])}]))<[[[[[][]\n", + "(<<(<{{{{<<<[(()<>){()<>}][[()()]]>{<{[]{}}<<>()>>}>{(<{<>}([]{})><(<>())<(){}>>)<(([]{})(()()))<<() ...\n", + "[[[[<[{[(<{{{({}<>)((){})}((()())[()()])}}><[([((){})]<[()[]]{{}<>}>)[[{[]<>}][([]{})[{}()]]]]>)<{(<\n", + "[<(<[[((<{((<<<>[]>><<<>{}>>){<[{}<>][<>[]]><<<>()>[(){}]>})[<{[{}<>][(){}]}<[[]<>][{}[]])>{([<>[]][\n", + "(([[[[<([[{([{<>()}{()<>}][((){})]){[{[]<>}({}<>)][(<><>)[()[]]]}}<{{({}{}){[]{}}}<{<><>}({}{})>}>\n" + ] + } + ], "source": [ "in10 = parse(10)" ] @@ -1312,53 +1569,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "Ideally, the brackets are balanced, but entries might be *corrupted* (an extra closing bracket of the wrong kind appears in the wrong place) or *incomplete* (one or more closing brackets are missing from the end).\n", + " \n", "- **Part 1**: Find the first illegal character in each corrupted line of the navigation subsystem. What is the total syntax error score for those errors?\n", "\n", - "When the instructions for Part 1 say \"you can ignore these [incomplete] lines for now,\" I'm pretty sure we will need to deal with incomplete lines on Part 2. So I'll define `analyze_syntax` to return a tuple of two values: an error score and the expected characters for an incomplete line." - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "error_scores = {')': 3, ']': 57, '}': 1197, '>': 25137}\n", - "open_close = {'(': ')', '[': ']', '{': '}', '<': '>'}\n", "\n", - "def analyze_syntax(line) -> Tuple[int, str]:\n", - " \"\"\"A tuple of (error_score, expected_chars) for this line.\"\"\"\n", - " stack = [''] # A stack of closing characters we are looking for.\n", - " for c in line:\n", - " if c == stack[-1]:\n", - " stack.pop()\n", - " elif c in open_close:\n", - " stack.append(open_close[c])\n", - " else: # erroneous character\n", - " return error_scores[c], cat(reversed(stack))\n", - " return 0, cat(reversed(stack))\n", - " \n", - "answer(10.1, sum(analyze_syntax(line)[0] for line in in10), 367059)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "- **Part 2**: Find the completion string for each incomplete line, score the completion strings, and sort the scores. What is the middle score?\n", - "\n", - "To score the completion string, we essentially treat it as a base-5 number, as shown in `completion_score`." + "The instructions for Part 1 say *Some of the lines aren't corrupted, just incomplete; you can ignore these lines for now.* I'm pretty sure that means we will need to deal with incomplete lines in Part 2. So I'll define `analyze_syntax` to return a tuple of two values: an error score for use in Part 1, and the missing characters for an incomplete line, which I suspect will be used in Part 2." ] }, { @@ -1378,25 +1594,492 @@ } ], "source": [ - "def completion_score(completion:str) -> int:\n", - " \"\"\"The completion score for the completion string.\"\"\"\n", - " score = completion.translate(str.maketrans(')]}>', '1234'))\n", - " return int(score, base=5)\n", + "error_scores = {')': 3, ']': 57, '}': 1197, '>': 25137}\n", + "open_close = {'(': ')', '[': ']', '{': '}', '<': '>'}\n", "\n", - "def median_completion_score(lines) -> int:\n", - " \"\"\"The median completion score out of all the uncorrupted lines.\"\"\"\n", - " return median(completion_score(completion) \n", - " for e, completion in map(analyze_syntax, lines) \n", - " if e == 0)\n", - "\n", - "answer(10.2, median_completion_score(in10), 1952146692)" + "def analyze_syntax(line) -> Tuple[int, str]:\n", + " \"\"\"A tuple of (error_score, missing_chars) for this line.\"\"\"\n", + " stack = [''] # A stack of closing characters we are looking for.\n", + " for c in line:\n", + " if c == stack[-1]:\n", + " stack.pop()\n", + " elif c in open_close:\n", + " stack.append(open_close[c])\n", + " else: # erroneous character\n", + " return error_scores[c], cat(reversed(stack))\n", + " return 0, cat(reversed(stack))\n", + " \n", + "answer(10.1, sum(analyze_syntax(line)[0] for line in in10), 367059)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# [Day 11](https://adventofcode.com/2021/day/11): ???" + "- **Part 2**: Find the completion string for each incomplete line, score the completion strings, and sort the scores. What is the middle score?\n", + "\n", + "I was right; we will use the missing characters (now called a \"completion string\"). To score the completion string, we treat it as a base-5 number, as shown in `completion_score`." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def completion_score(completion:str) -> int:\n", + " \"\"\"The completion score for the completion string (the missing characters).\"\"\"\n", + " score = completion.translate(str.maketrans(')]}>', '1234'))\n", + " return int(score, base=5)\n", + "\n", + "def median_completion_score(lines) -> int:\n", + " \"\"\"The median completion score out of all the uncorrupted lines.\"\"\"\n", + " scores = (completion_score(completion) \n", + " for e, completion in map(analyze_syntax, lines) \n", + " if e == 0)\n", + " return median(scores)\n", + "\n", + "answer(10.2, median_completion_score(in10), 1_952_146_692)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# [Day 11](https://adventofcode.com/2021/day/11): Dumbo Octopus\n", + "\n", + "- **Input**: The input is a 2D array of characters `0`–`9` representing the energy levels of bioluminescent [dumbo octopuses](https://www.youtube.com/watch?v=eih-VSaS2g0)." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First 6 lines of Day 11 input:\n", + "-----------------------------\n", + "1224346384\n", + "5621128587\n", + "6388426546\n", + "1556247756\n", + "1451811573\n", + "1832388122\n" + ] + } + ], + "source": [ + "in11 = Grid(rows=parse(11, digits), neighbors=neighbors8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **Part 1**: Given the starting energy levels of the dumbo octopuses in your cavern, simulate 100 steps. How many total flashes are there after 100 steps?\n", + "\n", + "On each step, each octopus increases by one energy unit; then the ones that are over 9 flash, which makes their neighbors get one more energy unit (potentially causing others to flash); then the flashers reset to zero energy." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def simulate_flashes(grid, steps=100) -> int:\n", + " \"\"\"Simulate octopus flashes for `steps` steps and return total number of flashes.\"\"\"\n", + " grid = grid.copy() # Don't mutate the original grid\n", + " flashes = 0\n", + " for step in range(steps):\n", + " flashers = set()\n", + " for p in grid:\n", + " grid[p] += 1\n", + " for p in grid:\n", + " check_flash(grid, p, flashers)\n", + " for p in flashers:\n", + " grid[p] = 0\n", + " flashes += len(flashers)\n", + " return flashes\n", + "\n", + "def check_flash(grid, p, flashers):\n", + " \"\"\"Check if grid[p] flashes, and if so, recursively spread.\"\"\"\n", + " if grid[p] > 9 and p not in flashers:\n", + " flashers.add(p)\n", + " for p2 in grid.neighbors(p):\n", + " grid[p2] += 1\n", + " check_flash(grid, p2, flashers)\n", + " \n", + "answer(11.1, simulate_flashes(in11, 100), 1591)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **Part 2**: If you can calculate the exact moments when the octopuses will all flash simultaneously, you should be able to navigate through the cavern. What is the first step during which all octopuses flash?\n", + "\n", + "I feel a bit bad that I have to copy/paste/edit the whole simulation function, changing just the number of steps and the return. But at least I don't have to copy the recursive `check_flash` function." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def simulate_flashes2(grid) -> int:\n", + " \"\"\"Simulate octopus flashes and return the first step during which all octopuses flash.\"\"\"\n", + " grid = grid.copy() # Don't mutate the original grid\n", + " for step in count_from(1):\n", + " flashers = set()\n", + " for p in grid:\n", + " grid[p] += 1\n", + " for p in grid:\n", + " check_flash(grid, p, flashers)\n", + " for p in flashers:\n", + " grid[p] = 0\n", + " if len(flashers) == len(grid):\n", + " return step\n", + " \n", + "answer(11.2, simulate_flashes2(in11), 314)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# [Day 12](https://adventofcode.com/2021/day/11): Passage Pathing\n", + "\n", + "- **Input**: Each entry in the input is a connection between two caves. Big caves are written in uppercase, small caves in lowercase. `start` and `end` are two special caves with the obvious meaning." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First 6 lines of Day 12 input:\n", + "-----------------------------\n", + "xx-xh\n", + "vx-qc\n", + "cu-wf\n", + "ny-LO\n", + "cu-DR\n", + "start-xx\n" + ] + } + ], + "source": [ + "in12 = parse(12, words)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **Part 1**: How many paths through this cave system are there that visit small caves at most once?\n", + "\n", + "My approach is as follows:\n", + "- I'll define a path as a list of cave names: `['start', ..., 'end']`.\n", + "- I'll construct `neighbors` as a mapping from a cave to the list of caves it connects to.\n", + "- I'll do depth-first search, starting from the trivial path `['start']` and returning all possible paths. " + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Path = List[str]\n", + " \n", + "def search_paths(path, neighbors) -> Iterable[Path]:\n", + " \"\"\"All paths that start with `path` and lead to 'end' using `neighbors`.\n", + " Small caves can only be visited once.\"\"\"\n", + " if path[-1] == 'end':\n", + " yield [path]\n", + " else:\n", + " for cave in neighbors[path[-1]]:\n", + " if cave.isupper() or cave not in path:\n", + " yield from search_paths(path + [cave], neighbors)\n", + "\n", + "neighbors = multimap(in12, symmetric=True)\n", + " \n", + "answer(12.1, quantify(search_paths(['start'], neighbors)), 4167)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **Part 2**: After reviewing the available paths, you realize you might have time to visit a single small cave twice. However, the caves named `start` and `end` can only be visited exactly once each. Given these new rules, how many paths through this cave system are there?\n", + "\n", + "At first I felt bad that I would again have to copy/paste/edit the code for Part 1. I felt a bit better when I realized that the revised function `search_paths2` would have need to call the original `search_paths`: once we add a small cave for the second time, the remainder of the search should be under the `search_paths` rules, not the `search_paths2` rules." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def search_paths2(path, neighbors):\n", + " \"\"\"Find all paths that start with `path` and lead to 'end' using `neighbors`.\n", + " Small caves can only be visited once, except one of them may be visited twice.\"\"\"\n", + " if path[-1] == 'end':\n", + " yield [path]\n", + " else:\n", + " for cave in neighbors[path[-1]]:\n", + " if cave.isupper() or cave not in path:\n", + " yield from search_paths2(path + [cave], neighbors)\n", + " elif cave.islower() and cave != 'start':\n", + " yield from search_paths(path + [cave], neighbors)\n", + " \n", + "answer(12.2, quantify(search_paths2(['start'], neighbors)), 98441)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# [Day 13](https://adventofcode.com/2021/day/13): Transparent Origami\n", + "\n", + "- **Input**: The input is in two section: first, a set of (x,y) dots, e.g. \"`6,10`\". Second, a list of fold instructions, e.g. \"`fold along y=7`\".\n", + "\n", + "My `parse` command is not set up to parse different sections differently, so I'll have `parse` do a minimal amount of work, returning two lists of lines for the two sections. Then I'll transform the first section into `dots` (a set of `(x, y)` points) and the second section into `folds` (a list of instructions like `('y', 7)`)." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First 6 lines of Day 13 input:\n", + "-----------------------------\n", + "103,224\n", + "624,491\n", + "808,688\n", + "1076,130\n", + "700,26\n", + "55,794\n" + ] + } + ], + "source": [ + "in13 = parse(13, str.splitlines, sep='\\n\\n')\n", + "dots = {ints(line) for line in in13[0]}\n", + "folds = [(words(line)[2], ints(line)[0]) for line in in13[1]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The fold instructions don't show up in the first 6 lines, so let's make sure I parsed them right:" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[('x', 655),\n", + " ('y', 447),\n", + " ('x', 327),\n", + " ('y', 223),\n", + " ('x', 163),\n", + " ('y', 111),\n", + " ('x', 81),\n", + " ('y', 55),\n", + " ('x', 40),\n", + " ('y', 27),\n", + " ('y', 13),\n", + " ('y', 6)]" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "folds" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The idea of this puzzle is that the dots are on transparent paper, and when following the `fold along y=7` instruction, all the dots below the line `y=7` are reflected above the line. Similarly, for an `x` fold, all the points to the right of the line are reflected to the left. When we finish the folds, a code message will appear.\n", + "\n", + "- **Part 1**: How many dots are visible after completing just the first fold instruction on your transparent paper?" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "def fold(dots, instruction) -> Set[Point]: \n", + " \"\"\"The set of dots that result from following the fold instruction.\"\"\"\n", + " axis, line = instruction\n", + " if axis == 'x':\n", + " return {(x, y) if x <= line else (2 * line - x, y)\n", + " for (x, y) in dots}\n", + " else:\n", + " return {(x, y) if y <= line else (x, 2 * line - y)\n", + " for (x, y) in dots}" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "answer(13.1, len(fold(dots, folds[0])), 638)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **Part 2**: Finish folding the transparent paper according to the instructions. The manual says the code is always eight capital letters. " + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def origami(dots, instructions) -> None:\n", + " \"\"\"Follow all the instructions and plot the resulting dots.\"\"\"\n", + " for instruction in instructions:\n", + " dots = fold(dots, instruction)\n", + " plt.scatter(*transpose(dots), marker='s')\n", + " plt.axis('equal'); plt.gca().invert_yaxis()\n", + " \n", + "answer(13.2, origami(dots, folds), None) # actual answer: CJCKBAPB" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I kind of cheated here. I didn't want to write an OCR program, so I relied on my own two eyes to look at the plot and see the answer." ] } ],