{ "cells": [ { "cell_type": "markdown", "id": "4f0ef1f2-0c73-4ef5-b430-48fe4ce450c0", "metadata": {}, "source": [ "
Peter Norvig, December 2024
\n", "\n", "# Advent of Code 2024\n", "\n", "I enjoy doing the [**Advent of Code**](https://adventofcode.com/) (AoC) programming puzzles, so here we go for 2024! This is the 10th year, so congratulations to puzzle creator [**Eric Wastl**](https://adventofcode.com/2024/about). Our old friend [**Gary Grady**](https://find.sciences.social/search/accounts/@garygrady@mastodon.social) is here to provide illustrations:\n", "\n", "\"GaryJGrady\n", "\n", "Even before December 1st I can start by loading up my [**AdventUtils.ipynb**](AdventUtils.ipynb) notebook (same as last time except for the `current_year`):" ] }, { "cell_type": "code", "execution_count": 2, "id": "ed82ed5b-a42d-468b-8f6e-288d3c2de20b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3.12.7 | packaged by Anaconda, Inc. | (main, Oct 4 2024, 08:22:19) [Clang 14.0.6 ]\n" ] } ], "source": [ "%run AdventUtils.ipynb\n", "current_year = 2024\n", "\n", "print(sys.version)" ] }, { "cell_type": "markdown", "id": "dfecffd7-6955-45ba-9dc2-1ec805baba85", "metadata": {}, "source": [ "Each day's solution consists of these parts, making use of my `parse` and `answer` utilities:\n", "- **Reading the input**: Parse the input file with, e.g. `pairs = parse(1, ints)`. \n", "- **Solving Part One**: Find the solution and record it with, e.g., `answer(1.1, 4, lambda: 2 + 2)`.\n", "- **Solving Part Two**: Find the solution and record it with, e.g., `answer(1.2, 9, lambda: 3 * 3)`.\n", "- *(Optional Part Three: On some days, I'll add some further exploration, visualization, or verification.)*\n", "\n", "The function `parse` assumes that the input is a sequence of sections (default one per line), each of which should be parsed in some way and then returned as a tuple. The parsing method `ints` says to treat each section as a tuple of integers. The function `answer` checks that the correct answer is computed (useful for regression testing), and records the run time (that's why a `lambda:` is used). You can read the [**AdventUtils.ipynb**](AdventUtils.ipynb) notebook for more on these functions (and the other utilities used throughout this notebook, such as the `Grid` class).\n", "\n", "To fully understand each day's puzzle, and to follow along the drama involving Santa, the elves, the reindeer, some elephants, the Chief Historian, and all the rest, you need to read the puzzle descriptions on the [**AoC**](https://adventofcode.com/) site, as linked in the header for each day's solutions (e.g. [**Day 1**](https://adventofcode.com/2023/day/1) below). " ] }, { "cell_type": "markdown", "id": "4c6120a1-3129-44ff-935c-30c1d81ae028", "metadata": {}, "source": [ "# [Day 1](https://adventofcode.com/2024/day/1) Historian Hysteria\n", "\n", "According to the narrative, North Pole Historians created two lists of **location IDs**. We can parse them as a sequence of pairs of integers, and then use the transpose function, `T`, from my [AdventUtils](AdventUtils.ipynb) to get two tuples of ID numbers:" ] }, { "cell_type": "code", "execution_count": 5, "id": "22e5d621-a152-4712-866f-f8b962b5dd14", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 1000 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "38665 13337\n", "84587 21418\n", "93374 50722\n", "68298 57474\n", "54771 18244\n", "49242 83955\n", "66490 44116\n", "65908 51323\n", "...\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Parsed representation ➜ 1000 tuples:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "(38665, 13337)\n", "(84587, 21418)\n", "(93374, 50722)\n", "(68298, 57474)\n", "(54771, 18244)\n", "(49242, 83955)\n", "(66490, 44116)\n", "(65908, 51323)\n", "...\n" ] } ], "source": [ "left, right = T(parse(1, ints))" ] }, { "cell_type": "markdown", "id": "63cf2940-e251-49e4-8bc9-f1bcd599f8f4", "metadata": {}, "source": [ "\n", "\n", "### Part 1: What is the total distance between your lists?\n", "\n", "The **distance** between two numbers is defined as the absolute value of their difference, and the **total distance** between two lists is the sum of the distances between respective pairs, where \"respective\" means to sort each list and then take the distance between the first element of each list, plus the distance between the second element of each list, and so on. (I use the transpose utility function, `T`, to turn the input sequence of 1000 pairs into two lists, each of 1000 integers.)" ] }, { "cell_type": "code", "execution_count": 7, "id": "8d6bc9f5-5fa1-4dad-bd43-d957833d8ea9", "metadata": {}, "outputs": [], "source": [ "def total_distance(left: Ints, right: Ints) -> int:\n", " \"\"\"Total distance between respective list elements, after sorting.\"\"\"\n", " return sum(abs(a - b) for a, b in zip(sorted(left), sorted(right)))" ] }, { "cell_type": "code", "execution_count": 8, "id": "6ada5e5b-2fb7-4198-a5bb-7b2af4b9270a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 1.1: .000 seconds, answer 1830467 ok" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(1.1, 1830467, lambda:\n", " total_distance(left, right))" ] }, { "cell_type": "markdown", "id": "88e26234-f1d2-4a62-86b0-2ad9251215eb", "metadata": {}, "source": [ "### Part 2: What is their similarity score?\n", "\n", "The **similarity score** is defined as the sum of each element of the left list times the number of times that value appears in the right list." ] }, { "cell_type": "code", "execution_count": 10, "id": "0131e096-38d1-4c13-9e9c-b0d09839a5cf", "metadata": {}, "outputs": [], "source": [ "def similarity_score(left: Ints, right: Ints) -> int:\n", " \"\"\"The sum of each x in `left` times the number of times x appears in `right`.\"\"\"\n", " counts = Counter(right)\n", " return sum(x * counts[x] for x in left)" ] }, { "cell_type": "code", "execution_count": 11, "id": "6f6c298a-53a1-4d80-8747-7dd713d4d4f0", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 1.2: .000 seconds, answer 26674158 ok" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(1.2, 26674158, lambda:\n", " similarity_score(left, right))" ] }, { "cell_type": "markdown", "id": "b895bb80-2269-423f-a33c-abaa3d96561a", "metadata": {}, "source": [ "As usual, the first day is something of a warm-up, coding up a solution is easy, and both parts run in under a millisecond (I don't need to know anything more precise than that)." ] }, { "cell_type": "markdown", "id": "b9fa4fe0-4194-47d7-b815-b571af98caee", "metadata": {}, "source": [ "# [Day 2](https://adventofcode.com/2024/day/2): Red-Nosed Reports\n", "\n", "Today's input is a sequence of engineering safety **reports**, each of which consists of a sequence of integers:" ] }, { "cell_type": "code", "execution_count": 14, "id": "10e1ab83-a6ec-4143-ad9a-eaae220adcde", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 1000 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "74 76 78 79 76\n", "38 40 43 44 44\n", "1 2 4 6 8 9 13\n", "65 68 70 72 75 76 81\n", "89 91 92 95 93 94\n", "15 17 16 18 19 17\n", "46 47 45 48 51 52 52\n", "77 78 79 82 79 83\n", "...\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Parsed representation ➜ 1000 tuples:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "(74, 76, 78, 79, 76)\n", "(38, 40, 43, 44, 44)\n", "(1, 2, 4, 6, 8, 9, 13)\n", "(65, 68, 70, 72, 75, 76, 81)\n", "(89, 91, 92, 95, 93, 94)\n", "(15, 17, 16, 18, 19, 17)\n", "(46, 47, 45, 48, 51, 52, 52)\n", "(77, 78, 79, 82, 79, 83)\n", "...\n" ] } ], "source": [ "reports = parse(2, ints)" ] }, { "cell_type": "markdown", "id": "5dfd72c2-06c6-4c71-ae37-0c2c84074091", "metadata": {}, "source": [ "### Part 1: How many reports are safe?\n", "\n", "A report is **safe** if it is monotonically strictly increasing or strictly decreasing, and if no jump between adjacent numbers is greater than 3 in absolute value." ] }, { "cell_type": "code", "execution_count": 16, "id": "0f6b6744-e93d-47cf-accd-daab9f3650d0", "metadata": {}, "outputs": [], "source": [ "def is_safe(report: Ints) -> bool:\n", " \"\"\"A report is safe if all adjacent-number-jumps are either in {1, 2, 3} or in {-1, -2, -3}.\"\"\"\n", " jumps = set_of_jumps(report)\n", " return jumps.issubset({1, 2, 3}) or jumps.issubset({-1, -2, -3})\n", " \n", "def set_of_jumps(numbers: Ints) -> Set[int]:\n", " \"\"\"The set of differences between adjacent numbers.\"\"\"\n", " return {numbers[i] - numbers[i - 1] for i in range(1, len(numbers))}" ] }, { "cell_type": "markdown", "id": "5625ad98-f571-4451-ad19-8614833dfb10", "metadata": {}, "source": [ "Here are examples of how these functions work:" ] }, { "cell_type": "code", "execution_count": 18, "id": "c0cc052b-e9ef-4757-a860-4cd34dd00fb8", "metadata": {}, "outputs": [], "source": [ "assert set_of_jumps((7, 6, 4, 2, 1)) == {-1, -2}\n", "assert is_safe((7, 6, 4, 2, 1)) == True" ] }, { "cell_type": "markdown", "id": "051c71b7-4375-4812-b7cc-0c50adf20a09", "metadata": {}, "source": [ "And here is the answer to the puzzle:" ] }, { "cell_type": "code", "execution_count": 20, "id": "e662bf10-4d6a-40f1-95ce-dfc39f5b3fc2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 2.1: .000 seconds, answer 257 ok" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(2.1, 257, lambda:\n", " quantify(reports, is_safe))" ] }, { "cell_type": "markdown", "id": "ee48bf63-8a67-407b-9a73-df097811eabc", "metadata": {}, "source": [ "Note: I used my [AdventUtils](AdventUtils.ipynb) function `quantify` (adapted from the [itertools recipes](https://docs.python.org/3/library/itertools.html#itertools-recipes)). `quantify(reports, is_safe)` counts the number of items in `reports` for which `is_safe` is true.\n", "\n", "### Part 2: How many reports are safe using the Problem Dampener?\n", "\n", "The **problem dampener** says that a report is safe if there is some way to drop one number and get a safe report. So I'll generate all ways of dropping one number and check each one for safety." ] }, { "cell_type": "code", "execution_count": 22, "id": "6c78f864-5425-472f-9740-6f44650a98ca", "metadata": {}, "outputs": [], "source": [ "def is_safe_with_dampener(report: Ints) -> bool:\n", " \"\"\"Is there any way to drop one element of `report` to get a safe report?\"\"\"\n", " return any(map(is_safe, drop_one(report)))\n", "\n", "def drop_one(seq: Sequence) -> Iterable[Sequence]:\n", " \"\"\"All ways of dropping one element of the input sequence.\"\"\"\n", " return (seq[:i] + seq[i + 1:] for i in range(len(seq)))" ] }, { "cell_type": "code", "execution_count": 23, "id": "7f492898-a704-4fb4-a93f-824f655d1f51", "metadata": {}, "outputs": [], "source": [ "assert set(drop_one('1234')) == {'234', '134', '124', '123'}" ] }, { "cell_type": "code", "execution_count": 24, "id": "d1b9ffb5-af7a-465f-a063-c31df2d0605c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 2.2: .002 seconds, answer 328 ok" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(2.2, 328, lambda:\n", " quantify(reports, is_safe_with_dampener))" ] }, { "cell_type": "markdown", "id": "54d6a0c2-a8ed-404d-abc0-72aa28a49f5d", "metadata": {}, "source": [ "# [Day 3](https://adventofcode.com/2024/day/3): Mull It Over\n", "\n", "Today's input is a computer program with some corrupted characters. The program has multiple lines, but newlines don't matter in this programming language, so I will concatenate them into one big string:" ] }, { "cell_type": "code", "execution_count": 26, "id": "78080200-0f9f-4492-9bee-c936737ee96f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 6 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "where(536,162)~'what()what()how(220,399){ mul(5,253);mul(757,101)$where()@why()who()&when()from( ...\n", "}?~who()select()-mul(316,505)&%*how()mul(363,589)>?%-:)where()~{{mul(38,452)select()%>[{]%>%mul( ...\n", "?>where(911,272)'mul(894,309)~+%@#}@#why()mul(330,296)what()mul(707,884)mul;&}<{>where()$why()]m ...\n", "> (when()[where()/#!/usr/bin/perl,@;mul(794,217)select():'])select()mul(801,192)why()&]why()/:]* ...\n", ",+who():mul(327,845)/ >@[>@}}mul(86,371)!~&&~how(79,334)mul(637,103)why()mul(358,845)-#~?why(243 ...\n", "where()#{*,!?:$mul(204,279)what()!{ what()mul(117,94)!select()>:mul(665,432)#don't()!!\"GaryJGrady\n", "\n", "\n", "### Part 1: What do you get if you add up all of the results of the multiplications?\n", "\n", "For Part 1, just look for instructions of the form \"mul(*digits*,*digits*)\", using a regular expression and `re.findall`. Perform each of these multiplications and add them up, and ignore all other characters/instructions:" ] }, { "cell_type": "code", "execution_count": 28, "id": "bf6366b1-6952-47d8-8b3c-09f8d05ec093", "metadata": {}, "outputs": [], "source": [ "def execute(program: str) -> int:\n", " \"\"\"The sum of the results of the multiply instructions.\"\"\"\n", " return sum(prod(ints(m)) for m in all_multiplications(program))\n", "\n", "all_multiplications = re.compile(r'mul\\(\\d+,\\d+\\)').findall" ] }, { "cell_type": "code", "execution_count": 29, "id": "2032c903-5f23-4c16-ba68-410b6c1750e1", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 3.1: .001 seconds, answer 156388521 ok" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(3.1, 156388521, lambda: \n", " execute(program))" ] }, { "cell_type": "markdown", "id": "622d7010-145e-422a-a592-d4b446afcc0f", "metadata": {}, "source": [ "### Part 2: What do you get if you add up all of the results of just the enabled multiplications?\n", "\n", "For Part 2, the instruction \"`don't()`\" says to **disable** (ignore) following multiply instructions until a \"`do()`\" instruction **enables** them again. I will define the function `enabled`, which returns the part of the program that is enabled, by susbstituting a space for the \"`don't()...do()`\" sequence (or a \"`don't()...`\" sequence that goes to the end of the file)." ] }, { "cell_type": "code", "execution_count": 31, "id": "4525d01a-bac0-41c2-92b8-baf0fd395e88", "metadata": {}, "outputs": [], "source": [ "def enabled_part(program: str) -> str:\n", " \"\"\"Just the part of the program that is enabled; remove \"don't()...do()\" text.\"\"\"\n", " return re.sub(r\"don't\\(\\).*?(do\\(\\)|$)\", \" \", program)" ] }, { "cell_type": "code", "execution_count": 32, "id": "ce40f258-ca76-48c3-9965-27a6979a4243", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 3.2: .000 seconds, answer 75920122 ok" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(3.2, 75920122, lambda:\n", " execute(enabled_part(program)))" ] }, { "cell_type": "markdown", "id": "81b1ed3a-5bdb-4ef9-957d-25bcb19e3a00", "metadata": {}, "source": [ "### Part 3: Verification\n", "\n", "Regular expressions are [always tricky](https://blog.codinghorror.com/regular-expressions-now-you-have-two-problems/), so here are some assertions to give us more confidence that we got the components right (and to show some examples of their use)." ] }, { "cell_type": "code", "execution_count": 34, "id": "1cb1b8e5-1ad7-4364-8816-73669f9c0777", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "assert all_multiplications(\"mul(1,2) + mul(34,5) - mul(67,89] / mul(x,15)\") == ['mul(1,2)', 'mul(34,5)']\n", "assert enabled_part(\"testing(1,2,3)\") == \"testing(1,2,3)\"\n", "assert enabled_part(\"preamble don't() middle part do() final\") == 'preamble final'\n", "enabled_part(\"preamble don't() middle part no do, final\") == 'preamble ' # Make sure it works without a closing \"do()\"" ] }, { "cell_type": "markdown", "id": "e1448343-6488-45ad-b03d-d7928feb75cd", "metadata": {}, "source": [ "# [Day 4](https://adventofcode.com/2024/day/4): Ceres Search\n", "\n", "Today's puzzle is a 2D word-search puzzle:" ] }, { "cell_type": "code", "execution_count": 36, "id": "a0d903b9-018e-4861-9314-cafed59055fd", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 140 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "MASAMXMSSXXMAMXXMXMASXMASXMMSMSMMMAXMASASMMSSMSXAXMASMMSMMMSSMSASMSSSSMSMSMXXMXMAXAMXMSMSSXSAMXM ...\n", "MASMMXMASAXASMSMMMSAMXSMSAMXAAAAAXAMXASXAMAAAAMMSMMMMMASXAAAAMMAMAMMASAAAAXMXMSSSSSSMMSAMAXAXXSM ...\n", "MMXAXMMMSXMAMAAXAAXAAAXXSMMSMSMSMXAXMXSMMMMSSMXAMXAAXMAMMMMSSMMAMAMMAMMMMMXSAAXAAMMAXXSAMXMSMAXM ...\n", "SXSAMASASMSXMSMSMSSMMMMMMXAMXMMXMASMMMMAXXAAAMMMSSSSSMASXXAAXASMSXXMXSXSXSASMSMMSMSAMMMAMXAAMASX ...\n", "AAAXXXMASASXMXMAXXMMASAASMXSASASXAAAAMSSMMMSXMAAMMMMMXAXMMMMSAMXAMASAMXSAMASXXAXAAMAMXSAMXSXSMMA ...\n", "MSMMXXMMMAMAMMMMMMXSAXXAMMMMXSAXMMXXAMXAAMMXMASXMAAASMMXAAMXAXAMMMAMAMAMAMXMASXMMXMAAXMAXMAMXMSA ...\n", "MXAXAMXXMMMMSAMAASMMMSMMASASAMAMAXMSXMSMMXAMXAXMMSSXSASXSSSMAMSMXMXSAMSSSMAMXMXAMAXXMMSAXAXMMXMA ...\n", "ASXMMXSAMXAASXXMXSAAAXASAMMMASMSSSMAAMMXMMSSMASAMAMMMAMMAXMAXMASXMAXMSAAASASAMXSSMXSAAXSSMXAAXXA ...\n", "...\n" ] } ], "source": [ "xmas_grid = Grid(parse(4))" ] }, { "cell_type": "markdown", "id": "16d56872-be2c-4e9d-8821-a0fe9f66970b", "metadata": {}, "source": [ "### Part 1: How many times does XMAS appear?\n", "\n", "We just have to find how many times the word \"XMAS\" appears in the grid, horizontally, vertically, or diagonally, forwards or backwards. The variable `directions8` contains those eight directions (as (delta-x, delta-y) pairs). So examine each square of the grid and if it contains \"X\", see in how many of the directions it spells \"XMAS\". (Note that locations in the grid are denoted by `(x, y)` coordinates, as are directions (e.g., `(1, 0)` is the `East` direction. (The functions `add` and `mul` do addition and scalar multiplication on these 2D vectors.)" ] }, { "cell_type": "code", "execution_count": 38, "id": "72d48abb-7a82-452f-b91d-838b3836a90f", "metadata": {}, "outputs": [], "source": [ "def word_search(grid: Grid, word='XMAS') -> int:\n", " \"\"\"How many times does the given word appear in the grid?\"\"\"\n", " return quantify(grid_can_spell(grid, start, dir, word) \n", " for start in grid \n", " if grid[start] == word[0]\n", " for dir in directions8)\n", "\n", "def grid_can_spell(grid, start, dir, word):\n", " \"\"\"Does `word` appear in grid starting at `start` and going in direction `dir`?\"\"\"\n", " return all(grid[add(start, mul(dir, i))] == ch \n", " for i, ch in enumerate(word))" ] }, { "cell_type": "code", "execution_count": 39, "id": "6175362b-d8b4-45d1-b70c-d8575a0fe188", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 4.1: .021 seconds, answer 2401 ok" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(4.1, 2401, lambda:\n", " word_search(xmas_grid))" ] }, { "cell_type": "markdown", "id": "eabe90c4-b668-4d9e-a345-b09f4b8ee42b", "metadata": {}, "source": [ "### Part 2: How many times does an X-MAS appear?\n", "\n", "Upon further review, the goal is not to find \"XMAS\" byt rather X-\"MAS\"; that is, two \"MAS\" words in an X pattern. The pattern can be any of these four:\n", "\n", " M.S S.M M.M S.S\n", " .A. .A. .A. .A.\n", " M.S S.M S.S M.M\n", "\n", "I decided to find these by first looking for each the middle letter (\"A\") in the grid, and then, for each \"A\" and for each of the four pairs of diagonal directions, see if the target word (\"MAS\") can be spelled in both directions:" ] }, { "cell_type": "code", "execution_count": 41, "id": "3d8a051f-cf7b-4e8c-b0fb-78c3f089989d", "metadata": {}, "outputs": [], "source": [ "diagonal_pairs = ([SE, NE], [SW, NW], [SE, SW], [NE, NW])\n", "\n", "def x_search(grid: Grid, word='MAS') -> int:\n", " \"\"\"How many times does an X-MAS appear in the grid?\"\"\"\n", " A_positions = grid.findall(word[1]) # All positions where an 'A' (the mid-letter 'MAS') appears\n", " return quantify((grid_can_spell(grid, sub(mid_pos, dir1), dir1, word) and\n", " grid_can_spell(grid, sub(mid_pos, dir2), dir2, word))\n", " for mid_pos in A_positions\n", " for dir1, dir2 in diagonal_pairs)" ] }, { "cell_type": "code", "execution_count": 42, "id": "64cde1d9-f58c-4633-b5da-87908a02f76d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 4.2: .015 seconds, answer 1822 ok" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(4.2, 1822, lambda:\n", " x_search(xmas_grid))" ] }, { "cell_type": "markdown", "id": "0249ce80-e649-44b3-8c02-613fc7652110", "metadata": {}, "source": [ "# [Day 5](https://adventofcode.com/2024/day/5): Print Queue\n", "\n", "Today's puzzle involves some **sleigh launch safety manuals** that need to be updated with new printings. The day's input is in two sections: the first a set of **rules** such as \"47|53\", which means that if an update prints both page 47 and page 53, then it must print 47 sometime before 53. The second section is a list of **updates** of the form \"75,47,61,53,29\", meaning that for one version of the safety manual, those are the pages that need to be printed, and that is the suggested order of printing.\n", "\n", "\n", "\n", "I mostly like my `parse` function: it is easy to tell it how to break the input into sections and how to parse every section, if all the sections are the same. But I admit my `parse` is not ideal when an input file has sections with two different formats. I'll parse the two sections as paragraphs, and then call `parse` again on each paragraph:" ] }, { "cell_type": "code", "execution_count": 44, "id": "b77a5a1f-a43b-4ce8-a60c-94d69a595505", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 1366 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "48|39\n", "39|84\n", "39|23\n", "95|51\n", "95|76\n", "95|61\n", "14|52\n", "14|49\n", "...\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Parsed representation ➜ 2 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "48|39\n", "39|84\n", "39|23\n", "95|51\n", "95|76\n", "95|61\n", "14|52\n", "14|49\n", "14|39\n", "14|53\n", "85|19\n", "85|25\n", "85|61\n", "85|35\n", "85|58\n", "74|86\n", " ...\n", "61,58,51,32,12,14,71\n", "58,25,54,14,12,94,32,76,39\n", "35,53,26,77,14,71,25,76,85,55,51,49,95\n", "32,91,76, ...\n" ] } ], "source": [ "manual = parse(5, sections=paragraphs)\n", "rules = set(parse(manual[0], ints))\n", "updates = parse(manual[1], ints)" ] }, { "cell_type": "markdown", "id": "c6e4d0b6-c69e-4284-9757-cf3ce51b196c", "metadata": {}, "source": [ "Here I show what the rules and updates look like:" ] }, { "cell_type": "code", "execution_count": 46, "id": "4c85a23e-686a-4129-a14c-ff6f6a88b9ac", "metadata": {}, "outputs": [], "source": [ "assert (48, 39) in rules # `rules` is a set of (earlier, later) page number pairs\n", "assert updates[0] == (61, 58, 51, 32, 12, 14, 71) # `updates` is a sequence of page number tuples" ] }, { "cell_type": "markdown", "id": "d6b6d374-cbe9-4b84-a1dd-d9df927c7182", "metadata": {}, "source": [ "### Part 1: What do you get if you add up the middle page number from the correctly-ordered updates?\n", "\n", "An update is correct if no combination of two pages in the update violates any of the rules. I'll define `is_correct` to implement this check, and `sum_of_correct_middles` to add up the middle numbers of the correct updates:" ] }, { "cell_type": "code", "execution_count": 48, "id": "78898d37-46ff-4367-9d89-b2a107a90aa1", "metadata": {}, "outputs": [], "source": [ "def sum_of_correct_middles(rules: Set[Ints], updates: Tuple[Ints]) -> int:\n", " \"\"\"The sum of the middle elements of each update that is correct.\"\"\"\n", " return sum(middle(update) for update in updates if is_correct(update, rules))\n", "\n", "def is_correct(update: Ints, rules: Set[Ints]) -> bool:\n", " \"\"\"An update is correct if no pair of pages violates a rule in the rules set.\"\"\"\n", " return not any((second, first) in rules for (first, second) in combinations(update, 2))\n", "\n", "def middle(seq: Sequence) -> object: return seq[len(seq) // 2]" ] }, { "cell_type": "code", "execution_count": 49, "id": "b1c87359-1d2d-4a90-8305-9d152ce5d547", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 5.1: .001 seconds, answer 5762 ok" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(5.1, 5762, lambda:\n", " sum_of_correct_middles(rules, updates))" ] }, { "cell_type": "markdown", "id": "80da4fd9-b11e-4dbb-8d22-2071d1a89827", "metadata": {}, "source": [ "### Part 2: What do you get if you add up the middle page numbers of the correction of each incorrect update?\n", "\n", "In Part 2 we have to find the incorrect updates, re-order them into a correct order, and sum the middle page numbers of just these corrected updates.\n", "Since I have already defined `is_correct`, I could just generate all permutations of each update and find one that `is_correct`. That would work great if the longest update consists of only 5 pages, as it does in the example input. But what is the longest update in *my* input?" ] }, { "cell_type": "code", "execution_count": 51, "id": "d8718c3e-0b3b-49ce-8cca-abd82aa788d7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "23" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "max(map(len, updates))" ] }, { "cell_type": "markdown", "id": "4449200f-dd19-48f1-94b2-7304daa9fa00", "metadata": {}, "source": [ "That's not great. With 23 page numbers there are 23! permutations, which is over 25 sextillion. So instead, here's my strategy:\n", "\n", "- Instead of generating all permutations, `correction` will **sort** an update, returning a corrected reordering that obeys all the rules. This is a [topological sort](https://en.wikipedia.org/wiki/Topological_sorting) and is guaranteed to give a correct reordering (unless the rules contain a contradiction like \"2 must be before 3 and 3 must be before 2\"). There may be multiple correct orderings (for example, if there are no rules involving the pages in the update, then any ordering is correct). It used to be that Python's `sort` method allowed a `cmp` keyword to compare two values; there is vestigial support for this with the `functools.cmp_to_key` function. I will sort each update so that page *m* comes before page *n* if (*m*, *n*) is in the rules, and *m* comes after *n* if (*n*, *m*) is in the rules. Sorting will be about a sextillion times faster than enumerating permutations.\n", "- `corrected` will find all the incorrect updates and correct them." ] }, { "cell_type": "code", "execution_count": 53, "id": "7222dc1c-067f-4bb5-84e1-3c2fc72fd53a", "metadata": {}, "outputs": [], "source": [ "def correction(update: Ints, rules) -> Ints:\n", " \"\"\"Reorder the update to make it correctly obey all the rules.\"\"\"\n", " def rule_lookup(m, n): return +1 if (m, n) in rules else -1 if (n, m) in rules else 0\n", " return sorted(update, key=functools.cmp_to_key(rule_lookup))\n", "\n", "def corrected(updates, rules) -> List[Ints]:\n", " \"\"\"Returns a list of corrected versions of all the incorrect rules.\"\"\"\n", " return [correction(update, rules) for update in updates if not is_correct(update, rules)]" ] }, { "cell_type": "code", "execution_count": 54, "id": "494cda6e-6b07-4054-9b03-45f61bd4f973", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 5.2: .001 seconds, answer 4130 ok" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(5.2, 4130, lambda:\n", " sum_of_correct_middles([], corrected(updates, rules)))" ] }, { "cell_type": "markdown", "id": "53b1ccbc-01ae-43d0-a75f-3f9389fdd3c9", "metadata": {}, "source": [ "I have to say, I'm pleased that so far I've had no bugs (other than simple typos like not closing a paren). Today I was worried I might have my `+1` and `-1` backwards in `cmp_to_key`, but so far, everything has gone smoothly. However, I have no chance of showing up on the leaderboard; I'm still *way* slower than skilled contest programmers, not to mention the automated large language models that some people are using." ] }, { "cell_type": "markdown", "id": "38258423-e3b8-4bae-8aeb-28f07f0d5a35", "metadata": {}, "source": [ "# [Day 6](https://adventofcode.com/2024/day/6): Guard Gallivant\n", "\n", "Today's input is a 2D map of the manufacturing lab, with \"`.`\" indicating an empty space, \"`#`\" indicating an obstruction, and \"`^`\" indicating the position of the security guard, and the fact that the guard is initially facing North." ] }, { "cell_type": "code", "execution_count": 57, "id": "6ec71cf8-c43d-457e-8e14-0e9eb99b956a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 130 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "........#........................................#......#........#.............................. ...\n", "....................................#......#.....#............#.............#..........#........ ...\n", "......................#.......................................................#................. ...\n", ".......#..#..#....#...#...#....#..............#......#.......#...#................#.......#..... ...\n", "......................#....##...#.......#....#.......................................#.......... ...\n", "...#............................#........................................#...................... ...\n", "....................#............#...............#......#.........#...........#................. ...\n", "............................#......#...#................#.............#......................... ...\n", "...\n" ] } ], "source": [ "lab_grid = Grid(parse(6))" ] }, { "cell_type": "markdown", "id": "4ba233f4-90aa-4249-9569-10288c34940d", "metadata": {}, "source": [ "### Part 1: How many distinct positions will the guard visit before leaving the mapped area?\n", "\n", "The guard follows this protocol: \n", "- If there is something directly in front of you, turn right 90 degrees.\n", "- Otherwise, take a step forward.\n", "\n", "I'll define `follow_path` to return a list of all the positions the guard occupies. I realize the puzzle is only asking for a *count* of the positions, but the path might be useful for Part 2, or for debugging, so I'll return it. I worried that it is also possible for a path to become a loop, but the puzzle statement specifically says that can't happen (the guard will always march off the grid), so I won't test for it." ] }, { "cell_type": "code", "execution_count": 59, "id": "95f0b409-a6d6-47bc-8ce5-1c2df80f2b18", "metadata": {}, "outputs": [], "source": [ "def follow_path(grid: Grid, guard='^', facing=North) -> List[Point]:\n", " \"\"\"A list of all points in the path followed by the guard.\n", " The guard turns right when there is an obstacle ahead, otherwise goes forward.\"\"\"\n", " path = grid.findall(guard) # A list of exactly one position, e.g. [(3, 4)]\n", " while (ahead := add(path[-1], facing)) in grid:\n", " if grid[ahead] == '#':\n", " facing = make_turn(facing, 'R')\n", " else:\n", " path.append(ahead)\n", " return path" ] }, { "cell_type": "code", "execution_count": 60, "id": "f4be3d1f-7f24-4d55-8221-df0026178e1e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 6.1: .002 seconds, answer 5329 ok" ] }, "execution_count": 60, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(6.1, 5329, lambda: \n", " len(set(follow_path(lab_grid))))" ] }, { "cell_type": "markdown", "id": "eaf72ac3-ade0-4479-a090-1d0f292ecc27", "metadata": {}, "source": [ "I initially had a **bug**; I took the **length** of the path, not the \"distinct positions\", which I get by taking the length of the **set** of positions. For a path that crosses itself these two numbers are different.\n", " \n", "### Part 2: How many different positions could you choose for an obstruction to put the guard in a loop?\n", "\n", "The historians would like to place a single obstacle so that the guard *will* get stuck in a loop, rather than exiting the grid. They want to know all possible positions for the obstacle. What do we know about such positions?\n", "- An obstacle position must be somewhere on the guard's path, otherwise it would have no effect.\n", "- The instructions say it can't be the guard's initial position.\n", "- A loop is when the guard's path returns to the same position with the same facing. This means my Part 1 solution, which returns the list of visited positions, without the facing directions, is not immediately helpful. \n", "- I can detect a loop by keeping a set of previously visited (position, facing) pairs.\n", "- I can save time and space by only storing the *corners* of the path: the places where the guard turns.\n", " - If the guiard is in a loop, the guard must turn the same way at the same corner.\n", "- The simplest approach for finding obstacle positions is to temporarily place an obstacle on each point on the path, one at a time, and see if it leads to a loop.\n", "- There are 5,329 positions on the path, so the runtime could be about 5,000 times longer than Part 1; on the order of 10 seconds or so.\n", " - I'll try it, and if it seems too slow, I'll think of something else." ] }, { "cell_type": "code", "execution_count": 62, "id": "1718fecb-aa3e-4162-9948-1c06d4ec5e8a", "metadata": {}, "outputs": [], "source": [ "def is_loopy_path(grid: Grid, guard_pos, facing=North) -> bool:\n", " \"\"\"Does the path followed by the guard form a loop?\"\"\"\n", " previous_positions = {(guard_pos, facing)}\n", " while (ahead := add(guard_pos, facing)) in grid:\n", " if grid[ahead] == '#':\n", " facing = make_turn(facing, 'R')\n", " if (guard_pos, facing) in previous_positions:\n", " return True # Found a loop\n", " previous_positions.add((guard_pos, facing))\n", " else:\n", " guard_pos = ahead\n", " return False\n", " \n", "def find_loopy_obstacles(grid: Grid) -> Iterable[Point]:\n", " \"\"\"All positions in which placing an obstacle would result in a loopy path for the guard.\"\"\"\n", " guard_pos = the(grid.findall('^'))\n", " for pos in set(follow_path(grid)) - {guard_pos}:\n", " grid[pos] = '#' # Temporarily place an obstacle \n", " if is_loopy_path(grid, guard_pos):\n", " yield pos\n", " grid[pos] = '.' # Remove the temporarily-placed obstacle" ] }, { "cell_type": "code", "execution_count": 63, "id": "36196264-eb33-4fc0-95d5-06c985105ebf", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 6.2: 1.980 seconds, answer 2162 ok" ] }, "execution_count": 63, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(6.2, 2162, lambda:\n", " quantify(find_loopy_obstacles(lab_grid)))" ] }, { "cell_type": "markdown", "id": "9f3ee6f9-7ec7-4248-ae52-1804fdc81dbd", "metadata": {}, "source": [ "That was my first run time over a second, but still faster than I thought it would be. I guess many of the obstacles force the guard into a small, fast loop, or an early exit from the grid. Note that in `the(grid.findall('^'))`, `findall` is a method from my `Grid` class that finds all locations where a `'^'` character resides, and `the` is my utility function that returns the first element of a one-element list (and raises an error if there is not exactly one element).\n", "\n", "I had a **bug** initially, and never figured out what it was; it went away when I refactored to make the program nicer." ] }, { "cell_type": "markdown", "id": "9eae8cf2-8c97-418e-b00b-3ea0187da526", "metadata": {}, "source": [ "# [Day 7](https://adventofcode.com/2024/day/7): Bridge Repair\n", "\n", "The narrative for today involves fixing a bridge, and each line of our input represents a **calibration equation** for the bridge. Unfortunately, some nearby elephants stole all the operators from the equations, so all that is left are the integers:" ] }, { "cell_type": "code", "execution_count": 66, "id": "c1c6cee8-122c-43c9-8c7d-ed8980ea2b76", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 850 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "202998336: 686 9 7 62 2 673\n", "19275222: 361 3 7 170 65 5 223\n", "23101: 7 694 916 4 6\n", "2042426: 6 34 2 423 3\n", "40369523: 8 880 91 45 23\n", "46629044796: 990 471 4 4 796\n", "1839056: 3 42 2 4 3 258 703 4 8\n", "26205: 2 9 5 9 9 4 3 7 44 5 8 7\n", "...\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Parsed representation ➜ 850 tuples:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "(202998336, 686, 9, 7, 62, 2, 673)\n", "(19275222, 361, 3, 7, 170, 65, 5, 223)\n", "(23101, 7, 694, 916, 4, 6)\n", "(2042426, 6, 34, 2, 423, 3)\n", "(40369523, 8, 880, 91, 45, 23)\n", "(46629044796, 990, 471, 4, 4, 796)\n", "(1839056, 3, 42, 2, 4, 3, 258, 703, 4, 8)\n", "(26205, 2, 9, 5, 9, 9, 4, 3, 7, 44, 5, 8, 7)\n", "...\n" ] } ], "source": [ "equations = parse(7, ints)" ] }, { "cell_type": "markdown", "id": "be207b67-a970-4f79-85be-5d62b7cedd9f", "metadata": {}, "source": [ " " ] }, { "cell_type": "markdown", "id": "2e31d28f-97b1-4a3d-a298-18fcad297150", "metadata": {}, "source": [ "### Part 1: What is the total calibration result of possibly true equations?\n", "\n", "Our task is to find operators to balance each equation. The input \"`3267: 81 40 27`\" can be made into the equation \"`3267 = 81 + 40 * 27`\", with the understanding that all evaluations are done left-to-right, so this is \"`3267 = ((81 + 40) * 27)`\". The two allowable operators are addition and multiplication. Our task is to compute the sum of all the equations that can be balanced.\n", "\n", "The straightforward approach is to try both operators on every number. If there are *n* numbers in an equation, then there are *n* - 1 numbers on the right-hand side, and *n* - 2 missing operators, so there will be 2*n*-2 possible equations. Is that going to be a problem?" ] }, { "cell_type": "code", "execution_count": 69, "id": "6fa3907c-0e1a-4d4a-9fc3-f809b9325674", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "13" ] }, "execution_count": 69, "metadata": {}, "output_type": "execute_result" } ], "source": [ "max(map(len, equations))" ] }, { "cell_type": "markdown", "id": "e0d9b0b2-fe1e-434e-b84e-c044da3d3673", "metadata": {}, "source": [ "No problem! With 13 numbers on a line there are just 211 = 2048 equations; a small number. I'll define `can_be_calibrated` to try all possible operator combinations. It goes left-to-right, one number at a time, keeping a list of partial `results` which is updated for each new number in the equation. \n", "\n", "Although the puzzle instructions are a bit vague, it appears that when they say \"numbers\" they mean \"positive integers\". Therefore, neither addition nor multiplication can cause a partal result to decrease, so once a partial result exceeds the target, we can drop it." ] }, { "cell_type": "code", "execution_count": 71, "id": "5dfe0edf-cf29-4623-bb2c-6180f832f4d7", "metadata": {}, "outputs": [], "source": [ "def can_be_calibrated(equation: ints, operators=(operator.add, operator.mul)) -> bool:\n", " \"\"\"Can the equation be balanced using '+' and '*' operators?\"\"\"\n", " target, first, *rest = equation\n", " results = [first] # A list of all possible results of the partial computation\n", " for y in rest:\n", " results = [op(x, y) for x in results if x <= target for op in operators]\n", " return target in results\n", "\n", "def lhs(equation) -> int: \"Left-hand side\"; return equation[0]" ] }, { "cell_type": "code", "execution_count": 72, "id": "3085596d-f5ec-4ba8-b05a-cf70cf276a0c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 7.1: .014 seconds, answer 1985268524462 ok" ] }, "execution_count": 72, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(7.1, 1985268524462, lambda:\n", " sum(lhs(equation) for equation in equations if can_be_calibrated(equation)))" ] }, { "cell_type": "markdown", "id": "62a5fe5f-e23f-4420-87a8-47d8be02fbc0", "metadata": {}, "source": [ "### Part 2: What is the total calibration result of possibly true equations, allowing concatenation?\n", "\n", "In Part 2, a third operator is allowed: **concatentation**. The equation \"`192: 17 8 14`\" can be balanced by concatenated 17 and 8 to get 178, and then adding 14 to get 192: \"`192 = ((17 || 8) + 14)`\". With three possible operators, the equation with 11 missing operator slots now has 311 = 177,147 possibilities, almost 100 times more than Part 1, so this will take longer:" ] }, { "cell_type": "code", "execution_count": 74, "id": "393a50cf-f136-446a-a97e-c501669ce89f", "metadata": {}, "outputs": [], "source": [ "operators3 = (operator.add, operator.mul, lambda x, y: int(str(x) + str(y))) " ] }, { "cell_type": "code", "execution_count": 75, "id": "f8e75ea3-e8ba-4b33-8efe-8bf74357e35d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 7.2: .810 seconds, answer 150077710195188 ok" ] }, "execution_count": 75, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(7.2, 150077710195188, lambda:\n", " sum(lhs(equation) for equation in equations if can_be_calibrated(equation, operators3)))" ] }, { "cell_type": "markdown", "id": "128b4857-ed3e-49f5-97f5-9d9afd46408d", "metadata": {}, "source": [ "That was easy, but it is the second-slowest runtime so far. I can make it faster by implementing concatenation by multiplying and adding rather than by string operations." ] }, { "cell_type": "code", "execution_count": 77, "id": "6fe6adad-a3a6-49b8-b49e-6098b27e3a44", "metadata": {}, "outputs": [], "source": [ "operators3 = (operator.add, operator.mul, lambda x, y: (x * 10 ** num_digits(y)) + y)\n", "\n", "def num_digits(n: int) -> int:\n", " \"\"\"The number of digits in a positive integer.\"\"\"\n", " if n < 10: return 1 ## Three special cases cover most calls\n", " elif n < 100: return 2\n", " elif n < 1000: return 3\n", " result = 1\n", " while n >= 10:\n", " result += 1\n", " n /= 10\n", " return result" ] }, { "cell_type": "code", "execution_count": 78, "id": "ffb673f1-af9d-4d15-8f8d-92e29489dd78", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 7.2: .611 seconds, answer 150077710195188 ok" ] }, "execution_count": 78, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(7.2, 150077710195188, lambda:\n", " sum(numbers[0] for numbers in equations if can_be_calibrated(numbers, operators3)))" ] }, { "cell_type": "markdown", "id": "2e5693b7-dab8-4f89-a000-c69ee75a11c9", "metadata": {}, "source": [ "# [Day 8](https://adventofcode.com/2024/day/8): Resonant Collinearity\n", "\n", "Another grid input, this one a map of antenna locations. Each different non-\"`.`\" character denotes an antenna of a given frequency." ] }, { "cell_type": "code", "execution_count": 80, "id": "cf6361a7-e3bc-42ec-ae16-f9eec166055e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 50 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "..................................................\n", ".................................C................\n", ".e..........7O....................................\n", ".....................................z............\n", "......................t.........C.......k.........\n", "............h................................9....\n", ".............5.7....O.............9C..............\n", ".......5.O................T.......................\n", "...\n" ] } ], "source": [ "antennas = Grid(parse(8))" ] }, { "cell_type": "markdown", "id": "c8e1006d-37bc-432e-bf1f-7a639287382a", "metadata": {}, "source": [ "### Part 1: How many unique locations within the bounds of the map contain an antinode?\n", "\n", "An **antinode** is defined as a point that is perfectly in line with two antennas of the same frequency, but only when one of the antennas is twice as far away as the other.\n", "\n", "That means that if two antennas are at points *A* and *B*, then the two antinodal points are at 2*A* - *B* and 2*B* - A. If there are three or more antennas with the same frequency then we consider each pair of them in turn. So all we have to do is group the antennas by frequency, compute the antinodes for each pair with the same frequency, and determine which of those antinodal points are on the grid." ] }, { "cell_type": "code", "execution_count": 82, "id": "22180ce8-5d03-4aee-8c73-62f2afbddf71", "metadata": {}, "outputs": [], "source": [ "def antinodes(antennas: Grid) -> Set[Point]:\n", " \"\"\"The set of all antinodal points for all antennas in the grid.\n", " (That is, points that are of distance d and 2d from same frequency antennas.)\"\"\"\n", " groups = [antennas.findall(f) for f in set(antennas.values()) if f != '.']\n", " return union(antinodes2(A, B, antennas)\n", " for points in groups\n", " for A, B in combinations(points, 2))\n", "\n", "def antinodes2(A: Point, B: Point, antennas: Grid) -> Set[Point]:\n", " \"\"\"The set of antinodal points for two antenna points, A and B.\"\"\"\n", " candidates = [sub(mul(A, 2), B), sub(mul(B, 2), A)]\n", " return {P for P in candidates if P in antennas}" ] }, { "cell_type": "code", "execution_count": 83, "id": "dd173ce9-cbbb-4282-b43f-c7cff662bd90", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 8.1: .002 seconds, answer 220 ok" ] }, "execution_count": 83, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(8.1, 220, lambda:\n", " len(antinodes(antennas)))" ] }, { "cell_type": "markdown", "id": "ff79d605-813a-46ac-8473-a1198be0e99f", "metadata": {}, "source": [ "### Part 2: How many unique locations within the bounds of the map contain an resonant antinode?\n", "\n", "For Part 2, a Historian tells us to consider **resonant antinodes**, which can occur at *any* point that is exactly on line with two antennas of the same frequency, regardless of distance. So if the two antennas are *A* and *B* then the antinodal points can be found by starting at *A* and going step by step in the direction of the vector *A* - *B* and also in the direction *B* - *A*, going as far as you can while staying on the grid. The `Grid.follow_line` method facilitates that.\n", "\n", "I'll refactor `antinodes` to take an `antinodes2` parameter so it can handle both parts:" ] }, { "cell_type": "code", "execution_count": 85, "id": "d30f8ce9-f186-46a0-a2e7-f74eceae6905", "metadata": {}, "outputs": [], "source": [ "def antinodes(antennas: Grid, antinodes2=antinodes2) -> Set[Point]:\n", " \"\"\"The set of all antinodal points in the grid, according to the `antinode2` function.\"\"\"\n", " groups = [antennas.findall(f) for f in set(antennas.values()) if f != '.']\n", " return union(antinodes2(A, B, antennas)\n", " for points in groups\n", " for A, B in combinations(points, 2))\n", "\n", "def resonant_antinodes2(A: Point, B: Point, antennas: Grid) -> Set[Point]:\n", " \"\"\"The set of resonant antinodal points for two antenna points, A and B.\"\"\"\n", " return (set(antennas.follow_line(A, sub(A, B))) | \n", " set(antennas.follow_line(A, sub(B, A))))" ] }, { "cell_type": "code", "execution_count": 86, "id": "6bf85b57-8b8f-4196-9903-6d5fe082f404", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 8.1: .003 seconds, answer 220 ok" ] }, "execution_count": 86, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(8.1, 220, lambda:\n", " len(antinodes(antennas)))" ] }, { "cell_type": "code", "execution_count": 87, "id": "f232952c-5fc6-4696-a8b1-d0b54137ac02", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 8.2: .003 seconds, answer 813 ok" ] }, "execution_count": 87, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(8.2, 813, lambda:\n", " len(antinodes(antennas, resonant_antinodes2)))" ] }, { "cell_type": "markdown", "id": "4ff92b7f-f9e9-4664-9fc5-0e9998aca47e", "metadata": {}, "source": [ "### Part 3: Visualization\n", "\n", "Here I show what the grid look like with all the resonant antinodes depicted with the same letter as their antenna." ] }, { "cell_type": "code", "execution_count": 89, "id": "4642cbba-16c1-4aa8-b39d-a104a475cbe6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "..........E7...xH..s....B.C........4..W..........5\n", ".........4O.T..H3...t..h....3.s..C.3..zo..35b.....\n", ".e.....x..x.7OH.x....t..8....CT...z.o5............\n", "5...........X7...s...t.....s...5j...8z.T.3........\n", "...........EH...ex.Tj3t.35....3.C....E..k.K....c.w\n", ".30........Hh...Kb.5.t.cs......O.S..z..k3....9..Eo\n", ".......3..H..5.7..x.O..B..........9C3..zcb....o.wX\n", ".......5.H.x.3.......st9..3...4C3j..W..3...o.G....\n", ".5.0....H...9......3.........o...c....z.o......w..\n", ".9H....H.c...sex.7s...tj.3.....b...E.o3..K.....w..\n", "......H..........67.x.....cO..C3.T3.5..8.C..E.w..S\n", "sW..0H....H...5s.........B6....o..S..3b.z..c......\n", ".s..HO.....s.HHx...7.xBt....o.......8.....e3Cw..S.\n", "..sH.k..H...s.....H..H.t.o.e.C......3..zT.......X3\n", "T.Hs.0.....ke.......H7x..4j..H...EO..9..K.z.w..C..\n", ".H..s....T.H.....k.o.7..H.H........3.H..E.G..0....\n", "H....s.......1E5o.T.x.7x...eC.j.4..b..3C.z.w.HST..\n", ".O....4......oH....x....t..T.k....3S....e08.z.....\n", ".......s..o..........B.77.........HHT.H0zOw..S....\n", "...s...os.e......H.......b.C5j.E.3C.70.K3kHz.T31.J\n", "..g.o..0.s.....o........tx.........0E....w..S.zX..\n", "so...s....s.....5...4....7....K.30w....3.Cz...H.J.\n", "....KS...o.s..........Ex.tC7X..0........9K3S.3..8.\n", "........0...s6.........Hkx.7.9.3...5Sj.Gez.....Jz.\n", ".4.s....e....s..E...BT....w71E..j.....Kw..S.z8....\n", ".E....O.....K.s..........Ct...38E.j......W..3.J...\n", "....h...o0.g...s.8.....e.w..xb7.......wT3S8z.....j\n", "02.8........S...s.wW.0....txT3.......wj...5.cJX..Z\n", "..J...k.......84.s.0K...Ct...xW......w.8S.z...3..G\n", "...0E.e...0......0sk.......t3...H..j.S......JzT...\n", "..........w....0.gks.....kttE.x777.ww..S...9..GG..\n", ".....O0......0.Tw.5.sE.C..b3K......HG..j.3.JzC..35\n", "S2..2......0......ESg9.....t...x.C.w..S....GG..z..\n", "B.w4...E.0..........8ws...3.t...17....H...Jz...X..\n", "....e.B0.....h.......1Cs.E....8.x.w.7SjWG.T..XZ...\n", "6....0..S.4.B.k.........s3..W.........S.jJ.......z\n", "...0...w.6.......WB5...b.st8....ww.7SG....3..z.C..\n", ".0..O.W2..E....0..6..C..3.s.tT.w...C.7..J...K.....\n", ".........T...0..S.......8..stgB.w.GS...7....z.9...\n", "..e...............0....3....st...G.KB7.J.j....EH..\n", "...2W...............C8.......s.Gg.Sx.b...EB..S....\n", "........28..j90W....b03.S.....s.....E.JS...3X.z.BC\n", ".....4..k.2..2...B8...h...WjGtws.S.gx..7..7..T...z\n", "..oO...h..........2C.3..0.ESt...s....J....j..zg...\n", "e.....G........8.....S.2.G.w.w..SsK..xg.x.7Jj...W.\n", "...T....w....jGSE...3......w2..tC.s.J..1.7.......X\n", ".........S.E8....bC..5G.....w..S.2.s..x..G..37.X.9\n", "...Sk.E...B..2..0..2.....S....G....Js.2.Sb.x.X....\n", ".E.......8......B..G..E....w..St.....sGxZ..Xg.z...\n", "4.O..6..G........C3E....W....2..tKJ.g.C..X....Gj2.\n" ] } ], "source": [ "def show_antinodes(antennas: Grid, antinodes2=resonant_antinodes2):\n", " \"\"\"Put antinodes on the grid and print.\"\"\"\n", " antennas = antennas.copy() # Don't alter the original\n", " groups = {f: antennas.findall(f) for f in set(antennas.values()) if f != '.'}\n", " for f, points in groups.items():\n", " for A, B in combinations(points, 2):\n", " for p in antinodes2(A, B, antennas):\n", " antennas[p] = f\n", " antennas.print()\n", " \n", "show_antinodes(antennas.copy())" ] }, { "cell_type": "markdown", "id": "d4835cad-7777-4636-b9af-52cc9782b2b8", "metadata": {}, "source": [ "# [Day 9](https://adventofcode.com/2024/day/9): Disk Fragmenter\n", "\n", "Today we're confronted with a computer disk that needs to be compressed to gain some contiguous free space. The contents of the disk is represented in the **disk map** format: a string of digits, where the digits alternate between the number of blocks of a file, followed by the number of blocks of free space. We'll parse that as a tuple of digits:" ] }, { "cell_type": "code", "execution_count": 91, "id": "0e944f9e-5c16-440c-b12e-178058a87048", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 1 str:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "692094513253604282899448234539616972499153261626907217394161512944107098953354935354419233821564 ...\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Parsed representation ➜ 1 tuple:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "(6, 9, 2, 0, 9, 4, 5, 1, 3, 2, 5, 3, 6, 0, 4, 2, 8, 2, 8, 9, 9, 4, 4, 8, 2, 3, 4, 5, 3, 9, 6, 1, ...\n" ] } ], "source": [ "disk_map = the(parse(9, digits))" ] }, { "cell_type": "markdown", "id": "99d40379-65e1-4872-8c68-17ba4925c24e", "metadata": {}, "source": [ "\n", "\n", "### Part 1: Compress the hard drive. What is the resulting filesystem checksum? \n", "\n", "We will deal with two formats to represent disks. Consider this **disk map** format:\n", "\n", " 1, 2, 3, 4, 5 ## Disk map format\n", "\n", "This means that there is 1 block for the first file (which has ID number 0), followed by 2 empty blocks, then 3 blocks for the second file (with ID number 1), followed by 4 empty blocks, and finally 5 blocks for the third file (with ID number 2). \n", "\n", "It makes sense to convert this into a **disk layout** format: which would be \"`\", where \"`.`\" represents an empty block.\n", "\n", " 0..111....22222 ## Disk layout format\n", "\n", "Here the integers represent file ID numbers, and the `.` indicates an empty block.\n", "\n", "To **compress** a disk layout, move file blocks one at a time starting by taking the rightmost non-empty block and moving it to the leftmost empty position; repeat until no more moves are possible. For the example above, that would give us:\n", "\n", " 022111222...... ## Disk layout format (compressed)\n", "\n", "The final answer to the puzzle is a **checksum** of the compressed disk: the sum of the product of the block position times the file ID number for all non-empty blocks." ] }, { "cell_type": "code", "execution_count": 93, "id": "76e8454d-a2f3-4b6b-92df-182116cf46e0", "metadata": {}, "outputs": [], "source": [ "empty = -1 # An empty block\n", "\n", "def disk_layout(disk_map: Ints) -> list:\n", " \"\"\"Convert a disk map into a disk layout.\"\"\"\n", " def empties(j) -> int: return (disk_map[j] if j < len(disk_map) else 0)\n", " return append(disk_map[i] * [id] + empties(i + 1) * [empty]\n", " for id, i in enumerate(range(0, len(disk_map), 2)))\n", "\n", "def compress_layout(layout: list) -> list:\n", " \"\"\"Mutate layout by moving blocks one at a time from the end to the leftmost free space.\"\"\"\n", " N = len(layout)\n", " free = -1 # Start looking for free space from the left\n", " end = N # Start looking for non-empty blocks from the right\n", " while True:\n", " free = first(i for i in range(free + 1, N) if layout[i] is empty)\n", " end = first(i for i in range(end - 1, 0, -1) if layout[i] is not empty)\n", " if free is None or free >= end:\n", " return layout\n", " layout[free], layout[end] = layout[end], empty\n", "\n", "def checksum(layout: list) -> list:\n", " \"\"\"The sum of the product of the block position times the file ID number for all non-empty blocks.\"\"\"\n", " return sum(i * id for i, id in enumerate(layout) if id is not empty)" ] }, { "cell_type": "code", "execution_count": 94, "id": "2aa7e2b9-844e-49ed-b41b-4a4cecff86b7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 9.1: .019 seconds, answer 6332189866718 ok" ] }, "execution_count": 94, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(9.1, 6332189866718, lambda:\n", " checksum(compress_layout(disk_layout(disk_map))))" ] }, { "cell_type": "markdown", "id": "2c05a497-cc66-4698-b88b-25c33eea224a", "metadata": {}, "source": [ "### Part 2: Compress the hard drive with the new method. What is the resulting filesystem checksum? \n", "\n", "In Part 2, there is a new method of compressing the disk, where we move full files rather than a block at a time. Again we start on the right, and try to move a file to the leftmost position where it will fit. If there is no such position, the file doesn't move. `compress_layout2` implements this new method, performing a move by swapping two [**slices**](https://docs.python.org/3/library/functions.html#slice) of the disk layout: \n", "\n", " layout[file], layout[free] = layout[free], layout[file]`\n", "\n", "To find all the slices that indicate files, it is easier to run through the disk map than the disk layout. The function `file_slices` quickly finds all such slices.\n", "\n", "Finding a free space for a file is more difficult than finding a single free block, because we need to find free space that is big enough. At first I coded a solution that ran through the whole layout from left-to-right each time, looking for the first sufficiently-large free space. That made it *O*(*n*2), but it should be *O*(*n*) So I added a table: `starts[length]` that tells me where to start looking for an empty space of size `length`, and updated the table every time I move a file. That speeds things up by a factor of 100." ] }, { "cell_type": "code", "execution_count": 96, "id": "8d34e96a-8ea9-4f92-b0aa-839b216ea14b", "metadata": {}, "outputs": [], "source": [ "def compress_layout2(disk_map: Ints) -> list:\n", " \"\"\"Mutate layout by moving files one at a time from the end to the leftmost free space.\"\"\"\n", " layout = disk_layout(disk_map)\n", " starts = defaultdict(int)\n", " for file in file_slices(disk_map):\n", " if free := find_freespace(layout, file, starts):\n", " layout[file], layout[free] = layout[free], layout[file]\n", " return layout\n", "\n", "def file_slices(disk_map: Ints) -> List[slice]:\n", " \"\"\"Given a disk map, find all the slice positions of files in the disk layout (last one first).\"\"\"\n", " slices = []\n", " block = 0\n", " for i, length in enumerate(disk_map):\n", " if i % 2 == 0:\n", " slices.append(slice(block, block + length))\n", " block += length\n", " slices.reverse()\n", " return slices\n", "\n", "def find_freespace(layout, file_slice, starts) -> Optional[slice]:\n", " \"\"\"Find a slice position big enough to fit the given file slice, or return None if there is no position.\"\"\"\n", " length = file_slice.stop - file_slice.start\n", " run = 0 # The number of consecutive empty spaces we have found so far\n", " for i in range(layout.index(empty, starts[length]), len(layout)):\n", " starts[length] = i\n", " if i >= file_slice.start:\n", " return None # We only want to move a file left, not right\n", " elif layout[i] is empty: # Look for empty spaces one by one\n", " run += 1\n", " if run == length:\n", " return slice(i + 1 - length, i + 1)\n", " else:\n", " run = 0\n", " return None" ] }, { "cell_type": "code", "execution_count": 97, "id": "e3036875-88d0-496e-9d2f-facd0e80a5b2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 9.2: .021 seconds, answer 6353648390778 ok" ] }, "execution_count": 97, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(9.2, 6353648390778, lambda:\n", " checksum(compress_layout2(disk_map)))" ] }, { "cell_type": "markdown", "id": "24c0e7d7-6ac7-4e4b-9557-bd4e215ad0a9", "metadata": {}, "source": [ "I got the right answer, but I confess I had an off-by-one **bug** in `find_freespace` on the first try, and another bug where I didn't check if `if i >= file_slice.start`, and was sometimes moving a large file to the right (thereby *uncompressing* the disk) rather than leaving it in place." ] }, { "cell_type": "markdown", "id": "7a900425-fe22-4d2f-8d1d-46c319c109e9", "metadata": {}, "source": [ "# [Day 10](https://adventofcode.com/2024/day/10): Hoof It\n", "\n", "Today's input is a topological map of hiking paths on Lava Island, with digits indicating the elevation of each terrain position." ] }, { "cell_type": "code", "execution_count": 100, "id": "5804fb03-05f3-402f-b6cc-6804c5d22512", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 60 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "432109865210212123765432101234321098543289654320132112121058\n", "045678774324301012892343023445456787650198763013241001034569\n", "187678789465692321001056014896234986456787012894653212123678\n", "296589921056789433217837895687145675323891233765784589238987\n", "345437835434576544786921278761010014210710321212098676521067\n", "032126546323465435695430789760121223121653450303145125430678\n", "123010567810156543212345699859834321056544067654236012321589\n", "543213498987657665401030787348765430187432198765987622345432\n", "...\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Parsed representation ➜ 60 tuples:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "(4, 3, 2, 1, 0, 9, 8, 6, 5, 2, 1, 0, 2, 1, 2, 1, 2, 3, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 3, 2, ...\n", "(0, 4, 5, 6, 7, 8, 7, 7, 4, 3, 2, 4, 3, 0, 1, 0, 1, 2, 8, 9, 2, 3, 4, 3, 0, 2, 3, 4, 4, 5, 4, 5, ...\n", "(1, 8, 7, 6, 7, 8, 7, 8, 9, 4, 6, 5, 6, 9, 2, 3, 2, 1, 0, 0, 1, 0, 5, 6, 0, 1, 4, 8, 9, 6, 2, 3, ...\n", "(2, 9, 6, 5, 8, 9, 9, 2, 1, 0, 5, 6, 7, 8, 9, 4, 3, 3, 2, 1, 7, 8, 3, 7, 8, 9, 5, 6, 8, 7, 1, 4, ...\n", "(3, 4, 5, 4, 3, 7, 8, 3, 5, 4, 3, 4, 5, 7, 6, 5, 4, 4, 7, 8, 6, 9, 2, 1, 2, 7, 8, 7, 6, 1, 0, 1, ...\n", "(0, 3, 2, 1, 2, 6, 5, 4, 6, 3, 2, 3, 4, 6, 5, 4, 3, 5, 6, 9, 5, 4, 3, 0, 7, 8, 9, 7, 6, 0, 1, 2, ...\n", "(1, 2, 3, 0, 1, 0, 5, 6, 7, 8, 1, 0, 1, 5, 6, 5, 4, 3, 2, 1, 2, 3, 4, 5, 6, 9, 9, 8, 5, 9, 8, 3, ...\n", "(5, 4, 3, 2, 1, 3, 4, 9, 8, 9, 8, 7, 6, 5, 7, 6, 6, 5, 4, 0, 1, 0, 3, 0, 7, 8, 7, 3, 4, 8, 7, 6, ...\n", "...\n" ] } ], "source": [ "topo = Grid(parse(10, digits))" ] }, { "cell_type": "markdown", "id": "d951807a-3611-445f-84ee-352221a25968", "metadata": {}, "source": [ "### Part 1: What is the sum of the scores of all trailheads on your topographic map?\n", "\n", "A **trailhead** is any position with elevation 0, and a **peak** is any position with elevation 9. The **score** of a trailhead is the number of peaks that can be reached by following a path where each step increases the elevation by exactly 1. All steps are in one of the four cardinal directions (north/south/east/west).\n", "\n", "I'll keep a set of points on the frontier of possible paths, updating this set on each iteratation from 1 to 9, by looking at each point on the frontier and seeing which of the neighboring points `p` have the right elevation:" ] }, { "cell_type": "code", "execution_count": 102, "id": "76b5379e-ee19-4607-91b8-88ec7b38023f", "metadata": {}, "outputs": [], "source": [ "def score(topo: Grid, trailhead: Point) -> int:\n", " \"\"\"How many peaks can be reached from this trailhead?\"\"\"\n", " frontier = {trailhead}\n", " for elevation in range(1, 10):\n", " frontier = {p for p in union(map(topo.neighbors, frontier))\n", " if topo[p] == elevation}\n", " return len(frontier)" ] }, { "cell_type": "code", "execution_count": 103, "id": "97cf05f7-fa56-4a90-b2d8-2cd4d9b81f95", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 10.1: .005 seconds, answer 744 ok" ] }, "execution_count": 103, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(10.1, 744, lambda:\n", " sum(score(topo, trailhead) for trailhead in topo.findall([0])))" ] }, { "cell_type": "markdown", "id": "4656eb08-b12a-4a02-92b8-ac23f2361387", "metadata": {}, "source": [ "### Part 2: What is the sum of the ratings of all trailheads?\n", "\n", "The **rating** of a trailhead is the number of distinct paths from the trailhead to a peak.\n", "\n", "As in Part 1, I'll keep a frontier and update it on each iteration from 1 to 9, but this time the frontier will be a counter of `{position: count}` where the count indicates the number of paths to that position. On each iteration I'll look at each point `f` on the frontier and see which of the neighboring points `p` have the right elevation, and increment the counts for those points by the count for `f`. This approach is linear in the number of positions, whereas if I followed all possible paths depth-first there could be an exponential number of paths." ] }, { "cell_type": "code", "execution_count": 105, "id": "b763450f-a565-4936-bee4-e531c2eeebdb", "metadata": {}, "outputs": [], "source": [ "def rating(topo: Grid, trailhead: Point) -> int:\n", " \"\"\"How many distinct paths are there from this trailhead to any peak?\"\"\"\n", " frontier = Counter({trailhead: 1})\n", " for elevation in range(1, 10):\n", " frontier = accumulate((p, frontier[f]) \n", " for f in frontier\n", " for p in topo.neighbors(f) \n", " if topo[p] == elevation)\n", " return sum(frontier.values())" ] }, { "cell_type": "markdown", "id": "bfb4ae54-db59-44df-a76d-12e155fd1e5e", "metadata": {}, "source": [ "(Note my [utility function](AdventUtils.ipynb) `accumulate` takes as input an iterable of (key, count) pairs, and returns a Counter of the total count for each key.)\n" ] }, { "cell_type": "code", "execution_count": 107, "id": "f8a87032-6556-4fc9-9bb8-573611aee8dc", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 10.2: .006 seconds, answer 1651 ok" ] }, "execution_count": 107, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(10.2, 1651, lambda:\n", " sum(rating(topo, trailhead) for trailhead in topo.findall([0])))" ] }, { "cell_type": "markdown", "id": "af410d30-7096-4be6-bb20-904b3c8e2f59", "metadata": {}, "source": [ "### Part 3: Visualization\n", "\n", "Here's a visualization of the map:" ] }, { "cell_type": "code", "execution_count": 109, "id": "eea7e277-4687-48a9-85b5-a031a9d4b6e1", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def plot_topo(topo: Grid):\n", " \"\"\"Show the map with a colormap from blue to red.\"\"\"\n", " plt.figure()\n", " scatter = plt.scatter(Xs(topo), Ys(topo), c=list(topo.values()), \n", " cmap='coolwarm', marker='s', s=12)\n", " plt.colorbar(scatter, label='Elevation')\n", " plt.axis('square')\n", " plt.axis('off')\n", "\n", "plot_topo(topo)" ] }, { "cell_type": "markdown", "id": "3e01d7f5-d0f0-4e7b-8cab-eef2afc02f6b", "metadata": {}, "source": [ "# [Day 11](https://adventofcode.com/2024/day/11): Plutonian Pebbles\n", "\n", "Today's narrative involves a straight line of stones, each of which has a number enscribed on it. The input is a single line of these numbers:" ] }, { "cell_type": "code", "execution_count": 111, "id": "76b68cef-d8de-4145-b65c-b254fedf1671", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 1 str:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "0 27 5409930 828979 4471 3 68524 170\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Parsed representation ➜ 1 tuple:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "(0, 27, 5409930, 828979, 4471, 3, 68524, 170)\n" ] } ], "source": [ "stones = the(parse(11, ints))" ] }, { "attachments": {}, "cell_type": "markdown", "id": "a7302dc5-5163-4f0b-bdcc-8c00e367391c", "metadata": {}, "source": [ "### Part 1: How many stones will you have after blinking 25 times?\n", "\n", "Every time you **blink**, the stones appear to change, according to these rules:\n", "- A stone marked 0 changes to 1.\n", "- Otherwise, a stone with an even number of digits splits into two stones, with the first and second halves of those digits.\n", "- Otherwise, the stone's number is multiplied by 2024.\n", "\n", "\n", "\n", "\n", "I'll define `blink` to simulate the effect of a given number of blinks, and `change_stone` to change a single stone, returning a list of either one or two stones (the two stones computed by `split_stone`):" ] }, { "cell_type": "code", "execution_count": 113, "id": "1513df56-3d6f-42cf-8aec-1bdbeb991d90", "metadata": {}, "outputs": [], "source": [ "def blink(stones: Ints, blinks=25) -> List[int]:\n", " \"\"\"Simulate the changes in the list of stones after blinking `blinks` times.\"\"\"\n", " for _ in range(blinks):\n", " stones = append(map(change_stone, stones))\n", " return stones\n", " \n", "def change_stone(stone: int) -> List[int]:\n", " \"\"\"Change a single stone into one or two, according to the rules.\"\"\"\n", " digits = str(stone)\n", " return ([1] if stone == 0 else\n", " split_stone(digits) if len(digits) % 2 == 0 else\n", " [stone * 2024])\n", "\n", "def split_stone(digits: str) -> List[int]:\n", " \"\"\"Split a stone into two halves.\"\"\"\n", " half = len(digits) // 2\n", " return [int(digits[:half]), int(digits[half:])]" ] }, { "cell_type": "code", "execution_count": 114, "id": "eff17cd0-a2c7-4d69-bc55-c0ef97917915", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 11.1: .067 seconds, answer 194482 ok" ] }, "execution_count": 114, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(11.1, 194482, lambda:\n", " len(blink(stones, 25)))" ] }, { "cell_type": "markdown", "id": "2f65e94f-43e8-4f08-85df-827928c57e0b", "metadata": {}, "source": [ "### Part 2: How many stones would you have after blinking a total of 75 times?\n", "\n", "It looks like the number of stones is roughly doubling every 1 or 2 blinks, so for 75 blinks we could have trillions of stones. I'd like something more efficient. I note that:\n", "- Although the puzzle makes it clear that the stones are in a line, it turns out their position in the line is irrelevant.\n", "- Because all the even-digit numbers get split in half, it seems like many small numbers will appear multiple times.\n", " - (In the given example, after 6 blinks the number 2 appears 4 times.)\n", "- Therefore, I'll keep a `Counter` of stones rather than a `list` of stones." ] }, { "cell_type": "code", "execution_count": 116, "id": "707b5a97-0296-48df-bdab-e34064cc67c2", "metadata": {}, "outputs": [], "source": [ "def blink2(stones: Ints, blinks=25) -> Counter:\n", " \"\"\"Simulate the changes after blinking `blinks` times and return a Counter of stones.\"\"\"\n", " counts = Counter(stones)\n", " for _ in range(blinks):\n", " counts = accumulate((s, counts[stone]) \n", " for stone in counts \n", " for s in change_stone(stone))\n", " return counts" ] }, { "cell_type": "markdown", "id": "f5bf07ce-b48e-40db-8992-b9b571e66554", "metadata": {}, "source": [ "Now we can re-run Part 1 (it should be slightly faster), and run Part 2 without fear of having trillion-element lists:" ] }, { "cell_type": "code", "execution_count": 118, "id": "efdcdbf8-e8ec-4a85-9d09-90a20e08c66a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 11.1: .002 seconds, answer 194482 ok" ] }, "execution_count": 118, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(11.1, 194482, lambda:\n", " total(blink2(stones, 25)))" ] }, { "cell_type": "code", "execution_count": 119, "id": "657b1f13-ffcc-44c6-84f1-398fa2fcdac7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 11.2: .059 seconds, answer 232454623677743 ok" ] }, "execution_count": 119, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(11.2, 232454623677743, lambda:\n", " total(blink2(stones, 75)))" ] }, { "cell_type": "markdown", "id": "ce377749-b3e2-4ca4-b50d-e7c3d2e7201a", "metadata": {}, "source": [ "I'm glad I used the `Counter`; it would have taken a petabyte of storage (and a long, long time) to represent that many stones as a list.\n", "\n", "Again, I did pretty well, with no errors, and moving at what I thought was a good pace, but I didn't even crack the top 2000 on the leaderboard. \n", "\n", "### Part 3: Exploration\n", "\n", "Here I show how the stones grow, starting from a single stone marked \"0\" for 10 blinks, and how the total number of stones grows over 30 blinks." ] }, { "cell_type": "code", "execution_count": 121, "id": "8609fda3-c158-4fbb-bec5-4270c3a2dbe7", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1]\n", "[2024]\n", "[20, 24]\n", "[2, 0, 2, 4]\n", "[4048, 1, 4048, 8096]\n", "[40, 48, 2024, 40, 48, 80, 96]\n", "[4, 0, 4, 8, 20, 24, 4, 0, 4, 8, 8, 0, 9, 6]\n", "[8096, 1, 8096, 16192, 2, 0, 2, 4, 8096, 1, 8096, 16192, 16192, 1, 18216, 12144]\n", "[80, 96, 2024, 80, 96, 32772608, 4048, 1, 4048, 8096, 80, 96, 2024, 80, 96, 32772608, 32772608, 2024, 36869184, 24579456]\n", "[8, 0, 9, 6, 20, 24, 8, 0, 9, 6, 3277, 2608, 40, 48, 2024, 40, 48, 80, 96, 8, 0, 9, 6, 20, 24, 8, 0, 9, 6, 3277, 2608, 3277, 2608, 20, 24, 3686, 9184, 2457, 9456]\n" ] } ], "source": [ "S = [0]\n", "for _ in range(10):\n", " S = blink(S, 1)\n", " print(S)" ] }, { "cell_type": "code", "execution_count": 122, "id": "100febf3-8397-4bce-a290-12de1f281f82", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1, 1, 2, 4, 4, 7, 14, 16, 20, 39, 62, 81, 110, 200, 328, 418, 667, 1059, 1546, 2377, 3572, 5602, 8268, 12343, 19778, 29165, 43726, 67724, 102131, 156451, " ] } ], "source": [ "S = [0]\n", "for _ in range(30):\n", " S = blink(S, 1)\n", " print(len(S), end=', ')" ] }, { "cell_type": "markdown", "id": "391cec1e-32fe-4e6e-81c2-4e38469b15e3", "metadata": {}, "source": [ "# [Day 12](https://adventofcode.com/2024/day/12): Garden Groups\n", "\n", "Today's input is yet another 2D map. This one depicts different garden **plots** on a farm, each plot planted with a **crop**, indicated by a letter. Perhaps \"I\" is iceberg lettuce, \"O\" is okra, \"A\" is avocado, and so on." ] }, { "cell_type": "code", "execution_count": 124, "id": "8161ee7e-76e3-499a-abf8-a607991c9602", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 140 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "IIIIIIIIIIIIIIIIIIIIIUUUUUUUUJLLLLAAAAAAMMMAUUUUPPXPZZZZZZZZZZZXXXXXXXXXXXXXXXXXXXXXFFFFFFFFFFZZ ...\n", "IIIIIIIIIIIIIIIIIIIIUUUUUUUUUJALEAAAAAAAAAAAAUUUUPXPPZZZZZHHHHHHXHXXXXXXXXXXXXXXXXXXFXFFFFFFFFZZ ...\n", "IIIIIIIIIIIIIIIIIIIIUUUUUUUUUJAAAAAAAAAAAAAAUUPPPPPPPZZZZZZZHHHHHHHXXXXXXXXXXXXXXXXXXXFFFFFFFFFZ ...\n", "IIIIIIIIIIIAAIIIIIIIIIUUUUUUUJJAAAAAAAAAAAAAAVVPPPPPPPPZHHHHHHHHHHHXXXXXXXXXXXXXXXXXFFFFFFFFFFFZ ...\n", "IOOIIIIIIIIAAIIIIIIIIIIUUUQVUJJAAAAAAAAAAAAAEVVZPPPPPPPHHHHHHHHHHHHXXXXXXXXXXXXXXXXXXXXFFFFFFLLL ...\n", "OOOOOOOOIIAAAAAIIIIIIIIUQQQQVQJAAAAAAAAAAAAAAVVPPPPPIIHHHHHHHHHHHHHXXXXXUXXXXXXUUXXBBBSFFFLLLLLL ...\n", "OOOOOOOOIAAAAAAIIIIIIQQQQQQQQQQQEADDAAAAAAAAHHVVPPPIIIIHHHHHHHHHHHHHXXXUUUUUXXUUUXXBBBSFFFLLELLL ...\n", "OOOOOOOOIIIAAIIIIIQQQQQQQQQQTQJQEEDDDAAAAAAHHVVVVPIIIIIHHHHHHHHHHHHHXUUUUUUUUUUUMMXBBBSSSFFFLLLL ...\n", "...\n" ] } ], "source": [ "farm = Grid(parse(12))" ] }, { "cell_type": "markdown", "id": "bb95a10b-1f83-4940-a68b-b94696c3aab3", "metadata": {}, "source": [ "### Part 1: What is the total price of fencing all regions on your map?\n", "\n", "We are asked to calculate the cost of putting fences around each region. A **region** is a set of garden plots with the same crop that abut each other horizontally or vertically. The **price** of the fence for a region is defined as the product of the region's area and its perimeter. (That seems like a strange way to do pricing, but what do I know.) If we represent a region as a **set** of (x, y) points, then the area is easy: it is just the number of points. The perimeter can be computed by, for each plot point in the region, counting the neighbors (in the 4 directions) that are *not* in the region." ] }, { "cell_type": "code", "execution_count": 126, "id": "79f91f38-e325-44f2-9e53-b64ce12d9d35", "metadata": {}, "outputs": [], "source": [ "Region = Set[Point]\n", "region_area = len\n", "\n", "def fence_price(farm: Grid) -> int:\n", " \"\"\"Total price of fences for all the regions in the farm.\"\"\"\n", " return sum(map(region_price, all_regions(farm)))\n", "\n", "def region_price(region) -> int: return region_area(region) * perimeter_length(region)\n", "\n", "def perimeter_length(region: Region) -> int:\n", " \"\"\"The number of sides on the perimeter of the region:\n", " sides where the neighboring position in the given direction is not in the region.\"\"\"\n", " return quantify(neighbor not in region \n", " for plot in region for neighbor in neighbors(plot))" ] }, { "cell_type": "markdown", "id": "9524ee15-c378-4cd4-a79b-14fb99b17cb3", "metadata": {}, "source": [ "To find all the regions I'll start at a point and do a [flood fill](https://en.wikipedia.org/wiki/Flood_fill) to neighboring points with the same region letter, keeping track of points that have already been found. The function `all_regions` iterates over all points to make sure it finds every region, and `flood_fill` recursively expands to all points that neighbor `p` and have the same crop (letter). `flood_fill` mutates the set `already_found` as it goes (and also mutates the `region` it is building up)." ] }, { "cell_type": "code", "execution_count": 128, "id": "1fbabbfb-50c8-4197-8517-e7cee9582765", "metadata": {}, "outputs": [], "source": [ "def all_regions(farm: Grid) -> List[Region]:\n", " \"\"\"Find all the regions in the farm.\"\"\"\n", " already_found = set() # Set of plots already accounted for\n", " return [flood_fill(p, farm, set(), already_found) \n", " for p in farm if p not in already_found]\n", "\n", "def flood_fill(p: Point, grid: Grid, region: set, already_found: set) -> set:\n", " \"\"\"Starting at point p, recursively add all neighboring points to `region`, keeping track of `already_found`.\"\"\"\n", " if p not in already_found:\n", " region.add(p)\n", " already_found.add(p)\n", " for p2 in grid.neighbors(p):\n", " if farm[p2] == farm[p]:\n", " flood_fill(p2, grid, region, already_found)\n", " return region" ] }, { "cell_type": "code", "execution_count": 129, "id": "cdaf655b-d12c-4973-b19b-3132e5e691c6", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 12.1: .031 seconds, answer 1402544 ok" ] }, "execution_count": 129, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(12.1, 1402544, lambda:\n", " fence_price(farm))" ] }, { "cell_type": "markdown", "id": "b3383560-2bbc-4dfc-b643-feb103876823", "metadata": {}, "source": [ "### Part 2: What is the total price of fencing all regions on your map, with the bulk discount?\n", "\n", "In Part 2 we get a **bulk discount** on the fencing; we only need to pay for the number of **straight line sides** on the perimeter, not the total length of the perimeter. For example, a 10 x 10 square has perimeter 40, but has only 4 sides. That's a 90% discount!\n", "\n", "It took me a while to figure out a good approach for this. At first I was reminded of the Convex Hull problem, for which I have [a notebook](https://github.com/norvig/pytudes/blob/main/ipynb/Convex%20Hull.ipynb). But that's not really appropriate here; our regions could be non-convex, and the set of sides in a region are not the same as the vertexes of a polygon (e.g., a region with one point has 4 sides, not 0). (*Funny story:* I wondered if an AI large language model (LLM) for programming would get confused like I did on this. So I described the problem in a way that hinted at convex hull, and the LLM suggested sorting the points by their angle to the centroid (a good idea for the convex hull problem), and then returning the length of the list of points. So, (1) that's not the right answer, and (2) if it was the right answer, it would have been right before sorting.)\n", "\n", "A better idea is to start with the perimeter length and subtract one for every case in which a point has an edge in one direction (e.g., an edge to the North) and also has a neighbor with the same edge. To be precise, I'll look for four cases:\n", "- A point with an edge to the North whose neighbor to the East also has an edge to the North\n", "- A point with an edge to the East whose neighbor to the South also has an edge to the East\n", "- A point with an edge to the South whose neighbor to the West also has an edge to the South\n", "- A point with an edge to the West whose neighbor to the North also has an edge to the West\n", "\n", "Here are two diagrams of two regions with two kinds of crop, \"`X`\" and \"`W`\", with a \"`-`\" marking each place where a perimeter piece would be subtracted.\n", "\n", " .X-... .-------..\n", " -X-.X- .WWWWWWWW-\n", " -XXXX- -WWWWWWWW-\n", " ..XXX. -WWWWWWWW.\n", " ...--. ..-------.\n", "\n", "I'll refactor `fence_price` to take a `region_price` parameter, and show that the change is backwards compatible to Part 1:" ] }, { "cell_type": "code", "execution_count": 131, "id": "38c30e15-3a33-40c2-b734-163a15af7a8a", "metadata": {}, "outputs": [], "source": [ "def fence_price(farm: Grid, region_price:Callable=region_price) -> int:\n", " \"\"\"Total price of fences for all the regions in the farm, given the price function for a region.\"\"\"\n", " return sum(map(region_price, all_regions(farm)))\n", "\n", "def discount_region_price(region) -> int: return region_area(region) * region_sides(region)\n", " \n", "def region_sides(region):\n", " \"\"\"How many straight-line sides does this region have?\n", " The perimeter minus all sides that are the same as their clockwise neighbor.\"\"\"\n", " def has_edge(p: Point, d: Vector): return p in region and add(p, d) not in region\n", " def neighbor(p: Point, d: Vector): return add(p, make_turn(d, 'R'))\n", " subtract = quantify(has_edge(p, d) and has_edge(neighbor(p, d), d)\n", " for p in region\n", " for d in directions4)\n", " return perimeter_length(region) - subtract" ] }, { "cell_type": "code", "execution_count": 132, "id": "72175812-dcd0-4f1b-9efa-0dceeeafa609", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 12.1: .051 seconds, answer 1402544 ok" ] }, "execution_count": 132, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(12.1, 1402544, lambda:\n", " fence_price(farm))" ] }, { "cell_type": "code", "execution_count": 133, "id": "9defcd35-91bc-41d4-a16f-bb7a4ede75e7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 12.2: .045 seconds, answer 862486 ok" ] }, "execution_count": 133, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(12.2, 862486, lambda: \n", " fence_price(farm, discount_region_price))" ] }, { "cell_type": "markdown", "id": "faa9d750-a619-40dc-965c-a9a8e2543e32", "metadata": {}, "source": [ "# [Day 13](https://adventofcode.com/2024/day/13): Claw Contraption\n", "\n", "Today's puzzle involves arcade claw machines. Each input paragraph describes a machine with two buttons, **A** and **B**; every push of a button moves the claw a specified amount in the X and Y directions (which is different for each machine). The prize is at a specified location (also different for each machine). We can parse the input by defining a `parse_claw` function and a `Claw` datatype to represent the machine.\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 135, "id": "e78f45c0-c420-4661-aad2-14e122b4473b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 1279 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Button A: X+24, Y+19\n", "Button B: X+32, Y+86\n", "Prize: X=1072, Y=2062\n", "\n", "Button A: X+70, Y+12\n", "Button B: X+11, Y+43\n", "Prize: X=3400, Y=3872\n", "\n", "...\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Parsed representation ➜ 320 Claws:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Claw(A=(24, 19), B=(32, 86), Prize=(1072, 2062))\n", "Claw(A=(70, 12), B=(11, 43), Prize=(3400, 3872))\n", "Claw(A=(48, 77), B=(34, 12), Prize=(6510, 1583))\n", "Claw(A=(76, 60), B=(29, 88), Prize=(5506, 6300))\n", "Claw(A=(16, 75), B=(68, 20), Prize=(17148, 13490))\n", "Claw(A=(46, 13), B=(33, 63), Prize=(15572, 9644))\n", "Claw(A=(21, 79), B=(44, 32), Prize=(2433, 5147))\n", "Claw(A=(13, 45), B=(36, 11), Prize=(4612, 19164))\n", "...\n" ] } ], "source": [ "Claw = namedtuple('Claw', 'A, B, Prize') # A claw machine\n", "\n", "def parse_claw(text: str) -> Claw:\n", " \"\"\"Parse a paragraph of text into a Claw object.\"\"\"\n", " ax, ay, bx, by, px, py = ints(text)\n", " return Claw((ax, ay), (bx, by), (px, py))\n", " \n", "claws = parse(13, parse_claw, sections=paragraphs)" ] }, { "cell_type": "markdown", "id": "7f6da888-9288-42f1-bc51-2eb2a66d34a1", "metadata": {}, "source": [ "### Part 1: What is the fewest tokens you would have to spend to win all possible prizes?\n", "\n", "We are told that for some machines it is possible to reach the prize and others it is impossible. We are also told that you need to spend 3 **tokens** to press the **A** button and 1 token to press the **B** button. There is a hint that no button will need to be pushed more than **100 times**. It is usually a good idea to accept the hint, so I will do the following:\n", "- Exhaustively try every number from 0 to 100 presses of the **A** button.\n", "- For each number, figure out what the resulting position of the claw would be after those presses.\n", "- Calculate how many presses of the **B** button would be required to get to the prize's X location.\n", "- If the number of presses is an integer, and would also arrive at the prize's Y location, then yield that (A-presses, B-presses) solution.\n", "- Out of these solutions, the cheapest solution is the one that needs the fewest tokens.\n", "- (If there are no solutions, `cheapest_solution` will return 0, whcih is convenient for adding the results up, but is worrisome because it doesn't distinguish between an impossible-to-reach prize and a prize at the origin. On this puzzle, that's ok, but it is still worrisome.)" ] }, { "cell_type": "code", "execution_count": 137, "id": "c2c4bbc9-42cd-483d-8da2-97cf051e93fe", "metadata": {}, "outputs": [], "source": [ "def solve_claw(claw: Claw, limit=100) -> Iterable[Tuple[int, int]]:\n", " \"\"\"All possible (A-presses, B-presses) solutions to reach the prize on this machine.\"\"\"\n", " A, B, Prize = claw\n", " for Apresses in range(limit + 1):\n", " pos = mul(A, Apresses)\n", " if X_(pos) > X_(Prize) or Y_(pos) > Y_(Prize):\n", " return\n", " diff = sub(Prize, pos)\n", " Bpresses = X_(diff) / X_(B)\n", " if Bpresses.is_integer() and Bpresses * Y_(B) == Y_(diff):\n", " yield (Apresses, int(Bpresses))\n", "\n", "def cheapest_solution(claw: Claw) -> int: \n", " \"\"\"The minimum cost out of every possible solution to this claw machine.\"\"\"\n", " return min((3 * A + B for (A, B) in solve_claw(claw)), default=0)" ] }, { "cell_type": "code", "execution_count": 138, "id": "f5638ed4-1e59-4b9f-b1fc-427d2eb0d036", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 13.1: .006 seconds, answer 29598 ok" ] }, "execution_count": 138, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(13.1, 29598, lambda:\n", " sum(map(cheapest_solution, claws)))" ] }, { "cell_type": "markdown", "id": "3a36e76c-dd5b-4d80-ae88-9980e7d274ac", "metadata": {}, "source": [ "### Part 2: Using the corrected prize coordinates, what is the fewest tokens you would have to spend to win all possible prizes?\n", "\n", "In Part 2, we discover that \"due to a unit conversion error\" the prize is actually **much** farther away, by 10,000,000,000,000 (ten trillion) steps in both the X and Y coordinates. Theoretically, we could still use `solve_claw` with a bigger `limit`, but that would take a *long* time.\n", "Instead I can solve each claw machine *mathematically* rather than by trial and error. It looks like each claw machine defines two equations; what exactly are the equations? For my first claw machine, \n", "\n", " Button A: X+24, Y+19\n", " Button B: X+32, Y+86\n", " Prize: X=1072, Y=2062\n", "\n", "there are two linear equations to solve simultaneously, over the integers:\n", "\n", " 24 A + 32 B = 1072\n", " 19 A + 86 B = 2062\n", "\n", "I know that an equation over the integers is called a [Diophantine equation](https://en.wikipedia.org/wiki/Diophantine_equation), but I don't remember much about them, and furthermore it seems like it is more important that these are linear equations than that they are Diophantine equations. In general, two linear equations in two unknowns can have zero solutions (if the lines are parallel), an infinite number of solutions (if the lines are the same), or exactly one solution (the intersection of the lines; the \"normal\" case). We can solve the linear equations, and then discard the answer if *A* and *B* are not integers. \n", "\n", "I defined `solve_claw` to yield multiple solutions, but let's see how many solutions each claw machine yields:" ] }, { "cell_type": "code", "execution_count": 140, "id": "df8da2ae-52f9-409b-a54f-ad7d21b32e45", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Counter({0: 168, 1: 152})" ] }, "execution_count": 140, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Counter(quantify(solve_claw(c)) for c in claws)" ] }, { "cell_type": "markdown", "id": "f0f97d47-5741-4c6e-ae96-5b3161ee2e56", "metadata": {}, "source": [ "This says that 168 claw machines have no solution and 152 have exactly one solution. None of them have more than one solution.\n", "\n", "So, what is the intersection point of two lines? You could [look it up](https://www.wolframalpha.com/input?i=solve+for+a%2C+b%3A+p+*+a+%2B+q+*+b+%3D+r++and+++s+*+a+%2B+t+*+b+%3D+u) or work it out by hand, or [call a library function](https://numpy.org/doc/2.1/reference/generated/numpy.linalg.solve.html). Given the two equations over the variables *a* and *b*:\n", "\n", " p * a + q * b = r\n", " s * a + t * b = u\n", "\n", "The solution is:\n", "\n", " a = (r * t - q * u) / (p * t - q * s)\n", " b = (r * s - p * u) / (q * s - p * t)\n", "\n", "So we can rewrite `solve_claw` to use this:" ] }, { "cell_type": "code", "execution_count": 142, "id": "6bbd0934-d962-4c93-940b-810651e9e568", "metadata": {}, "outputs": [], "source": [ "def solve_claw(claw: Claw) -> Iterable[Tuple[int, int]]:\n", " \"\"\"All possible (A-presses, B-presses) solutions to reach the prize on this machine.\"\"\"\n", " ((p, s), (q, t), (r, u)) = claw\n", " a = (r * t - q * u) / (p * t - q * s)\n", " b = (r * s - p * u) / (q * s - p * t)\n", " if a.is_integer() and b.is_integer():\n", " yield (int(a), int(b))" ] }, { "cell_type": "markdown", "id": "af52d98e-50e9-4c4d-875f-1ed2b3dc8111", "metadata": {}, "source": [ "This raises an interesting style question: If you have a function that might return zero or one result of type `T`, should you define the return type as `Optional[T]` or as `Iterable[T]`? I guess it depends on the expected use cases of the function.\n", "\n", "We'll need a way to move the prizes further away:" ] }, { "cell_type": "code", "execution_count": 144, "id": "dd38ba4c-44ba-426b-b1c8-0e10adbdd642", "metadata": {}, "outputs": [], "source": [ "def move_prizes(claws, delta=(10**13, 10**13)) -> List[Claw]:\n", " \"\"\"Move each claw's prize by the given displacement, delta.\"\"\"\n", " return [claw._replace(Prize=(add(claw.Prize, delta))) for claw in claws]" ] }, { "cell_type": "markdown", "id": "285bfa66-a33e-4d97-b7a7-cfd821953091", "metadata": {}, "source": [ "Now we can answer Part 2:" ] }, { "cell_type": "code", "execution_count": 146, "id": "9f578b3e-6b6d-4eb0-9228-c98122a84747", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 13.2: .000 seconds, answer 93217456941970 ok" ] }, "execution_count": 146, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(13.2, 93217456941970, lambda:\n", " sum(map(cheapest_solution, move_prizes(claws))))" ] }, { "cell_type": "markdown", "id": "db917eed-07e5-4409-a92d-b26534a1fcd4", "metadata": {}, "source": [ "The refactored `solve_claw` is compatible with Part 1, and should be faster:" ] }, { "cell_type": "code", "execution_count": 148, "id": "609ed4ce-548c-4af4-8e09-c621aca0124e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 13.1: .000 seconds, answer 29598 ok" ] }, "execution_count": 148, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(13.1, 29598, lambda:\n", " sum(map(cheapest_solution, claws)))" ] }, { "cell_type": "markdown", "id": "741bd221-cda4-432b-8ad2-b8c6950c7dc3", "metadata": {}, "source": [ "I could have recognized in Part 1 that we have a system of two linear equations in two unknowns, and implemented the Part 2 solution. But I have no regrets; I took the hint that trial-and-test for 100 trials was a good idea, and I saved the complicated algebra for when I really needed it in Part 2. Having two independent implementations that produce the same answer increases my confidence in both of them." ] }, { "cell_type": "markdown", "id": "2576ce68-3f1e-4887-ab0b-62fa94cbe55a", "metadata": {}, "source": [ "# [Day 14](https://adventofcode.com/2024/day/14 ): Restroom Redoubt\n", "\n", "Today's narratives involve multiple robots roaming around a restroom. Each line of the input describes a robot's position and velocity in two dimensions:" ] }, { "cell_type": "code", "execution_count": 151, "id": "1a5f5875-426d-47ea-a35a-405c39ced5dd", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 500 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "p=62,20 v=85,-14\n", "p=88,18 v=-70,97\n", "p=51,21 v=35,-22\n", "p=19,56 v=2,45\n", "p=93,11 v=-87,26\n", "p=90,67 v=44,-13\n", "p=99,34 v=82,57\n", "p=55,42 v=82,22\n", "...\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Parsed representation ➜ 500 tuples:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "(62, 20, 85, -14)\n", "(88, 18, -70, 97)\n", "(51, 21, 35, -22)\n", "(19, 56, 2, 45)\n", "(93, 11, -87, 26)\n", "(90, 67, 44, -13)\n", "(99, 34, 82, 57)\n", "(55, 42, 82, 22)\n", "...\n" ] } ], "source": [ "robots = parse(14, ints) " ] }, { "cell_type": "markdown", "id": "818a939d-2038-4574-a20b-c1194d403f2c", "metadata": {}, "source": [ "### Part 1: What will the safety factor be after exactly 100 seconds have elapsed?\n", "\n", "Each second the robots move according to their velocity, and they wrap around when they reach the edge of their world, which has width 101 and height 103. They never collide; they can pass right through each other. We're asked to figure out where they are after 100 seconds. I can see that it is not necessary to simulate the robots movements time step by time step; we can just multiply their velocity by time, add it to their initial position, and then take the result modulo the width or height. That's done in `robot_dance`. \n", "\n", "We're asked to figure out how many robots end up in each **quadrant**. There are four quadrants, but a robot that is exactly on a middle line, either horizontally or vertically, doesn't count in any quadrant. Finally, the **safety factor** is the product of the four counts of robots in each quadrant." ] }, { "cell_type": "code", "execution_count": 153, "id": "be22ac94-7401-4cf6-ab83-e43775536af7", "metadata": {}, "outputs": [], "source": [ "def robot_dance(robots, steps=100, width=101, height=103) -> List[Point]:\n", " \"\"\"Move each robot for `steps` number of steps.\"\"\"\n", " return [((x + steps * dx) % width, (y + steps * dy) % height)\n", " for (x, y, dx, dy) in robots]\n", "\n", "def quadrant_counts(positions, w=101//2, h=103//2) -> Counter:\n", " \"\"\"How many robots are in each quadrant? Ignore robots exactly in the middle.\"\"\"\n", " return Counter((sign(x - w), sign(y - h)) \n", " for (x, y) in positions if x != w and y != h)\n", "\n", "def safety_factor(robots) -> int:\n", " \"\"\"The product of the four counts of robots in each quadrant.\"\"\"\n", " return prod(quadrant_counts(robot_dance(robots)).values())" ] }, { "cell_type": "code", "execution_count": 154, "id": "69093001-79aa-463a-b801-51cd5b4de4eb", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 14.1: .000 seconds, answer 216027840 ok" ] }, "execution_count": 154, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(14.1, 216027840, lambda:\n", " safety_factor(robots))" ] }, { "cell_type": "markdown", "id": "06b4e335-9863-40f7-983a-0744884dbc20", "metadata": {}, "source": [ "In case you're curious, here are the quadrant counts after 100 steps:" ] }, { "cell_type": "code", "execution_count": 156, "id": "08661dc5-445c-4908-b0b4-57f3a53e5179", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Counter({(1, 1): 124, (-1, 1): 122, (-1, -1): 120, (1, -1): 119})" ] }, "execution_count": 156, "metadata": {}, "output_type": "execute_result" } ], "source": [ "quadrant_counts(robot_dance(robots))" ] }, { "cell_type": "markdown", "id": "a0cb27ad-82ff-4dcb-85cf-596b16ae9875", "metadata": {}, "source": [ "### Part 2: What is the fewest number of seconds that must elapse for the robots to display a picture of a Christmas Tree?\n", "\n", "I was **so** sure that Part 2 was going to ask for 10 trillion steps, and I was going to be **so** clever for not simulating step-by-step. But I was wrong. \n", "\n", "Instead we have the very vague task of discovering when a picture emerges. There is a hint that \"*very rarely, most of the robots should arrange themselves into a picture of a Christmas tree.*\" Since I don't know exactly how to specify a picture of a Christmas tree, I see three options:\n", "1) I could build an animation, and watch as each frame is displayed, stopping when I see something that looks like a tree.\n", "2) The phrase \"*most of the robots should arrange themselves*\" suggests that most of the robots are in one area. I could check for that.\n", "3) I could generate an image for each time step and send it off to an AI image recognition service. That would be iffy, slow, and probably expensive. \n", "\n", "I'll try the animation approach first. Google and Stack Overflow led me to the `matplotlib.animation.FuncAnimation` function:" ] }, { "cell_type": "code", "execution_count": 158, "id": "664c686e-0c3d-43b8-970f-88c0bf47dbf6", "metadata": {}, "outputs": [], "source": [ "import matplotlib.animation\n", "\n", "def animate_robots(robots, times: Ints):\n", " \"\"\"Animate the robot dance over the given time steps.\"\"\"\n", " plt.rcParams[\"animation.html\"] = \"jshtml\"\n", " plt.rcParams['figure.dpi'] = 100 \n", " plt.ioff()\n", " fig, ax = plt.subplots()\n", " def animate(t: int):\n", " points = robot_dance(robots, t)\n", " plt.cla()\n", " ax.yaxis.set_inverted(True)\n", " plt.plot(*T(points), 'go')\n", " plt.title(f'{t} seconds')\n", " return matplotlib.animation.FuncAnimation(fig, animate, frames=times)" ] }, { "cell_type": "markdown", "id": "92048f28-a6a4-4c12-847f-62884177dec5", "metadata": {}, "source": [ "Here's what it looks like:" ] }, { "cell_type": "code", "execution_count": 160, "id": "87843969-cb37-4fa5-9788-6a1b71c43521", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", " \n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", "
\n", "
\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 160, "metadata": {}, "output_type": "execute_result" } ], "source": [ "animate_robots(robots, range(3))" ] }, { "cell_type": "markdown", "id": "6f722d21-dc5e-473c-b9d1-c71915cbeb6f", "metadata": {}, "source": [ "The animations take up a lot of space in the stored `.ipynb` file, so I only show 3 frames here. I looked at hundreds of frames, but no Christmas tree emerged. \n", "\n", "So, on to the second idea. If the hint had mentioned \"*all of the robots*\", I would look for an image frame with the minimum bounding box. But for \"*most of the robots*,\" I'll look for a frame that minimizes the mean distance from the centroid. " ] }, { "cell_type": "code", "execution_count": 162, "id": "9563d49c-54a3-439f-a833-f48c2a070609", "metadata": {}, "outputs": [], "source": [ "def mean_distance_to_centroid(points, distance=taxi_distance) -> float:\n", " \"\"\"The mean of each point's distance to the centroid.\"\"\"\n", " centroid = (mean(Xs(points)), mean(Ys(points)))\n", " return mean(distance(p, centroid) for p in points)\n", "\n", "def most_clustered_time(robots, times=range(10_000)) -> int:\n", " \"\"\"Out of all the given time steps, the one that has the robots clustered closest together.\"\"\"\n", " return min(times, key=lambda t: mean_distance_to_centroid(robot_dance(robots, t)))" ] }, { "cell_type": "code", "execution_count": 163, "id": "ab8c7e3b-f400-4976-ad0d-5f92cbadec02", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", " \n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", "
\n", "
\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 163, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t = most_clustered_time(robots)\n", "animate_robots(robots, [t])" ] }, { "cell_type": "markdown", "id": "6a4794b4-1d3e-4d82-b886-4416ef5b6453", "metadata": {}, "source": [ "**It worked!** \n", "\n", "(At first I had a **bug**: the Christmas tree was upside down, because my Y-axis was upside down. So I added the `yaxis.set_inverted` call to `animate_robots`.)\n", "\n", "Although there was a human in the loop to verify the output, I can make this official with this call to `answer`:" ] }, { "cell_type": "code", "execution_count": 165, "id": "75434bc8-35ae-4d8b-b747-01d773472541", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 14.2: 1.898 seconds, answer 6876 ok" ] }, "execution_count": 165, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(14.2, 6876, lambda:\n", " most_clustered_time(robots, range(7000)))" ] }, { "cell_type": "markdown", "id": "08cae29b-9b07-4e8d-b2d1-f3798f6c7cd0", "metadata": {}, "source": [ "# [Day 15](https://adventofcode.com/2024/day/15): Warehouse Woes\n", "\n", "Today's input is in two sections: the first section is a grid map describing a warehouse with walls (`#`) and boxes (`O`) and a single robot (`@`). The second part is a set of instructions for how the robot moves (arrows). I'll parse the two sections as paragraphs, then parse each paragraph:" ] }, { "cell_type": "code", "execution_count": 167, "id": "20be45ec-f6fc-472c-9b49-872b7334528c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 71 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "##################################################\n", "#..OO..O.O....O...O..O...O.......O...OO##....O.OO#\n", "#O.#..#OOO#..O..OO...O.O.....OO..O#O#.OOO.....#..#\n", "#.....O.......OO.#OO....#O.OO.O..OO.O.O.O..##....#\n", "#.O....O...O#...#...OO..#..O........#O..#..O..O..#\n", "#O....O...O.O..OO..OO..#OO.#OO.O......##..O..O...#\n", "#..O.##..#O...O...#.#.O.O..O.#......O..#.#...O...#\n", "#O.O.........O..O........OO....OO......O.....O#..#\n", "...\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Parsed representation ➜ 2 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "##################################################\n", "#..OO..O.O....O...O..O...O.......O...OO##.... ...\n", ">><^v><>^v<vv><<^^>>>>^^><>^<^^vvv>>><><>v^^^^<<^<^><>>>v><>>>^>><>v>v>^v>>v>>>v ...\n" ] } ], "source": [ "warehouse_woes = parse(15, sections=paragraphs)\n", "warehouse = Grid(parse(warehouse_woes[0]))\n", "arrows = cat(parse(warehouse_woes[1]))" ] }, { "cell_type": "markdown", "id": "9a4aed93-5205-4946-b04c-637f3b095e4b", "metadata": {}, "source": [ "### Part 1: What is the sum of all boxes' GPS coordinates after moving?\n", "\n", "The robot attempts to follow each instruction arrow (for example, moving East when the arrow is `>`). The robot is strong enough to push a line of any number of boxes sitting in front of it; that's its job. However, if a push is blocked by a wall, then neither the robot nor any boxes will move.\n", "\n", "The **GPS coordinate** of a box at (*x*, *y*) is defined to be *x* + 100*y*.\n", "\n", "I'll implement `obey_arrows` to make the arrow moves on a copy of the warehouse. For each arrow the function finds all the things that might move (the robot and any boxes) with `moveables`; then `make_movement` checks if they would bump into a wall, and if not, they all move." ] }, { "cell_type": "code", "execution_count": 169, "id": "248d51c0-424e-4bbb-bbf4-37cdc18313e1", "metadata": {}, "outputs": [], "source": [ "def gps_coordinate(box: Point) -> int: return X_(box) + 100 * Y_(box)\n", "\n", "def obey_arrows(warehouse: Grid, arrows: str) -> Grid:\n", " \"\"\"Return a grid in which the robot has followed `arrows`, pushing boxes around.\"\"\"\n", " grid = warehouse.copy()\n", " robot_pos = the(grid.findall('@'))\n", " for arrow in arrows:\n", " dir = arrow_direction[arrow]\n", " robot_and_boxes = moveables(grid, robot_pos, dir)\n", " if make_movement(grid, robot_and_boxes, dir):\n", " robot_pos = add(robot_pos, dir)\n", " return grid\n", "\n", "def all_box_positions(grid) -> List[Point]: return grid.findall('O')\n", "\n", "def moveables(grid, start: Point, dir: Vector) -> List[Point]:\n", " \"\"\"The positions of moveable things (the robot and maybe boxes) going in direction `dir` from the `start`.\"\"\"\n", " def moveable(pos): return grid[pos] in ('@', 'O')\n", " return list(takewhile(moveable, grid.follow_line(start, dir)))\n", "\n", "def make_movement(grid, to_move: List[Point], dir: Vector) -> bool:\n", " \"\"\"Try to move the objects in the `to_move` positions in direction `dir`; return True if they move.\"\"\"\n", " def destination(p): return add(p, dir) # Where we are trying to move `p` to\n", " if grid[destination(to_move[-1])] == '#':\n", " return False\n", " else:\n", " for p in reversed(to_move): # Reverse order so they don't step on each other\n", " grid[destination(p)] = grid[p]\n", " grid[p] = '.'\n", " return True" ] }, { "cell_type": "code", "execution_count": 170, "id": "52e93218-6ac2-4cf7-aced-f4f3a3df77b5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 15.1: .026 seconds, answer 1563092 ok" ] }, "execution_count": 170, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(15.1, 1563092, lambda:\n", " sum(map(gps_coordinate, all_box_positions(obey_arrows(warehouse, arrows)))))" ] }, { "cell_type": "markdown", "id": "84dcd7fd-0f4a-4377-b61e-22bd5a0a51a9", "metadata": {}, "source": [ "### Part 2: What is the sum of all boxes' final GPS coordinates on the double-wide grid?\n", "\n", "In Part 2, there is another warehouse that is similar to the first, but twice as wide. Each position in the original warehouse is replaced by *two* copies of the contents, except that the robot is replaced by `@.` and a box, `O`, is replaced by `[]`, indicating the two halves of a double-wide box. The rules for movement and pushing are the same, except that when the robot is moving North or South and is pushing a box, that box, since it is two positions wide, can push *two* boxes if they are lined up right. (Presumably, those two boxes could then push three boxes in the next row, and so on, although the puzzle description did not explicitly specify that). Finally, the GPS coordinates are taken for the `[` part of the box. Here's what it looks like before and after the robot moves \"^\":\n", "\n", " ############## ##############\n", " ##......##..## ##......##..##\n", " ##..........## ##...[][]...##\n", " ##...[][]...## ##....[]....##\n", " ##....[]....## ##.....@....##\n", " ##.....@....## ##..........##\n", " ############## ##############\n", "\n", "So this is mostly the same as Part 1, but the criteria of what to move is different. Here are the changes I'll make:\n", "- I'll need to make the double-wide grid, by applying `doublewide` to the original text to get `warehouse2`.\n", "- I'll redefine `make_movement` to check for a wall in front of *any* of the boxes, not just the last one, and to move them all in one `update`, rather than one at a time.\n", "- I'll redefine `moveables` to deal with either regular or double-wide boxes (but not both in one maze).\n", "\n", "The redefinitions are backwards-comnpatible, which I'll demonstrate by re-running Part 1 before running Part 2:" ] }, { "cell_type": "code", "execution_count": 172, "id": "2d9afbc1-75b2-479d-81fc-fbab69d25753", "metadata": {}, "outputs": [], "source": [ "def doublewide(text: str) -> str:\n", " \"\"\"Make the grid (described in text) twice as wide.\"\"\"\n", " return text.replace('#', '##').replace('O', '[]').replace('.', '..').replace('@', '@.')\n", " \n", "warehouse2 = Grid(parse(doublewide(warehouse_woes[0])))\n", "\n", "def make_movement(grid, to_move: Collection[Point], dir: Vector) -> bool:\n", " \"\"\"Try to move the objects in the `to_move` positions in direction `dir`; return True if they move.\"\"\"\n", " def destination(p): return add(p, dir) # Where we are trying to move `p` to\n", " if any(grid[destination(p)] == '#' for p in to_move):\n", " return False\n", " else:\n", " updates = {destination(p): grid[p] for p in to_move}\n", " grid.update({p: '.' for p in to_move})\n", " grid.update(updates)\n", " return True\n", "\n", "def moveables(grid, start_pos, dir) -> Set[Point]:\n", " \"\"\"The positions of moveable things (robot and maybe boxes) going in direction from the start.\"\"\" \n", " ahead = add(start_pos, dir)\n", " if dir in (East, West) or grid[ahead] == 'O': # Single line push\n", " def moveable(pos): return grid[pos] in ('@', 'O', '[', ']')\n", " return set(takewhile(moveable, grid.follow_line(start_pos, dir)))\n", " else: # Potential non-linear push\n", " results = {start_pos}\n", " if grid[ahead] in ('[', ']'): results |= moveables(grid, ahead, dir) \n", " if grid[ahead] == '[': results |= moveables(grid, add(ahead, East), dir)\n", " if grid[ahead] == ']': results |= moveables(grid, add(ahead, West), dir)\n", " return results" ] }, { "cell_type": "code", "execution_count": 173, "id": "7af49bbf-dd10-4221-9096-6f548dec44c0", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 15.1: .029 seconds, answer 1563092 ok" ] }, "execution_count": 173, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(15.1, 1563092, lambda:\n", " sum(map(gps_coordinate, obey_arrows(warehouse, arrows).findall('O'))))" ] }, { "cell_type": "code", "execution_count": 174, "id": "99246602-a51e-41aa-a7e9-7cdbc8d449ca", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 15.2: .042 seconds, answer 1582688 ok" ] }, "execution_count": 174, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(15.2, 1582688, lambda:\n", " sum(map(gps_coordinate, obey_arrows(warehouse2, arrows).findall('['))))" ] }, { "cell_type": "markdown", "id": "4361f8c3-1d15-441e-9a41-b1ea20707651", "metadata": {}, "source": [ "I had a frustrating time **debugging** this one; this was by far my worst performance on this year's puizzles so far. First I had a silly typo in `moveables`; I was able to fix it after looking at the results on the smaller test puzzle:" ] }, { "cell_type": "code", "execution_count": 176, "id": "47c99f0f-ab65-4ae1-a308-42668feacdd5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "##############\n", "##...[].##..##\n", "##...@.[]...##\n", "##....[]....##\n", "##..........##\n", "##..........##\n", "##############\n" ] } ], "source": [ "xwarehouse = Grid(parse(doublewide(\"\"\"\\\n", "#######\n", "#...#.#\n", "#.....#\n", "#..OO@#\n", "#..O..#\n", "#.....#\n", "#######\"\"\")))\n", "\n", "xarrows = \"\n", "\n", "\n", "\n", "### Part 1: What is the lowest score a Reindeer could possibly get?\n", "\n", "The race through the maze starts at the `S` position and ends at the `E`. A reindeer is allowed to take a step forward (as long as there isn't a `#` wall there) or to turn 90 degrees right or left. The reindeer is initially facing East. The **score** for a path is one point for every forward step and 1000 points for every turn.\n", "\n", "We're asked to find the path with the minimum score. My [AdventUtils](AdventUtils.ipynb) notebook already contains an `A_star_search` function for finding least-cost paths, and a `GridProblem` class. By default, a `GridProblem` counts one point for a move in any direction, so we'll have to create a subclass, `MazeSearchProblem`. This is straightforward but a bit tedious; I had a **bug** where I accepted the default `is_goal` and `h` methods; that doesn't work because they assume the state is just a position; but for this problem the state contains both the position and the facing direction. Another **bug** was that I left out the `goal=end` in the call to `MazeSearchProblem`. I thought I wouldn't need it because I wrote an `is_goal` method, but the `goal` is needed in the `h` (heuristic estimate) method." ] }, { "cell_type": "code", "execution_count": 181, "id": "e6e4bfba-0170-436a-961b-d4749f2cd66e", "metadata": {}, "outputs": [], "source": [ "State = namedtuple('State', 'pos, facing')\n", "\n", "def reindeer_path(maze) -> Node:\n", " \"\"\"The lowest-cost path through the maze.\"\"\"\n", " start, end = the(maze.findall('S')), the(maze.findall('E'))\n", " problem = MazeSearchProblem(grid=maze, initial=State(start, East), goal=end)\n", " return A_star_search(problem)\n", "\n", "class MazeSearchProblem(GridProblem):\n", " \"\"\"A GridProblem where a turn costs 1000 points, a step ahead 1.\"\"\"\n", " \n", " def actions(self, state):\n", " ahead = add(state.pos, state.facing)\n", " return ['L', 'R'] + ([ahead] if self.grid[ahead] != '#' else [])\n", " \n", " def result(self, state, action) -> State:\n", " return (State(state.pos, make_turn(state.facing, action)) if action in ('L', 'R') else\n", " State(add(state.pos, state.facing), state.facing))\n", " \n", " def action_cost(self, s1, action, s2) -> int: return 1000 if action in ('L', 'R') else 1\n", "\n", " def is_goal(self, state) -> bool: return self.grid[state.pos] == 'E'\n", "\n", " def h(self, node) -> int: return taxi_distance(node.state.pos, self.goal)" ] }, { "cell_type": "code", "execution_count": 182, "id": "4974c14c-86da-4b86-a55c-6ae8781df207", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 16.1: .149 seconds, answer 103512 ok" ] }, "execution_count": 182, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(16.1, 103512, lambda:\n", " reindeer_path(maze).path_cost)" ] }, { "cell_type": "markdown", "id": "030e5786-cd2a-405f-b4d4-460cefab7e32", "metadata": {}, "source": [ "### Part 2: How many tiles are part of at least one of the best paths through the maze?\n", "\n", "In Part 2 we're asked to find the total number of positions that are part of *any* best path from start to end. I'll write a new version of `best_first_search` to return all the paths that have the same cost as the best path. I thought this would be easy, but I had **another bug** where I forgot to change the `<` to a `<=` in the fourth-to-last line of `all_paths_best_first_search`:" ] }, { "cell_type": "code", "execution_count": 184, "id": "692abfea-f9c8-477c-8369-386cdd2a7606", "metadata": {}, "outputs": [], "source": [ "def reindeer_best_positions(maze) -> Node:\n", " \"\"\"All the positions on any best path from start to end.\"\"\"\n", " start, end = the(maze.findall('S')), the(maze.findall('E'))\n", " problem = MazeSearchProblem(grid=maze, initial=State(start, East), goal=end)\n", " paths = list(all_paths_best_first_search(problem, f=lambda n: n.path_cost + problem.h(n)))\n", " return union({state.pos for state in path_states(path)} for path in paths)\n", "\n", "def all_paths_best_first_search(problem, f) -> List[Node]:\n", " \"Search nodes with minimum f(node) value first, return all paths with minimum cost.\"\n", " node = Node(problem.initial)\n", " frontier = PriorityQueue([node], key=f)\n", " reached = {problem.initial: node}\n", " while frontier:\n", " node = frontier.pop()\n", " if problem.is_goal(node.state):\n", " return [node] + [path for (cost, path) in frontier.items\n", " if cost == node.path_cost and problem.is_goal(path.state)]\n", " for child in expand(problem, node):\n", " s = child.state\n", " if s not in reached or child.path_cost <= reached[s].path_cost:\n", " reached[s] = child\n", " frontier.add(child)\n", " return []" ] }, { "cell_type": "code", "execution_count": 185, "id": "ea9bf9f3-0e6b-4949-a641-6b3db2fd9d32", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 16.2: .873 seconds, answer 554 ok" ] }, "execution_count": 185, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(16.2, 554, lambda:\n", " len(reindeer_best_positions(maze)))" ] }, { "cell_type": "markdown", "id": "91607c18-56c3-4432-8da8-cfe570887bc0", "metadata": {}, "source": [ "# [Day 17](https://adventofcode.com/2024/day/17): Chronospatial Computer\n", "\n", "Today we have to help debug a faulty computer. This particular computer has three registers, A, B, and C, and a program consisting of a sequence of octal digits. The input is a description of the state of the computer: the register values and the stored program. Since the format is the same," ] }, { "cell_type": "code", "execution_count": 187, "id": "50fd3cb8-0a6f-4edd-b5cb-f7b1e6f9d987", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 5 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Register A: 52042868\n", "Register B: 0\n", "Register C: 0\n", "\n", "Program: 2,4,1,7,7,5,0,3,4,4,1,7,5,5,3,0\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Parsed representation ➜ 3 ints, 1 list:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "52042868\n", "0\n", "0\n", "[2, 4, 1, 7, 7, 5, 0, 3, 4, 4, 1, 7, 5, 5, 3, 0]\n" ] }, { "data": { "text/plain": [ "Computer(A=52042868, B=0, C=0, program=[2, 4, 1, 7, 7, 5, 0, 3, 4, 4, 1, 7, 5, 5, 3, 0])" ] }, "execution_count": 187, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Computer = namedtuple('Computer', 'A, B, C, program')\n", " \n", "def parse_computer(text: str) -> Computer:\n", " \"\"\"Parse the text, extracting values for registers and program.\"\"\"\n", " A, B, C, *program = ints(text)\n", " return Computer(A, B, C, program)\n", "\n", "computer = parse(17, parse_computer, sections=None) # Just find all the integers\n", "computer" ] }, { "cell_type": "code", "execution_count": 188, "id": "c23b8a44-e352-4a30-abe5-3c939ffc743c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Computer(A=52042868, B=0, C=0, program=[2, 4, 1, 7, 7, 5, 0, 3, 4, 4, 1, 7, 5, 5, 3, 0])" ] }, "execution_count": 188, "metadata": {}, "output_type": "execute_result" } ], "source": [ "computer" ] }, { "cell_type": "markdown", "id": "031ec910-e249-487b-ae95-b98abae3b9cf", "metadata": {}, "source": [ "### Part 1: Run the Program. What do you get if you use commas to join the output values?\n", "\n", "Now we have to run the program. The computer has eight opcodes; each opcode operates on the following value in memory; some instructions take the operand literally, and some compute a **combo value** from it. The combo value is the same as the literal value, except that values 4, 5, and 6 refer to registers A, B, and C, respectively. Opcode 5 outputs (yields) the last octal digit of the combo value. There is a program counter (pc) that increments by 2 on each instruction (to skip over the operand) unless there is a branch instuction (opcode 3). See the [day's description](https://adventofcode.com/2024/day/17) for details on how the opcodes work." ] }, { "cell_type": "code", "execution_count": 190, "id": "d98f88cc-c435-43fc-bcb5-52e6dd70fdb1", "metadata": {}, "outputs": [], "source": [ "def run_program(computer) -> Iterable[int]:\n", " \"\"\"Run the program on the computer, yielding each output.\"\"\"\n", " A, B, C, program = computer\n", " pc = 0\n", " while pc < len(program):\n", " op, val = program[pc:pc+2]\n", " pc += 2\n", " combo = (A if val == 4 else B if val == 5 else C if val == 6 else val)\n", " match op:\n", " case 0: A = A // (2 ** combo)\n", " case 6: B = A // (2 ** combo)\n", " case 7: C = A // (2 ** combo)\n", " case 1: B = B ^ val\n", " case 4: B = B ^ C\n", " case 2: B = combo % 8\n", " case 5: yield combo % 8\n", " case 3: \n", " if A: pc = val" ] }, { "cell_type": "markdown", "id": "6348d561-9ac9-437c-8bcd-6fbd91d1ebf5", "metadata": {}, "source": [ "With my `run_program` function, the answer for Part 1 is easy:" ] }, { "cell_type": "code", "execution_count": 192, "id": "860f24e5-92ad-4361-8920-102ebc573598", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 17.1: .000 seconds, answer 2,1,0,1,7,2,5,0,3 ok" ] }, "execution_count": 192, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(17.1, '2,1,0,1,7,2,5,0,3', lambda:\n", " cat(run_program(computer), ','))" ] }, { "cell_type": "markdown", "id": "d3248e42-ab8e-4fdb-8e19-439766275c37", "metadata": {}, "source": [ "### Part 2: What is the lowest positive initial value for register A that causes the program to output a copy of itself?\n", "\n", "In Part 2, we find that register A has been corrupted, and we need to restore it to the value that will make the program output a copy of itself (a [Quine](https://en.wikipedia.org/wiki/Quine_%28computing%29)). I was afraid of this! AoC always has a puzzle where you have to write an interpreter for a program in some obscure language, but then in Part 2 you have to actually *understand* what the program is doing; you can't use brute force. (I tried brute force up to A=10,000,000 with no luck.)\n", "\n", "To try to understand my program, here it is in pseudocode:\n", "\n", " top: B = A % 8 # 2, 4\n", " B = B ^ 7 # 1, 7\n", " C = A / 2 ** B # 7, 5\n", " A = A / 2 ** 3 # 0, 3\n", " B = B ^ C # 4, 4\n", " B = B ^ 7 # 1, 7\n", " output B # 5, 5\n", " if A: goto top # 3, 0\n", "\n", "I can summarize that as:\n", "\n", " top: B and C are defined in terms of the last octal digit of A, and prior value of B\n", " A is shifted to eliminate the last octal digit\n", " output B \n", " if A: goto top \n", "\n", "So I realized that one octal digit of `A` is eliminated on each pass through the loop, and when `A` hits zero, we exit. Each pass outputs one octal digit, so `A` in octal has to be the same number of digits as my program; 16 octal digits is somewhere in the hundred trillion range. Good thing I gave up on brute force. \n", "\n", "I started playing around and came up with this:" ] }, { "cell_type": "code", "execution_count": 194, "id": "bb745303-dd20-486f-bbdd-7ae77f995c2c", "metadata": {}, "outputs": [], "source": [ "def run(computer=computer, **registers) -> List[int]: \n", " \"\"\"Run the program with registers set as keywords.\"\"\"\n", " return list(run_program(computer._replace(**registers)))" ] }, { "cell_type": "code", "execution_count": 195, "id": "36d89d9a-c8fc-41be-820b-cb13e40793c0", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0]" ] }, "execution_count": 195, "metadata": {}, "output_type": "execute_result" } ], "source": [ "run(A=0o7) # match the last digit of program" ] }, { "cell_type": "code", "execution_count": 196, "id": "892fef38-5f9b-4370-a242-f7a10df5487b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[3, 0]" ] }, "execution_count": 196, "metadata": {}, "output_type": "execute_result" } ], "source": [ "run(A=0o72) # match the last two digits of program" ] }, { "cell_type": "code", "execution_count": 197, "id": "b3d11d5e-30c2-419f-bc11-3f26fbdddfbb", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[5, 3, 0]" ] }, "execution_count": 197, "metadata": {}, "output_type": "execute_result" } ], "source": [ "run(A=0o726) # match the last three digits of program" ] }, { "cell_type": "code", "execution_count": 198, "id": "9ffcefa7-714f-416f-b6c7-8a9ad6d65380", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[5, 5, 3, 0]" ] }, "execution_count": 198, "metadata": {}, "output_type": "execute_result" } ], "source": [ "run(A=0o7266) # match the last four digits of program" ] }, { "cell_type": "markdown", "id": "f40f775f-bb9d-459c-80c3-ac09b6b42904", "metadata": {}, "source": [ "That is, I can build up the right value for `A` to generate a Quine program as follows:\n", "\n", "- I'm going to keep a **set** of candidate partial values for `A` as the set `As`.\n", "- The set starts with no digits, so just `{0}`.\n", "- On each iteration I try appending each octal digit to each element of the set `As` (by multplying by 8 and adding the digit).\n", "- I keep the candidate `A` values whose output from the run matches the tail of the program's output.\n", " - On each iteration we insist on matching one more octal digit of the tail of the program \n", "- Iterate this for each digit in the program and return the set of `A` values that reproduce the whole program.\n", "\n", "All of the resulting `A` values will be Quines, but the puzzle asks us to find just the minimum of the set." ] }, { "cell_type": "code", "execution_count": 200, "id": "2d244126-bcf4-4ef6-b9e8-1c9f4c682f07", "metadata": {}, "outputs": [], "source": [ "def quine(computer) -> Set[int]:\n", " \"\"\"Find the values of register `A` that cause the output of the run to match the program.\"\"\"\n", " As = {0} # Set of candidate partial values for register A\n", " for place in reversed(range(len(computer.program))):\n", " tail = computer.program[place:]\n", " candidates = {(A * 8) + d for A in As for d in range(8)}\n", " As = {A for A in candidates if run(A=A) == tail}\n", " return As" ] }, { "cell_type": "code", "execution_count": 201, "id": "82e2e6af-ec1b-4f37-a975-3e39152ebe3a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 17.2: .004 seconds, answer 267265166222235 ok" ] }, "execution_count": 201, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(17.2, 267265166222235, \n", " lambda: min(quine(computer)))" ] }, { "cell_type": "markdown", "id": "c7f9e900-45be-401f-a6f2-a1d7b751fae6", "metadata": {}, "source": [ "# [Day 18](https://adventofcode.com/2024/day/18): RAM Run\n", "\n", "In today's narrative, we're inside a computer, on a 2D memory board, and bytes are falling down, at specified (x, y) positions, as given in our input:" ] }, { "cell_type": "code", "execution_count": 203, "id": "d14e1966-2feb-4553-9a0a-12595ef4f7d7", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 3450 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "40,65\n", "17,1\n", "34,45\n", "31,51\n", "29,43\n", "25,9\n", "14,27\n", "5,29\n", "...\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Parsed representation ➜ 3450 tuples:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "(40, 65)\n", "(17, 1)\n", "(34, 45)\n", "(31, 51)\n", "(29, 43)\n", "(25, 9)\n", "(14, 27)\n", "(5, 29)\n", "...\n" ] } ], "source": [ "falling_bytes = parse(18, ints)" ] }, { "cell_type": "markdown", "id": "1229cec7-a456-4dd6-a668-8a00591c63f7", "metadata": {}, "source": [ "\n", "\n", "### Part 1: What is the minimum number of steps needed to reach the exit?\n", "\n", "When a byte falls it creates a barrier. Our task is to find a path that avoids the barriers, from the start in the upper left to the exit in the lower right of a 71 x 71 grid that is the memory board. \n", "\n", "This is another search puzzle, like the maze in Day 16, but without the complications (e.g. costs for turning right or left), so I can use my `GridProblem` class from [AdventUtils](AdventUtils.ipynb) without alteration. The puzzle description for today says that we should first consider just the first kilobyte (1024 falling bytes), and I was worried that if I just hand those points to my `Grid` class, it wouldn't cover the whole 71 x 71 grid. Therefore, I created a grid with empty spaces, and then updated with the falling bytes. The function `memory_path` returns a path, and we can then ask for its length to get the answer." ] }, { "cell_type": "code", "execution_count": 205, "id": "83af4751-38c9-4830-a2fa-78515b59bc97", "metadata": {}, "outputs": [], "source": [ "def memory_path(falling_bytes: Tuple[Point], width=71, height=71) -> Grid:\n", " \"\"\"Make a Grid of the given size with the points as obstacles, and find a path.\"\"\"\n", " grid = Grid(['.' * width] * height)\n", " grid.update({p: '#' for p in falling_bytes})\n", " problem = GridProblem(grid=grid, initial=(0, 0), goal=(width - 1, height - 1))\n", " return A_star_search(problem)" ] }, { "cell_type": "code", "execution_count": 206, "id": "29da25e2-f3c2-43e3-8769-1d4fcecb807b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 18.1: .014 seconds, answer 344 ok" ] }, "execution_count": 206, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(18.1, 344, lambda:\n", " len(memory_path(falling_bytes[:1024])))" ] }, { "cell_type": "markdown", "id": "792bc31e-964d-47fe-a09b-6a95724e641e", "metadata": {}, "source": [ "### Part 2: What are the coordinates of the first byte that will prevent the exit from being reachable from your starting position?\n", "\n", "After 1024 bytes fall there is a path from start to exit, but as more bytes fall we might have to switch to a different path, and eventually there will be no path. We're asked for the `(x,y)` position of the first falling byte that blocks off the last possible path. I can think of two ways to handle this:\n", "1) Add falling bytes one at a time and repeat the A-star search each time. **Slow!**\n", "2) Add falling bytes in **binary search** fashion: We know adding no bytes is **good** for getting a path and adding all of them is **bad**; try half way and then update **good** or **bad** depending on whether we found a path. Repeat until **good** is one more than **bad**; that's the answer. **Fast!**" ] }, { "cell_type": "code", "execution_count": 208, "id": "4c0a8dcb-c3af-45e7-9273-8776e8c3ea1d", "metadata": {}, "outputs": [], "source": [ "def memory_blocker(falling_bytes, good=1024) -> Point:\n", " \"\"\"Which falling byte is the first to block a path to the exit? Do binary search.\"\"\"\n", " # Here `good` and `bad` are the stop values of a slice, not an index,\n", " # so the final answer is falling_bytes[bad - 1], not falling_bytes[bad]\n", " bad = len(falling_bytes) \n", " while bad != good + 1:\n", " mid = (good + bad) // 2\n", " if memory_path(falling_bytes[:mid]) == search_failure:\n", " bad = mid\n", " else:\n", " good = mid\n", " return falling_bytes[bad - 1]" ] }, { "cell_type": "code", "execution_count": 209, "id": "22371144-5d51-440a-918f-a63de73b13ad", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 18.2: .032 seconds, answer 46,18 ok" ] }, "execution_count": 209, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(18.2, '46,18', lambda:\n", " cat(memory_blocker(falling_bytes), ','))" ] }, { "cell_type": "markdown", "id": "552f1c6e-052e-43d0-b13f-e8f66f274d63", "metadata": {}, "source": [ "I admit I initially had an off-by-one **bug** here. I was inconsistent on whether `bad` should be an **index** into the falling byte arrays, or the **stop** of a slice.\n", "\n", "I realize that for Part 1 I should have had separate functions for making the grid and solving it; then in Part 2 I could have incrementally modified the grid each time rather than creating a whole new Grid (and Problem). But it runs in under 1/10 second, so it is not worth changing it." ] }, { "cell_type": "markdown", "id": "702d6ea3-bcb1-4c90-8d67-9e686cd0155f", "metadata": {}, "source": [ "# [Day 19](https://adventofcode.com/2024/day/19): Linen Layout\n", "\n", "Today's input is in two sections, the first a list of towel patterns (with each letter of a word specifying a color), and the second a list of desired designs to be made by adjoining towel patterns. For example, if the patterns include\n", "\n", " a, dub, rub, ...\n", "\n", "and the desired design is\n", "\n", " rubadubdub\n", "\n", "then it can be made from the patterns with\n", "\n", " rub + a + dub + dub" ] }, { "cell_type": "code", "execution_count": 212, "id": "689df92b-92d7-44e6-8b4e-d67bf3f153df", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 402 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "rub, wugrr, gww, wgurb, urur, ggb, bw, uubbu, uw, uggru, gwwgrgb, wbbb, rgb, wuuur, bgruggug, ru ...\n", "\n", "rurgggubugbuwugbwgggwbwwwrbrbgwwwwuwuugrwbrbwgguwr\n", "ruurbrwgrurubwrurugubgurgruurwgugwgrwuwbrww\n", "gwbrwwruwubrwgubggggubwwrurugbbuuugwwburbw\n", "wwgwugrrrbwbgwburguwgbrgrwurugbbgubuuugbguur\n", "ubgbbrruwbgbrrgwwwwwrwgggggrwbgwuwgrwrbwbrg\n", "rurbbgrbwbggugrbwwbwrwuwuwbwwbwugwrubbww\n", "...\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Parsed representation ➜ 2 tuples:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "('rub', 'wugrr', 'gww', 'wgurb', 'urur', 'ggb', 'bw', 'uubbu', 'uw', 'uggru', 'gwwgrgb', 'wbbb', ...\n", "('rurgggubugbuwugbwgggwbwwwrbrbgwwwwuwuugrwbrbwgguwr', 'ruurbrwgrurubwrurugubgurgruurwgugwgrwuwb ...\n" ] } ], "source": [ "patterns, designs = parse(19, atoms, sections=paragraphs)" ] }, { "cell_type": "markdown", "id": "581ff31b-ec09-4ae5-84c7-3b3ffbbd9362", "metadata": {}, "source": [ "### Part 1: How many of the desired designs are possible?\n", "\n", "The task is to see how many of the desired designs can posibly be made by concatenating one or more of the patterns (with repetitions allowed). I can do this by checking if some pattern starts the design and recursively checking if the rest of the design is possible." ] }, { "cell_type": "code", "execution_count": 214, "id": "e0b96545-5f60-4c8e-9a0f-c77608c19128", "metadata": {}, "outputs": [], "source": [ "def is_possible_design(design, patterns=patterns) -> bool:\n", " \"\"\"Is it possible to make `design` by concatenating some of the `patterns`?\"\"\"\n", " return (design == '' \n", " or any(design.startswith(p) and is_possible_design(design[len(p):], patterns) \n", " for p in patterns))" ] }, { "cell_type": "code", "execution_count": 215, "id": "3c3fba1b-d3e5-494e-aad0-42ca0566ae1f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 19.1: .040 seconds, answer 242 ok" ] }, "execution_count": 215, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(19.1, 242, lambda:\n", " quantify(designs, is_possible_design))" ] }, { "cell_type": "markdown", "id": "c7a03f27-c1af-4561-a887-ff4f9b7b0b51", "metadata": {}, "source": [ "### Part 2: What do you get if you add up the number of different ways you could make each design?\n", "\n", "For Part 2 we need to count all the ways that each design can be made. Since there can be an exponential number of ways for each design, I'm going to `cache` intermediate results. The number of ways is computed by considering each pattern that starts the design and recursively summing up the count of the number of ways for the rest of the design." ] }, { "cell_type": "code", "execution_count": 217, "id": "77d4fae1-d506-4733-9bb2-467619012f97", "metadata": {}, "outputs": [], "source": [ "@cache\n", "def count_ways(design, patterns=patterns) -> int:\n", " \"\"\"How many ways can the design be made from the patterns?\"\"\"\n", " return (1 if design == '' else\n", " sum(count_ways(design[len(p):], patterns)\n", " for p in patterns if design.startswith(p)))" ] }, { "cell_type": "code", "execution_count": 218, "id": "14116eca-0b0f-484a-a169-9726e4ac7fbf", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 19.2: .188 seconds, answer 595975512785325 ok" ] }, "execution_count": 218, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(19.2, 595975512785325, lambda:\n", " sum(map(count_ways, designs)))" ] }, { "cell_type": "markdown", "id": "b1199e79-bb09-4d68-89e6-b235c5f987c5", "metadata": {}, "source": [ "### Part 3: Exploration\n", "\n", "That was so easy that there is time to explore a bit more. First, here's a check that says a design is possible if and only if there is at least one way to make it: " ] }, { "cell_type": "code", "execution_count": 220, "id": "f992b197-be14-47dc-8678-10cc63a1afd7", "metadata": {}, "outputs": [], "source": [ "for d in designs:\n", " assert is_possible_design(d) == (count_ways(d) >= 1)" ] }, { "cell_type": "markdown", "id": "a003849a-ae35-4c86-8d48-b954908d636b", "metadata": {}, "source": [ "Here is an alternative approach to Part 1 that turns out to be faster. It uses one big regular expression to match repetitions of the designs. We then check for a full-line match against each of the desired designs. Note that the `fullmatch` method in the `re` module looks for a full match of the input string, similar to `r\"^...$\"`. " ] }, { "cell_type": "code", "execution_count": 222, "id": "2437ae06-27e4-4840-ad51-65454ef0bf60", "metadata": {}, "outputs": [], "source": [ "def count_possible_designs(designs, patterns) -> int:\n", " \"\"\"A count of all the `designs` that can be made by concatenating `patterns`.\"\"\"\n", " regex = re.compile(\"(\" + \"|\".join(patterns) + \")+\")\n", " return quantify(designs, regex.fullmatch)" ] }, { "cell_type": "code", "execution_count": 223, "id": "88e45604-ce45-478e-a1b8-66ead1d0e72e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 19.1: .004 seconds, answer 242 ok" ] }, "execution_count": 223, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(19.1, 242, lambda: \n", " count_possible_designs(designs, patterns))" ] }, { "cell_type": "markdown", "id": "efc9dc54-cdcc-40d5-85d5-b8ed8da61ba2", "metadata": {}, "source": [ "# [Day 20](https://adventofcode.com/2024/day/20): Race Condition\n", "\n", "Yet another puzzle with a grid, this one depicting a racetrack:" ] }, { "cell_type": "code", "execution_count": 225, "id": "156dcbf7-79ec-41a7-a9f2-397a827b9856", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 141 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "################################################################################################ ...\n", "#...#...#...........#...#...#...#...#.....#...###...#...###.........#...#...#.......#...#...#... ...\n", "#.#.#.#.#.#########.#.#.#.#.#.#.#.#.#.###.#.#.###.#.#.#.###.#######.#.#.#.#.#.#####.#.#.#.#.#.#. ...\n", "#.#...#.#...#.....#...#...#...#.#.#.#...#...#...#.#...#...#.......#...#...#.#.....#.#.#...#.#.#. ...\n", "#.#####.###.#.###.#############.#.#.###.#######.#.#######.#######.#########.#####.#.#.#####.#.#. ...\n", "#.#.....###...###.......#.......#.#.....#.......#.......#...#.....#...#.....#...#.#.#.....#...#. ...\n", "#.#.###################.#.#######.#######.#############.###.#.#####.#.#.#####.#.#.#.#####.#####. ...\n", "#.#.#...###...#...#.....#.......#.......#.###...#...###...#.#...#...#...###...#.#.#...###.....#. ...\n", "...\n" ] } ], "source": [ "racetrack = Grid(parse(20))" ] }, { "cell_type": "markdown", "id": "57918fd0-bb72-4c5e-8e1f-3bcf164a1d72", "metadata": {}, "source": [ "### Part 1: How many cheats would save you at least 100 picoseconds?\n", "\n", "We are told that the grid depicts a single path from start (`S`) to end (`E`). Each step (in one of the four cardinal directions) takes one picosecond. But you are allowed to **cheat** once during the race by going through a wall: you can take two steps where the first step is into a wall and the second is back onto the track. We are asked how many such cheats would save 100 picoseconds or more.\n", "\n", "This is an all-paths-to-the-goal puzzle, which should make you think [**Dijkstra's algorithm**](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm). My function `dijkstra` will return a dict of `{(x, y): distance_to_end}`. It works by maintaining a queue, `Q` of points to be considered, and one at a time popping a point off the queue, and for each neighbor that is not a wall, add the neighbor to the queue and record the distance to the neighbor as being one more than the distance to the point in the dict `distance_from`. Since we are told the grid is single-path, we don't have to worry about updating entries in `distance_from` for a second path to a point.\n", "\n", "Then my function `cheats` yields all `(start_position, end_position, time_saved)` tuples where the time saved is at least the given lower bound." ] }, { "cell_type": "code", "execution_count": 227, "id": "4c4ef05c-b548-49f9-b092-847e9752e745", "metadata": {}, "outputs": [], "source": [ "def dijkstra(grid, end: Point) -> Dict[Point, int]:\n", " \"\"\"All-paths distances from each point on the grid to the end position: {(x, y): distance}.\"\"\"\n", " distance_from = {end: 0}\n", " Q = [end]\n", " while Q:\n", " p = Q.pop()\n", " for p2 in grid.neighbors(p):\n", " if grid[p2] != '#' and p2 not in distance_from:\n", " Q.append(p2)\n", " distance_from[p2] = distance_from[p] + 1\n", " return distance_from\n", "\n", "def cheats(racetrack, minimum_savings=1) -> Iterable[Tuple[Point, Point, int]]:\n", " \"\"\"All ways of cheating by taking one step onto a wall (at p2) and a second step back on track (at p3),\n", " as long as they save at lease `minimum_savings` picoseconds\"\"\"\n", " D = dijkstra(racetrack, the(racetrack.findall('E'))) # A dict of {sposition: distance_to_E}\n", " return ((p1, p3, t)\n", " for p1 in D\n", " for p2 in racetrack.neighbors(p1) if racetrack[p2] == '#'\n", " for p3 in racetrack.neighbors(p2)\n", " if p3 in D and (t := D[p1] - D[p3] - 2) >= minimum_savings)" ] }, { "cell_type": "code", "execution_count": 228, "id": "1bbd8b72-c503-4384-aaea-a5bed45a4491", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 20.1: .029 seconds, answer 1343 ok" ] }, "execution_count": 228, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(20.1, 1343, lambda:\n", " quantify(cheats(racetrack, 100)))" ] }, { "cell_type": "markdown", "id": "0f86c3a4-47e7-4731-8acf-9133b3e41838", "metadata": {}, "source": [ "At first I had a puzzling **bug**. I had a lot of confidence in my code, but AoC said I had the wrong answer. I addressed it by carefully re-reading the puzzle description. Then I realized my mistake: I didn't count the 2 picoseconds of cheating as part of the total time. I fixed that by inserting the \"`-2`\" in the last line of `cheats`. In the process of carefully re-reading, I realized that the path through the grid is a single path; I didn't need a queue of points in `dijkstra`; the queue will always be just one point. But changing it wouldn't have a big effect on efficiency, so I'll keep it as is.\n", "\n", "\n", "\n", "\n", "### Part 2: How many big cheats would save you at least 100 picoseconds?\n", "\n", "In Part 2 you can use a much **bigger cheat**, of up to 20 steps (and thus 20 picoseconds). But you can still only use one cheat. I'll tackle this by looking at all points in a neighborhood of radius 20 from each starting point on the path." ] }, { "cell_type": "code", "execution_count": 230, "id": "e5f15182-68df-4831-b061-660413fdbae4", "metadata": {}, "outputs": [], "source": [ "def big_cheats(racetrack, minimum_savings=1, radius=20) -> Iterable[Tuple[Point, Point, int]]:\n", " \"\"\"All ways of cheating by taking up to `radius` steps through walls and back to the track,\n", " as long as they save at lease `minimum_savings` picoseconds\"\"\"\n", " D = dijkstra(racetrack, the(racetrack.findall('E'))) # A dict of {sposition: distance_to_E}\n", " return ((p1, p2, t)\n", " for p1 in D\n", " for p2 in neighborhood(p1, radius)\n", " if p2 in D and (t := D[p1] - D[p2] - taxi_distance(p1, p2)) >= minimum_savings)\n", "\n", "def neighborhood(point, radius) -> List[Point]:\n", " \"\"\"All points within `radius` of `point` (using taxi distance).\"\"\"\n", " (x, y) = point\n", " return [(x + dx, y + dy) \n", " for dx in range(-radius, radius + 1)\n", " for dy in range(-(radius - abs(dx)), radius - abs(dx) + 1)]" ] }, { "cell_type": "code", "execution_count": 231, "id": "aa9ea31c-26a3-411f-b0ae-df37bea3c8c0", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 20.2: .768 seconds, answer 982891 ok" ] }, "execution_count": 231, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(20.2, 982891, lambda:\n", " quantify(big_cheats(racetrack, 100, radius=20)))" ] }, { "cell_type": "markdown", "id": "0022ec12-5359-455f-ace8-c8615d7cd1d2", "metadata": {}, "source": [ "This solution is backwards-compatible with Part 1:" ] }, { "cell_type": "code", "execution_count": 233, "id": "332e9c72-db9a-4b90-a649-45f7bf955e84", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 20.1: .022 seconds, answer 1343 ok" ] }, "execution_count": 233, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(20.1, 1343, lambda:\n", " quantify(big_cheats(racetrack, 100, radius=2)))" ] }, { "cell_type": "markdown", "id": "6f136dce-d68b-47b1-9b2e-31293f73ed6c", "metadata": {}, "source": [ "# [Day 21](https://adventofcode.com/2024/day/21): Keypad Conundrum\n", "\n", "Today's puzzle is simple: unlock the door to Santa's starship by entering some lock codes on a **numeric keypad**. Here are the lock codes:" ] }, { "cell_type": "code", "execution_count": 235, "id": "9d0eea9f-9d8f-4410-97ec-13d8b136925b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 5 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "839A\n", "169A\n", "579A\n", "670A\n", "638A\n" ] } ], "source": [ "codes = parse(21)" ] }, { "cell_type": "markdown", "id": "adeabd3b-f534-4457-ab7e-3f057c34600f", "metadata": {}, "source": [ "### Part 1: What is the sum of the complexities of the five codes on your list?\n", "\n", "We know the codes, so what is the difficulty? It turns out the numeric keypad is inaccessible, so we have to get a **robot** to press the buttons, and we have to command the robot's arm by pressing some buttons on a **remote control directional keypad**: arrow keys to move the arm, and the \"`A`\" (activate) button to make the arm press the button it is currently pointing at. Here are the two keypads:\n", "\n", " +---+---+---+ +---+---+\n", " | 7 | 8 | 9 | | ^ | A |\n", " +---+---+---+ +---+---+---+\n", " | 4 | 5 | 6 | | < | v | > |\n", " +---+---+---+ +---+---+---+\n", " | 1 | 2 | 3 |\n", " +---+---+---+\n", " | 0 | A |\n", " +---+---+\n", " \n", "Long story short: it turns out the robot's remote keypad is *also* inaccessible, and we end up needing **three robots**, each pressing buttons on the next keypad, so there are **four levels** of button pressing all together:\n", "\n", "- You press some buttons on Robot 3's remote keypad (e.g. >...)\n", "- Robot 2 presses some buttons on Robot 1's remote keypad (e.g. \" and \"<\", or both \"^\" and \"v\", because that's just wasteful.\n", "- Each of these paths have the same length, so if we were directly pressing Robot 1's remote control, any path would do.\n", "- However, it might take the robot at the next level a different number of presses to command each of these paths.\n", "- To command \"^^^\" the next robot has to command this robot to the \"^\" key and then press \"AAA\". If the \"^\" and \"<\" keys are interspersed, the commands will take more buttons, because there will be navigation between each \"A\". Therefore, I will consider at most two paths: all the horizontal arrows first, or all the vertical arrows first.\n", "- Fortunately, whenever there is a button press on the numeric keypad, we know that *all* the robots are on \"A\", because each one must have activated a button press to make the chain of presses happen.\n", "- Therefore, the parts of the problem are *decomposible*: at any level, the minimum number of keypresses to, say, \"get the robot arm from the `^` to the `A` and press it\" will be the same, regardless of what keypresses come before or after. The order doesn't matter on this level, although it may affect other levels.\n", "- I could represent a keypad with my `Grid` class, but I don't need what `Grid` provides, all I need is a way to look up the (x, y) location of each key. I'll also explicitly save the (x, y) position of the forbidden empty corner as `keypad.forbidden`." ] }, { "cell_type": "code", "execution_count": 237, "id": "779c6b4c-ceb0-49ac-96f2-4700835c70ea", "metadata": {}, "outputs": [], "source": [ "class Keypad(dict):\n", " \"\"\"A representation of the key positions in a keypad.\"\"\"\n", " def __init__(self, rows):\n", " self.update({char: (x, y) for (y, row) in enumerate(rows) for (x, char) in enumerate(row)})\n", " self.forbidden = self['_']\n", " del self['_']\n", "\n", "numeric_keypad = Keypad(['789', '456', '123', '_0A'])\n", "remote_keypad = Keypad(['_^A', ''])" ] }, { "cell_type": "markdown", "id": "486ae303-36cf-4750-965b-3402eec2b625", "metadata": {}, "source": [ "Now I can compute the remote keypad presses that are required to command a robot to move from `key1` to `key2` and press `key2`. There will be either one or two possible paths, depending on whether one of them hits the `forbidden` corner." ] }, { "cell_type": "code", "execution_count": 239, "id": "c915ada2-9dfe-42fe-bd08-855ff5d0e837", "metadata": {}, "outputs": [], "source": [ "def possible_paths(key1, key2, keypad) -> Iterable[str]:\n", " \"\"\"Should we try, e.g. \">>^^A\" or \"^^>>A\", or both, to command\n", " a move from key1 to key2 and press key2 on the target keypad?\"\"\"\n", " pos1, pos2 = keypad[key1], keypad[key2]\n", " (dx, dy) = sub(pos2, pos1)\n", " horizontal = abs(dx) * ('>' if dx > 0 else '<')\n", " vertical = abs(dy) * ('v' if dy > 0 else '^')\n", " if add(pos1, (dx, 0)) != keypad.forbidden:\n", " yield horizontal + vertical + 'A'\n", " if add(pos1, (0, dy)) != keypad.forbidden: \n", " yield vertical + horizontal + 'A'" ] }, { "cell_type": "markdown", "id": "e9243a77-8466-4aea-bbc9-b10af141e2fb", "metadata": {}, "source": [ "My first **bug** on today's puzzle was multiplying the arrow character by `dx` instead of `abs(dx)`. Did you know that `-2 * '>'` is the empty string, and not an error? " ] }, { "cell_type": "markdown", "id": "74f1f872-5c0c-4baa-a941-d910dc9c1048", "metadata": {}, "source": [ "We will need to compute the **complexity** of a code for our final answer:" ] }, { "cell_type": "code", "execution_count": 242, "id": "1e2e8c59-744f-4f36-9251-c8ea5fd60aed", "metadata": {}, "outputs": [], "source": [ "def complexity(code, levels=4): \n", " \"\"\"The integer part of the code times the niminimum number of key presses.\"\"\"\n", " return int(cat(digits(code))) * min_keypresses(code, levels)" ] }, { "cell_type": "markdown", "id": "975b5719-9afc-4b0a-9e07-c1c2b38059f7", "metadata": {}, "source": [ "And here's how we compute the minimum number of keypresses:\n", "- `total_presses` determines the minimum number of keypresses required to execute a key sequence.\n", " - At level 1, this means just typing the code on the numeric keypad.\n", " - At level 2 and up, it means the number of remote keypad presses needed to command a robot below to execute the key sequence. \n", "- `one_button_min_keypresses` is similar, but it determines the minimum number of keypresses to command just one thing: move from one key to another and press it. We get efficiency from the `@cache` decorator on this method, so even though there are many movements between keys at all levels, we only need to compute each of them once. " ] }, { "cell_type": "code", "execution_count": 244, "id": "eca187c8-4457-4c06-a5a4-d4fd19858325", "metadata": {}, "outputs": [], "source": [ "def min_keypresses(code: str, levels: int) -> int:\n", " \"\"\"The smallest possible number of keypresses (on the top level) to type `code` \n", " on the numeric keypad, if there are `levels` of button-pressers \n", " (all but one of them using the remote keypad).\"\"\"\n", " \n", " def total_presses(keysequence: str, level: int) -> int:\n", " \"\"\"Total presses required to command `keysequence` from this level.\"\"\"\n", " if level == 1:\n", " return len(keysequence) # Just press the code buttons\n", " else:\n", " return sum(one_button_min_keypresses(key1, key2, level)\n", " for key1, key2 in sliding_window('A' + keysequence, 2))\n", " \n", " @cache\n", " def one_button_min_keypresses(key1: Char, key2: Char, level: int) -> int:\n", " \"\"\"The minimum number of presses to command a press of key2, starting from key1.\"\"\"\n", " keypad = numeric_keypad if level == levels else remote_keypad\n", " return min(total_presses(path, level - 1) \n", " for path in possible_paths(key1, key2, keypad))\n", "\n", " return total_presses(code, levels)" ] }, { "cell_type": "markdown", "id": "696ad2eb-244a-4ed1-ac0b-d40a0556090f", "metadata": {}, "source": [ "Here is the answer, which turns out to be a fairly small number:" ] }, { "cell_type": "code", "execution_count": 246, "id": "393a8c6b-6a1c-4495-aad5-92f48711fbf1", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 21.1: .000 seconds, answer 205160 ok" ] }, "execution_count": 246, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(21.1, 205160, lambda:\n", " sum(map(complexity, codes)))" ] }, { "cell_type": "markdown", "id": "08d46094-0ebf-4c84-8ec4-b563630b2458", "metadata": {}, "source": [ "I was encountering other **bugs** (off-by-one errors, maybe?), so I wrote some code that explicitly built a cache of path lengths. Once I did that I understood the puzzle better and was able to easily write the code above with the cache handled by the decorator, which I think is neater." ] }, { "cell_type": "markdown", "id": "2a16c8f8-e1e5-47f8-b6c6-4a7500a457e6", "metadata": {}, "source": [ "### Part 2: With 27 levels, what is the sum of the complexities of the five codes on your list?\n", "\n", "As I suspected, Part 2 gets us into a [ludicrous](https://www.youtube.com/watch?v=oApAdwuqtn8) number of button presses. The problem is the same, but now there are **27** levels, not **4**. No new code, just sum the complexity again:" ] }, { "cell_type": "code", "execution_count": 249, "id": "563c5959-692d-4368-8c0b-469fa0142678", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 21.2: .004 seconds, answer 252473394928452 ok" ] }, "execution_count": 249, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(21.2, 252473394928452, lambda:\n", " sum(complexity(code, levels=27) for code in codes))" ] }, { "cell_type": "markdown", "id": "56db891e-56c4-4f0a-bab8-545c2ccdbb2c", "metadata": {}, "source": [ "### Part 3: Verification and Exploration\n", "\n", "We know the sum of the complexities, but how many button presses are there?" ] }, { "cell_type": "code", "execution_count": 251, "id": "f2d29a66-5420-4fc1-8586-1570ed5ac0a8", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "439646398242" ] }, "execution_count": 251, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sum(min_keypresses(code, levels=27) for code in codes)" ] }, { "cell_type": "markdown", "id": "1cf2d848-2f43-48dc-8862-493cebd94558", "metadata": {}, "source": [ "If we could press one button per millisecond, it would take [**14 years**](https://www.google.com/search?q=439646398242+milliseconds+in+years) to do this number of button presses.\n", "\n", "Below are some assertions that serve as unit tests and as examples of usage:" ] }, { "cell_type": "code", "execution_count": 253, "id": "4d8c8659-52d3-4349-8465-7003e880502f", "metadata": {}, "outputs": [], "source": [ "assert list(possible_paths('A', '7', numeric_keypad)) == ['^^^<vvvA', 'vvv>A']\n", "assert list(possible_paths('v', 'A', remote_keypad)) == ['>^A', '^>A']\n", "\n", "assert list(sliding_window('A029A', 2)) == ['A0', '02', '29', '9A']\n", "\n", "assert min_keypresses('029A', 1) == 4 # \"029A\"\n", "assert min_keypresses('029A', 2) == 12 # \"^^AvvvA\"\n", "assert min_keypresses('029A', 3) == 28 # \"v<>^AAvA<^AA>A^A\"" ] }, { "cell_type": "markdown", "id": "29c33a82-0baf-41fd-807f-f7e955b1706a", "metadata": {}, "source": [ "I considered representing a key sequence as a `Counter` of one button presses. So we would have\n", "\n", " min_keypresses('029A', 1) == Counter({'02': 1, '29': 1, '9A': 1})\n", " min_keypresses('029A', 2) == Counter({'^A': 2, 'vv': 2, '': 1, '>^': 1, '^^': 1, 'Av': 1, 'vA': 1})\n", "\n", "This would take slightly longer to compute, but would give a more informative answer. But I guessed (correctly) that Part 2 would only be interested in the total number of key presses, not the details." ] }, { "cell_type": "markdown", "id": "ab5218d4-3c0c-47d8-a105-d0dbced92cd4", "metadata": {}, "source": [ "# [Day 22](https://adventofcode.com/2024/day/22): Monkey Market\n", "\n", "Today we are introduced to the monkey exchange market. The monkeys are **buyers** of hiding spots, offering **bananas** as payment. We need bananas, and fortunately we have many hiding spots to sell. Each monkey has a **secret number** (today's input):" ] }, { "cell_type": "code", "execution_count": 256, "id": "2c1e7612-4ec5-4ce1-b591-5c3a14f8ea61", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 1685 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "9524047\n", "7448470\n", "4573369\n", "4782321\n", "14221799\n", "5609429\n", "16652319\n", "2515459\n", "...\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Parsed representation ➜ 1685 ints:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "9524047\n", "7448470\n", "4573369\n", "4782321\n", "14221799\n", "5609429\n", "16652319\n", "2515459\n", "...\n" ] } ], "source": [ "secrets = parse(22, int)" ] }, { "cell_type": "markdown", "id": "b7f4cf5f-0e07-4e61-88ce-c3dfd6e3f0c8", "metadata": {}, "source": [ "### Part 1: What is the sum of the 2000th secret number generated by each buyer?\n", "\n", "Each buyer's secret number changes on each time step. There is a detailed process for generating the next secret number from the previous secret number, involving dividing, multiplying, XOR-ing, and taking modulos. We are asked for the sum of each buyer's 2000th next secret number. Easy enough:" ] }, { "cell_type": "code", "execution_count": 258, "id": "3807adbc-261a-4108-88ba-6e2b061526b5", "metadata": {}, "outputs": [], "source": [ "def nth_secret(secret: int, n=2000) -> int:\n", " \"\"\"Compute the `n`th next secret number after this secret number.\"\"\"\n", " for _ in range(n):\n", " secret ^= (secret * 64) % 16777216\n", " secret ^= (secret // 32) % 16777216\n", " secret ^= (secret * 2048) % 16777216\n", " return secret" ] }, { "cell_type": "code", "execution_count": 259, "id": "fce754cd-f6da-4e7d-b406-3314c9c28ca8", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 22.1: .339 seconds, answer 14273043166 ok" ] }, "execution_count": 259, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(22.1, 14273043166, lambda:\n", " sum(map(nth_secret, secrets)))" ] }, { "cell_type": "markdown", "id": "80fea986-b9f3-4184-94b5-5fda551ce115", "metadata": {}, "source": [ "I note that all the the integer constants in `nth_secret` are powers of 2, so they could be replaced by bit operations. I wonder if I will have to analyze exactly what is going on with these bit operations for Part 2. \n", "\n", "### Part 2: What is the most bananas you can get?\n", "\n", "Knowing the timeline of secret numbers is not the whole story. Each buyer monkey has a **price** in bananas that they are offering at each time step. The price is the ones digit of their secret number (e.g., for secret number 9524047 the price is 7 bananas). Each monkey wants to buy exactly one hiding spot. We would like to wait for the highest price offering from each monkey, but we don't speak monkeese. We do have a translator who speaks a few words, but unfortunately, the translator doesn't know enough to help us sell as soon as the price hits 9 (or 8, or whatever). All we can do is the following:\n", "\n", "- We tell the translator to watch for a specific sequence of four deltas in price in the timeline of any monkey.\n", "- For example, we say to watch for the deltas (**+1, -2, 0, +3**).\n", "- Say the prices for the first monkey are (3, 3, 3, 5, 6, 4, 4, 7, ...)\n", "- Then the deltas are (0, 0, +2, **+1, -2, 0, +3**, ...)\n", "- That matches our 4 deltas, so we immediately sell our hiding spot to the monkey for the current price, 7 bananas.\n", "- That monkey is now done and won't buy again.\n", "- The translator simultaneously monitors all the monkeys, looking for (**+1, -2, 0, +3**).\n", "\n", "Our task is to get the most possible bananas under these constraints. \n", "\n", "Can we brute-force it? Each delta is between -9 and +9, so the number of possible 4-tuples of deltas is fairly small, less than 105 (5 digits give you all the 4-deltas, but some are duplicates). However, if for each possible 4-tuple of deltas I looked at all 2000 steps of all 1685 monkeys, then 105 ✖️ 2000 ✖️ 1685 is more than 300 billion, which is a medium-large number. So instead I'll define `total_bananas` to do this:\n", "\n", " Maintain a dict of {4-tuple: total bananas gained}, initially empty\n", " For each monkey:\n", " For each unique 4-tuple of price deltas in the monkey's price timeline:\n", " increment the total number of bananas for this 4-tuple by the current price\n", "\n", "I'll also define `price_timeline` to give the timeline of unique 4-tuples for one monkey, making sure to only include the first time each 4-tuple appears. In `price_timeline` I could call `nth_secret(secret, 1)`, but I decided to make a separate `next_secret` function. I probably should have done that for Part 1. Finally, take the maximum of the numbers of bananas, across all the recorded 4-tuples." ] }, { "cell_type": "code", "execution_count": 261, "id": "cbbb4793-b13d-4a95-ba03-673b3ebaa229", "metadata": {}, "outputs": [], "source": [ "Deltas = Tuple[int, int, int, int]\n", "\n", "def total_bananas(secrets: Ints, n=2000) -> Dict[Deltas, int]:\n", " \"\"\"Pairs of {delta-4-tuple: total_bananas_gained} over all secret numbers,\n", " for the first `n` 4-tuples of deltas.\"\"\"\n", " bananas = defaultdict(int) # {deltas: total_bananas}\n", " for secret in secrets: # For each monkey ...\n", " for deltas, price in price_timeline(secret, n).items():\n", " bananas[deltas] += price\n", " return bananas\n", "\n", "def price_timeline(secret, n=2000) -> Dict[Deltas, int]:\n", " \"\"\"Each {delta-4-tuple: price} in the timeline of this secret number, \n", " for `n` steps, but only the first time each unique delta-4-tuple appears.\"\"\"\n", " timeline = {} # {delta-4-tuple: price} pairs\n", " deltas = () # The 4 most recent price deltas \n", " price = secret % 10 # Initial price\n", " for _ in range(n):\n", " secret = next_secret(secret)\n", " price, previous_price = secret % 10, price\n", " deltas = (*deltas[-3:], price - previous_price)\n", " if len(deltas) == 4 and deltas not in timeline:\n", " timeline[deltas] = price\n", " return timeline\n", "\n", "def next_secret(secret: int) -> int:\n", " \"\"\"Compute the next secret number after this secret number.\"\"\"\n", " secret ^= (secret * 64) % 16777216\n", " secret ^= (secret // 32) % 16777216\n", " secret ^= (secret * 2048) % 16777216\n", " return secret" ] }, { "cell_type": "code", "execution_count": 262, "id": "34eaf7fe-fe9b-4858-b1e8-e4c3713ea093", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 22.2: 1.157 seconds, answer 1667 ok" ] }, "execution_count": 262, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(22.2, 1667, lambda:\n", " max(total_bananas(secrets).values()))" ] }, { "cell_type": "markdown", "id": "bfc067a9-e6de-4390-bf78-3da283d68465", "metadata": {}, "source": [ "### Part 3: Exploration\n", "\n", "I'm surprised the answer is so low; less than one banana per monkey. I would have guessed more like 4 per monkey. And yet it is the correct answer. Let's investigate. First, what is the best 4-tuple of deltas?" ] }, { "cell_type": "code", "execution_count": 264, "id": "a2da8c78-d240-4c52-a83a-f3599f4f69a4", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(-3, 2, -1, 2)" ] }, "execution_count": 264, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bananas = total_bananas(secrets)\n", "best_deltas = max(bananas, key=bananas.get) \n", "best_deltas" ] }, { "cell_type": "markdown", "id": "1e1c48b3-bfff-4e5d-8f6f-9c9fff5f6baa", "metadata": {}, "source": [ "Now, how many monkeys had this 4-tuple in their timeline, and what prices did each buy at? " ] }, { "cell_type": "code", "execution_count": 266, "id": "9de3f365-c546-494a-a18c-2ae58d88792b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "271 monkeys (16%) bought, total price 1667, mean 6.2\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "Counter({9: 50, 3: 43, 8: 42, 7: 37, 4: 34, 5: 33, 6: 32})" ] }, "execution_count": 266, "metadata": {}, "output_type": "execute_result" } ], "source": [ "prices = [p for secret in secrets for d, p in price_timeline(secret).items() if d == best_deltas]\n", "print(f'{len(prices)} monkeys ({len(prices)/len(secrets):.0%}) bought, '\n", " f'total price {sum(prices)}, mean {mean(prices):3.1f}')\n", "plt.hist(prices, rwidth=0.9, bins=[x+0.5 for x in range(10)]); plt.show()\n", "Counter(prices)" ] }, { "cell_type": "markdown", "id": "7fac136e-b676-49c9-91f1-a209b9ef53fa", "metadata": {}, "source": [ "We do pretty well on prices, getting a lot of 8 and 9 prices, and nothing less than 3, but only 271 monkeys (16%) every get the `best_deltas` sequence.\n", "\n", "Do any 4-tuples show up in more timelines?" ] }, { "cell_type": "code", "execution_count": 268, "id": "4fc191f9-62d8-47ef-a571-8c0541e25f4d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[((0, -1, 1, -1), 322),\n", " ((-1, 0, 0, 0), 315),\n", " ((0, -1, 0, 0), 315),\n", " ((-1, 0, 1, 0), 312),\n", " ((1, -2, 1, 0), 303),\n", " ((0, 1, -1, 0), 302),\n", " ((0, 0, 0, 0), 297),\n", " ((0, 1, 0, 0), 295),\n", " ((0, 1, 0, -1), 295),\n", " ((1, -1, 0, 0), 292)]" ] }, "execution_count": 268, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Counter(flatten(map(price_timeline, secrets))).most_common(10)" ] }, { "cell_type": "markdown", "id": "1fa741c6-ecf7-4459-a017-ffa574352d7e", "metadata": {}, "source": [ "Yes, but not by that much: 322 monkeys is 19% more than the 271 monkeys for the best 4-tuple, but the total number of bananas is less:" ] }, { "cell_type": "code", "execution_count": 270, "id": "bbd329a0-309c-4c81-a780-6bd97a95f652", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1341" ] }, "execution_count": 270, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bananas[(0, -1, 1, -1)]" ] }, { "cell_type": "markdown", "id": "58c39447-f458-4254-bb4c-144effd3f23c", "metadata": {}, "source": [ "I waas also curious about exactly how many possible *n*-tuples of deltas there are for any sequence of *n* digits (not just from the secrets):" ] }, { "cell_type": "code", "execution_count": 272, "id": "a2945c44-00f7-4c88-9b6e-747d9563034e", "metadata": {}, "outputs": [], "source": [ "def all_deltas(digits=range(10), n=4) -> Counter[Tuple[int, ...]]:\n", " \"\"\"What `n`-tuples of deltas are possible for all sequences of `n`+1 `digits`,\n", " and how many ways can each of them occur?\"\"\"\n", " sequences = cross_product(digits, repeat=n+1)\n", " return Counter(tuple(seq[i + 1] - seq[i] for i in range(n))\n", " for seq in sequences)" ] }, { "cell_type": "markdown", "id": "4e8e0ea9-b617-43fc-83dc-767511ce63a6", "metadata": {}, "source": [ "First a small example, with only two digits:" ] }, { "cell_type": "code", "execution_count": 274, "id": "936bfa40-726a-4ddd-8033-8a50fa09b9ea", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Counter({(0, 0, 0): 2,\n", " (0, 0, 1): 1,\n", " (0, 1, -1): 1,\n", " (0, 1, 0): 1,\n", " (1, -1, 0): 1,\n", " (1, -1, 1): 1,\n", " (1, 0, -1): 1,\n", " (1, 0, 0): 1,\n", " (-1, 0, 0): 1,\n", " (-1, 0, 1): 1,\n", " (-1, 1, -1): 1,\n", " (-1, 1, 0): 1,\n", " (0, -1, 0): 1,\n", " (0, -1, 1): 1,\n", " (0, 0, -1): 1})" ] }, "execution_count": 274, "metadata": {}, "output_type": "execute_result" } ], "source": [ "all_deltas(digits=(0, 1), n=3)" ] }, { "cell_type": "markdown", "id": "bf3f03a4-c9ea-4429-82a4-3f54b7846ce0", "metadata": {}, "source": [ "With 2 digits there are 24 sequences of length 4 that make (24 - 1) unique delta 3-tuples, because the sequence (0, 0, 0, 0) and (1, 1, 1, 1) both yield the deltas (0, 0, 0). \n", "\n", "Now we try with 10 digits, for tuples of length 1 to 5:" ] }, { "cell_type": "code", "execution_count": 276, "id": "2bb368b8-d5e7-431c-bd2c-19aa41983b8d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{1: 19, 2: 271, 3: 3439, 4: 40951, 5: 468559}" ] }, "execution_count": 276, "metadata": {}, "output_type": "execute_result" } ], "source": [ "{n: len(all_deltas(digits=range(10), n=n)) for n in range(1, 6)}" ] }, { "cell_type": "markdown", "id": "47add4c5-499a-4c6f-a148-74093a72e3c7", "metadata": {}, "source": [ "This sequence of integers, 19, 271, 3439, 40951, 468559 [**appears**](https://oeis.org/search?q=+1%2C+19%2C+271%2C+3439%2C+40951&language=english&go=Search) in the Online Encyclopedia of Integer Sequences (OEIS), but it is not described as having anything to do with deltas, but rather as 10*n* - 9*n*." ] }, { "cell_type": "markdown", "id": "bd6330b8-9ddd-4d58-9314-83b47cb2fb78", "metadata": {}, "source": [ "# [Day 23](https://adventofcode.com/2024/day/23): LAN Party\n", "\n", "We see that there is a LAN party scheduled for today. Our input is a network map of bidirectional connections between computers:" ] }, { "cell_type": "code", "execution_count": 279, "id": "85f5b145-8c5e-448c-8b45-ad5750252ff2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 3380 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "ht-nz\n", "pt-uj\n", "nr-me\n", "qq-up\n", "zr-pa\n", "ly-wv\n", "ei-ry\n", "sm-md\n", "...\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Parsed representation ➜ 3380 tuples:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "('ht', 'nz')\n", "('pt', 'uj')\n", "('nr', 'me')\n", "('qq', 'up')\n", "('zr', 'pa')\n", "('ly', 'wv')\n", "('ei', 'ry')\n", "('sm', 'md')\n", "...\n" ] } ], "source": [ "network = parse(23, atoms)" ] }, { "cell_type": "markdown", "id": "a22e4214-736c-477a-810c-e77fcd68f1b4", "metadata": {}, "source": [ "### Part 1: Find all the sets of three inter-connected computers. How many contain at least one computer with a name that starts with t?\n", "\n", "We're asked to find three inter-connected computers, e.g., three computers A, B, C, such that A-B, B-C, and C-A are all in the list of connections (but connections are bidirectional, so either A-B or B-A could be in the input). A set where every node is connected to every other is called a **clique**. I'll represent the network **graph** as a dict of the form `{A: {B, C}}` to denote that node `A` is connected to `B` and `C`. The function `bidrected_graph` forms a graph from an iterable of (A, B) connections. Then `triples_starting_with` finds all cliques of size 3, where at least one of them starts with the given letter. The procedure could find duplicates (e.g. both (A, B, C) and (C, B, A), so I represent each triple as a frozenset and eliminate duplicates by returning the set of them. The answer for Part 1 is then the number of triples that start with `t`." ] }, { "cell_type": "code", "execution_count": 281, "id": "289d2325-1e58-41f5-b4b2-b90ae26e7887", "metadata": {}, "outputs": [], "source": [ "Clique = set # A clique is a set of nodes\n", "\n", "def bidirected_graph(connections) -> dict:\n", " \"\"\"A graph where, e.g., {A: {B, C}} means A is connected to B and C.\"\"\"\n", " graph = defaultdict(set)\n", " for (A, B) in connections:\n", " graph[A].add(B)\n", " graph[B].add(A)\n", " return graph\n", "\n", "def triples_starting_with(graph, start='') -> Set[Clique]:\n", " \"\"\"All cliques of 3 nodes, where at least one of them starts with the letter `start`.\"\"\"\n", " return {frozenset((A, B, C)) \n", " for A in graph if A.startswith(start)\n", " for B in graph[A]\n", " for C in graph[B] if C in graph[A]}" ] }, { "cell_type": "code", "execution_count": 282, "id": "6425577d-4ca9-45de-9698-cd9b026f7ce6", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 23.1: .001 seconds, answer 1170 ok" ] }, "execution_count": 282, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(23.1, 1170, lambda:\n", " len(triples_starting_with(bidirected_graph(network), 't')))" ] }, { "cell_type": "markdown", "id": "af420aeb-314b-4750-a424-7daad0ffdd62", "metadata": {}, "source": [ "### Part 2: What is the password to get into the LAN party?\n", "\n", "In Part 2 we are asked to figure out the password for the LAN party. We learn two important facts: \n", "- The LAN party is the maximum **clique** in the graph (the clique wwith the most members).\n", "- The **password** is formed by listing the names of all the computers in the LAN party in alphabetical order, separatied by commas.\n", "\n", "The function `maximum_clique` finds the largest clique; and `password` creates the password. The function `expand_clique` takes a clique, a node, and a graph. It expands out from the node, recursively looking for and adding any other nodes that should be added to the clique, finally returning the clique. " ] }, { "cell_type": "code", "execution_count": 284, "id": "c497adf7-caee-4ced-9d62-0a589879b460", "metadata": {}, "outputs": [], "source": [ "def maximum_clique(graph) -> Clique: \n", " \"\"\"The clique in `graph` with the most members.\"\"\"\n", " return max([expand_clique({A}, A, graph) for A in graph], key=len)\n", " \n", "def expand_clique(clique, A, graph) -> Clique:\n", " \"\"\"Expand out from node A, adding nodes to `clique` as long as they form a clique.\"\"\"\n", " for B in graph[A]:\n", " if B not in clique and clique.issubset(graph[B]):\n", " clique.add(B)\n", " expand_clique(clique, B, graph)\n", " return clique\n", "\n", "def password(clique) -> str: return ','.join(sorted(clique))" ] }, { "cell_type": "code", "execution_count": 285, "id": "0b5f08ac-18e2-4933-9737-cdbc842c5809", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 23.2: .003 seconds, answer bo,dd,eq,ik,lo,lu,ph,ro,rr,rw,uo,wx,yg ok" ] }, "execution_count": 285, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(23.2, 'bo,dd,eq,ik,lo,lu,ph,ro,rr,rw,uo,wx,yg', lambda:\n", " password(maximum_clique(bidirected_graph(network))))" ] }, { "cell_type": "markdown", "id": "859914ff-6ec5-4251-b3b9-bcd099f327c3", "metadata": {}, "source": [ "### Part 3: Exploration\n", "\n", "*Terminology note:* A **maximum clique** is a largest clique in the graph. A **maximal clique** is a clique to which no other node can be added to form a larger clique. Say there are 3 nodes that form a triangle. That's a clique. But if there is a fourth node that is connected to all three nodes in the triangle, then that too is a clique, and it means the triangle is not a maximal clique." ] }, { "cell_type": "markdown", "id": "197986f5-61b2-4e9e-929a-c1ba440b3550", "metadata": {}, "source": [ "*Second thoughts:* I got the right answer, and I coded it up quickly (for me) without errors, and it runs in under 1/10 second. But it is not the most efficient algorithm, because if a clique has *n* nodes, that clique will be re-generated *n* times. Since the maximum clique on my graph is only 13 members, that's not so bad, but don't use my algorithm on a graph with million-element cliques.\n", "\n", "I'm also not completely sure my algorithm handles all possible inputs. Consider the following network, where `{BCD}` means the three nodes form a (non-maximal) clique, and a dashed line means all nodes on each side are connected.\n", "\n", " {BCD}--{A}--{EF}\n", "\n", "The call to `expand_cliqe(A, ...)` might return either `{ABCD}` or `{AEF}`, so it might miss the maximum clique. For this example, if we missed on `A`, we would still get `{ABCD}` from `B` or `C` or `D`. But I can't quite prove there can't be some more complex configurations where my algorithm fails." ] }, { "cell_type": "markdown", "id": "88d8883e-922a-4d08-bbec-a01d5bf225ef", "metadata": {}, "source": [ "# [Day 24](https://adventofcode.com/2024/day/24): Crossed Wire\n", "\n", "Today we are trying to help the historian to debug a malfunctioning **monitoring device**, which consistes of some wires and logic gates. Some of the wires have been misrouted. The day's input described the connections in the device. There are two types of inputs: an input wire is described with its name and its bit value: `x00: 1`, and a logic gate is described with the two input wire names, the operation, and the output wire name: `x00 AND y00 -> z00`.\n", "\n", "\n", "\n", "For now I'll just parse each line as a sequence of atoms: " ] }, { "cell_type": "code", "execution_count": 289, "id": "47421581-71df-4c72-a62e-c40d0596fdbb", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 313 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "x00: 1\n", "x01: 1\n", "x02: 0\n", "x03: 0\n", "x04: 0\n", "x05: 1\n", "x06: 0\n", "x07: 1\n", "...\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Parsed representation ➜ 313 tuples:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "('x00', 1)\n", "('x01', 1)\n", "('x02', 0)\n", "('x03', 0)\n", "('x04', 0)\n", "('x05', 1)\n", "('x06', 0)\n", "('x07', 1)\n", "...\n" ] } ], "source": [ "connections = parse(24, atoms)" ] }, { "cell_type": "markdown", "id": "354dd8da-2737-45c2-af8c-b4b30584ae9a", "metadata": {}, "source": [ "### Part 1: Simulate the system of gates and wires. What decimal number does it output on the wires starting with z?\n", "\n", "We can't just treat the device as a program where we execute statements in order, because in a statement like `z01 = bfn XOR y33`, the values of `bfn` and `y33` may not yet be determined. But we can execute *backwards*, as a [dataflow architecture](https://en.wikipedia.org/wiki/Dataflow_architecture). To go backwards we'll need a mapping from each output wire to where it comes from: either a bit value or a gate. I'll define `Device` as a subclass of `dict` where the keys are wire names and the values are either bits or gates." ] }, { "cell_type": "code", "execution_count": 291, "id": "43b29260-d912-4cfc-91ce-d303ec1c86df", "metadata": {}, "outputs": [], "source": [ "class Device(dict):\n", " \"\"\"A mapping of {wire_name: bit_value_or_gate}, assembled from a device specification.\"\"\"\n", " def __init__(self, lines: Tuple[Tuple]):\n", " for line in lines:\n", " match line: \n", " case (wire, bit): # e.g., ('x00', 1)\n", " self[wire] = bit\n", " case (x, op, y, wire): # e.g., ('y33', 'AND', 'x33', 'bfn')\n", " self[wire] = (x, op, y)" ] }, { "cell_type": "markdown", "id": "ff09bc35-43a4-45c1-bc00-c9cd6a1d7f69", "metadata": {}, "source": [ "Next, the function `simulate` does the dataflow computation. We start from the outputs (the wires whose first letter is `'z'`) and try to **get** their values. If the value is a bit, great, we got it. If the value is a gate, then we recursively **get** the values of both of the gate's input wires, and perform the gate's boolean operation on them. When we're done calculating all the output variables, the function `simulate` returns their values as a string of `'0'` or `'1'` characters." ] }, { "cell_type": "code", "execution_count": 293, "id": "a9a4780f-6033-452f-b49c-74b97c9e2440", "metadata": {}, "outputs": [], "source": [ "def simulate(device: Device) -> str:\n", " \"\"\"Use dataflow to get the values of the output bits of this device (as a \"01\" str).\"\"\"\n", " def get(w) -> int: \n", " match device[w]:\n", " case (x, op, y): return operators[op](get(x), get(y))\n", " case bit: return bit\n", " return cat(map(get, wires(device, 'z')))\n", "\n", "operators = dict(XOR=operator.xor, AND=min, OR=max)\n", "\n", "def wires(device: Device, letter: str) -> List[str]: \n", " \"\"\"The names of all the wires that start with the given letter, in sorted order.\"\"\"\n", " return sorted([w for w in device if w.startswith(letter)], reverse=True)" ] }, { "cell_type": "code", "execution_count": 294, "id": "72437439-dddf-4202-9944-36e796800304", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 24.1: .001 seconds, answer 36035961805936 ok" ] }, "execution_count": 294, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(24.1, 36035961805936, lambda:\n", " int(simulate(Device(connections)), base=2))" ] }, { "cell_type": "markdown", "id": "7ddc7897-5ff2-46bc-999d-302c92c137da", "metadata": {}, "source": [ "At first I fell victim to one of the [**classic blunders**](https://youtu.be/RWW6aDpUvbQ?si=0uvZFEYgY9i_441N): using the wrong [**endianness**](https://en.wikipedia.org/wiki/Endianness) of my bits. After re-reading the puzzle description, I fixed the **bug** by adding `reverse=True` to `wires`." ] }, { "cell_type": "markdown", "id": "c42bd211-b999-4dd8-9e34-aebf042e55e4", "metadata": {}, "source": [ "### Part 2: What do you get if you sort the names of the eight wires involved in a swap and then join those names with commas?\n", "\n", "In Part 2 we are told that the system is attempting to do addition: treating the `x` wires as a binary number and the `y` wires as another binary number, and computing their sum and outputting it to the `z` wires. However, four pairs of output wires are miswired: they are swapped with each other. Our job is to find all eight wires. For example, one pair might be `(z01, z02)` if we detect the following fault:\n", "\n", " Faulty gates: Corrected gates:\n", " a XOR b -> z01 a XOR b -> z02\n", " c XOR d -> z02 c XOR d -> z01\n", "\n", "I have four ideas of how to proceed, with arguments against each of them:\n", "1) **Plot** the circuit diagram and examine it to see if anything looks funny.\n", " - Making a nice plot would be hard; I'm worried that wires in a circuit diagram cross each other; that could get messy.\n", "2) **Examine properties** of the structure of the device and look for something that breaks the pattern.\n", " - For example, make a table of circuit depths of each output wire, and see if one looks wrong.\n", " - This might help me, as a detective, uncover the answer, but if I was given another input device I'd have to start all over.\n", "4) **Simulate** the circuit on known `z = x + y` examples (because we know how to add bits) and see where it goes wrong.\n", " - If I chose random numbers it might take a long time to isolate the faults.\n", " - It is easy to identify faulty output (`z`) values; trickier to identify faults in internal gates.\n", " - I could test the one-bit adders one at a time (with and without carry). But I don't know if that would always work.\n", "5) **Compare** a conventional adder to the circuit.\n", " - I know how an adder circuit is conventionally built; if our device is like that, we should be able to see where it goes wrong.\n", " - It could be that the device is a correct adder, but is built in a non-conventional way." ] }, { "cell_type": "markdown", "id": "3691add5-cd06-4b74-ac5a-7569a1ccb081", "metadata": {}, "source": [ "I started with approach (2). A simple thing to try is to look at all the gates that lead directly to the outputs:" ] }, { "cell_type": "code", "execution_count": 298, "id": "9021ad30-f505-4164-9feb-5af740632182", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "z45: nrv OR jsp\n", "z44: jsg XOR hks\n", "z43: gsk XOR fhk\n", "z42: cng XOR mwt\n", "z41: jhg XOR gfd\n", "z40: nns XOR jbd\n", "z39: vqf XOR fkq\n", "z38: sqj XOR wts\n", "z37: jgw OR rhh\n", "z36: rfq XOR hbh\n", "z35: djt XOR khf\n", "z34: jmv XOR nss\n", "z33: dts XOR wmq\n", "z32: rck XOR ftq\n", "z31: rms XOR sgf\n", "z30: pwp XOR nnn\n", "z29: tsk XOR hvc\n", "z28: msf XOR kdd\n", "z27: tvf XOR cmb\n", "z26: wkb XOR jkr\n", "z25: pfc XOR prp\n", "z24: gww XOR jmf\n", "z23: mcp XOR mkf\n", "z22: wwp XOR bvr\n", "z21: qpm XOR csw\n", "z20: bvw XOR hvn\n", "z19: y19 AND x19\n", "z18: qvq XOR hns\n", "z17: wrc XOR hbw\n", "z16: rvn XOR kbq\n", "z15: skh XOR rkt\n", "z14: cgg XOR rhf\n", "z13: jkm XOR dmp\n", "z12: htn XOR dtq\n", "z11: gkc AND qqw\n", "z10: kmr XOR rmb\n", "z09: wpb XOR kbb\n", "z08: rjs XOR tmg\n", "z07: qmb XOR qpc\n", "z06: jtg XOR cfn\n", "z05: whf XOR fds\n", "z04: jvf XOR jth\n", "z03: wvt XOR sbt\n", "z02: rvm XOR vdq\n", "z01: hjp XOR kjs\n", "z00: x00 XOR y00\n" ] } ], "source": [ "device = Device(connections)\n", "for z in wires(device, 'z'):\n", " print(f'{z}: {\" \".join(device[z])}')" ] }, { "cell_type": "markdown", "id": "aadf7dfc-32a1-4409-9f61-ae08741868ef", "metadata": {}, "source": [ "Right away I can see three anomalies: \n", "- `z37` has an OR gate instead of an XOR.\n", "- `z11` has an AND gate instead of an XOR.\n", "- `z19` connects directly to the inputs `x19` and `y19`; no other `z` does that (except `z00`, because it has no carry bit).\n", "\n", "I'm already 3/8 of the way there! I tried a few other things but didn't make progress, so I decided to try approach (4).\n", "\n", "Here's a picture of a (one-bit) full adder, made out of two half-adders and an OR gate. We have two XOR gates, two AND gates, and one OR gate for every output wire (except for `z00`, which doesn't have a carry bit so only needs a half-adder). \n", "\n", "![Adder from Wikipedia](https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhCXZpXA19TudYZz-S51V6WZ_b1HPAbA-uozACxQdnavllWn9oUrVwID5eOmtOhUhFHZZKadar5TY3os2H-Vs4uiCK92wEERCFSOAamOTwOZTQ_q034zdMUhSmxYNihUHWRIRVwLJVoR7Zo1u7-dPL9gysEifyvQqO8AnTvGv9oEAgkxTZMuVyNVN-D/w400-h245/nbit_1.png) \n", "\n", "Let's see if this matches the number of gates in our device:" ] }, { "cell_type": "code", "execution_count": 300, "id": "3b41a166-d33b-402b-971b-1dc1d33135ec", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Counter({'AND': 89, 'XOR': 89, 'OR': 44})" ] }, "execution_count": 300, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Counter(val[1] for val in device.values() if val not in (0, 1))" ] }, { "cell_type": "markdown", "id": "c1f072b2-8c7f-40b2-9712-d0fc0dee62e7", "metadata": {}, "source": [ "It does match, so I guess our device is probably implementing the conventional circuit layout. \n", " \n", "The first trouble I ran into was that the two inputs to a gate could be in either order. I will canonicalize this, so that the first input wire is always alphabetically before the second one. The function `canon` enforces this canonicalization. I'll redefine `Device` to use it, and also to cache the inverse mapping: from gates to **output** wires." ] }, { "cell_type": "code", "execution_count": 302, "id": "ec8d86d4-8caf-40f2-b516-c7da4acbda19", "metadata": {}, "outputs": [], "source": [ "class Device(dict):\n", " \"\"\"A mapping of {wire_name: bit_value_or_gate}, assembled from a device specification.\n", " Also caches the inverse as a dict under self.inverse.\"\"\"\n", " def __init__(self, lines: Tuple[Tuple]):\n", " for line in lines:\n", " match line: \n", " case (wire, bit): # e.g., ('x00', 1)\n", " self[wire] = bit\n", " case (x, op, y, out): # e.g., ('y33', 'AND', 'x33', 'bfn')\n", " self[out] = canon(x, op, y) # canonicalize order\n", " self.compute_outputs()\n", " \n", " def compute_outputs(self):\n", " \"\"\"Make a mapping {gate: output wire name}.\"\"\"\n", " self.outputs = {self[w]: w for w in self if self[w] not in (0, 1)} \n", " \n", "def canon(x, op, y) -> Tuple: \n", " \"\"\"The canonical ordering of the two input wires (and the operator).\"\"\"\n", " return (min(x, y), op, max(x, y))" ] }, { "cell_type": "markdown", "id": "47ef587b-d8de-401d-9015-e4b81e1eef96", "metadata": {}, "source": [ "Here's how I compare my circuit to the conventional adder.\n", " - For each bit from right to left, I start by finding the (`xi XOR yi`) gate (and I remember the carry bit as I go). \n", " - I then look for the second XOR in the full adder.\n", " - If I don't find it, I look backwards from `zi`, and swap wires to make things right.\n", " - I need to then trace through the carry bits.\n", " - (I thought I would have to look for more swaps with the carry bit, and I was going to code that in later, but I got the right answer.)" ] }, { "cell_type": "code", "execution_count": 304, "id": "7ed8f8e6-c3e1-4c22-b812-e1a201afec3d", "metadata": {}, "outputs": [], "source": [ "def find_swaps(device) -> Iterable[str]:\n", " \"\"\"For each bit position in the inputs, x and y, look forward for the\n", " XOR and AND gates they participate in, then look backwards from the \n", " corresponding z output, and see where they fail to match up,\n", " and swap wires accordingly, yielding each swapped wire.\"\"\"\n", " \n", " def output(x, op, y): return device.outputs.get(canon(x, op, y), None)\n", " \n", " for i in range(len(wires(device, 'x'))):\n", " x, y, z = [f'{v}{i:02d}' for v in 'xyz']\n", " if x == 'x00':\n", " carry = output(x, 'AND', y)\n", " else:\n", " a, b = carry, output(x, 'XOR', y)\n", " if not output(a, 'XOR', b):\n", " a2, op, b2, = device[z] # Look backwards from z to see if they hook up\n", " once = [w for w in (a, b, a2, b2) if [a, b, a2, b2].count(w) == 1]\n", " if len(once) == 2: # Wires that appear once in the two gates; they don't connect properly\n", " yield from swap(*once, device)\n", " elif output(a, 'XOR', b) != z:\n", " yield from swap(z, output(a, 'XOR', b), device)\n", " carry = output(carry, 'AND', output(x, 'XOR', y)) # The carry gets propagated through two gates\n", " carry = output(carry, 'OR', output(x, 'AND', y))\n", "\n", "def swap(a: str, b: str, device: dict) -> Set[str]:\n", " \"\"\"Swap wires `a` and `b` in device.\"\"\"\n", " device[a], device[b] = device[b], device[a]\n", " device.compute_outputs() # Recompute outputs after this swap\n", " return a, b" ] }, { "cell_type": "code", "execution_count": 305, "id": "e9b87c38-f67c-4948-9af6-251021747e9d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 24.2: .000 seconds, answer jqf,mdd,skh,wpd,wts,z11,z19,z37 ok" ] }, "execution_count": 305, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(24.2, 'jqf,mdd,skh,wpd,wts,z11,z19,z37', lambda:\n", " ','.join(sorted(find_swaps(Device(connections)))))" ] }, { "cell_type": "markdown", "id": "b8d3967e-3473-47b0-b1b8-687c56e49138", "metadata": {}, "source": [ "# [Day 25](https://adventofcode.com/2024/day/25): Code Chronicle\n", "\n", "We're trying to get into the Chief Historian's office, but the door is locked. We have the schematics of all the **locks** and **keys** on the floor we're on, and we need to see which key could fit which lock. A lock schematic has 5 columns of different length growing down from the top, and a key schematic has five columns growing up from the bottom. A key and a lock are a possible fit if none of the five lines overlap; that is, since the lock cylinder has a height of 7 units, it is a possible fit if none of the five columns has more than 7 total `'#'` marks for the lock and the key combined.\n", "\n", "We'll parse the schematics into paragraphs, where each paragraph is a list of lines." ] }, { "cell_type": "code", "execution_count": 307, "id": "f5971853-7139-4f17-bdc5-6c51e12a928d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Puzzle input ➜ 3999 strs:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "#####\n", "####.\n", "####.\n", "####.\n", "##.#.\n", "#....\n", ".....\n", "\n", "...\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "Parsed representation ➜ 500 lists:\n", "────────────────────────────────────────────────────────────────────────────────────────────────────\n", "['#####', '####.', '####.', '####.', '##.#.', '#....', '.....']\n", "['#####', '####.', '##.#.', '##.#.', '.#.#.', '.#.#.', '.....']\n", "['.....', '.....', '#..#.', '#..#.', '##.##', '#####', '#####']\n", "['#####', '###.#', '#.#.#', '#.#.#', '#.#..', '#....', '.....']\n", "['#####', '##.#.', '#..#.', '#..#.', '#..#.', '#..#.', '.....']\n", "['#####', '#####', '#####', '#.##.', '..##.', '...#.', '.....']\n", "['#####', '#.###', '...#.', '.....', '.....', '.....', '.....']\n", "['.....', '.....', '.....', '.#.#.', '##.#.', '#####', '#####']\n", "...\n" ] } ], "source": [ "schematics = parse(25, lines, sections=paragraphs)" ] }, { "cell_type": "markdown", "id": "3bece291-f0e6-463a-9ac9-401563c5184b", "metadata": {}, "source": [ "### Part 1: How many unique lock/key pairs fit together without overlapping in any column?\n", "\n", "This looks pretty easy:\n", "- The function `count_fits` will compute the answer. First it separates the schematics into locks and keys, transforming each one into a list of column heights. Then it counts how many key/lock combinations fit, trying every possibility.\n", "- The function `column_heights` takes a schematic, which is a list of rows, and applies the transpose, `T(schematic)`, to get a list of columns. Then it uses `count` to count the number of `'#'` characters in each column.\n", "- The function `can_fit` takes takes two lists of column counts and determines if any column has more than 7 total `'#'` characters.\n", "\n", "For example, the first lock is:\n", "\n", " ['#####', '####.', '####.', '####.', '##.#.', '#....', '.....']\n", "\n", "We transpose that to get a list of columns, \n", "\n", " ('######.', '#####..', '####...', '#####..', '#......')\n", "\n", "and count the number of `'#'` characters in each column:\n", "\n", " [6, 5, 4, 5, 1]\n", "\n", "Here is the code:" ] }, { "cell_type": "code", "execution_count": 309, "id": "5302ac58-91fc-475a-83d9-cea91457df3b", "metadata": {}, "outputs": [], "source": [ "def count_fits(schematics) -> List:\n", " \"\"\"Try all key/lock combinations and count how many fit each other.\"\"\"\n", " locks = [column_heights(s) for s in schematics if s[0] == '#####']\n", " keys = [column_heights(s) for s in schematics if s[0] != '#####']\n", " return quantify(can_fit(key, lock) for lock in locks for key in keys)\n", " \n", "def column_heights(schematic) -> List[int]:\n", " \"\"\"A counter of {column_number: (number of '#' in that column)}.\"\"\"\n", " return [column.count('#') for column in T(schematic)] # Remember, `T` is transpose\n", " \n", "def can_fit(key: Ints, lock: Ints): \n", " \"\"\"The key can fit the lock if the sum of the '#' count in each column is <= 7.\"\"\"\n", " return all(lock[c] + key[c] <= 7 for c in range(len(lock)))" ] }, { "cell_type": "code", "execution_count": 310, "id": "89c28b74-ed31-4bb5-b463-7177952a95ae", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Puzzle 25.1: .023 seconds, answer 3196 ok" ] }, "execution_count": 310, "metadata": {}, "output_type": "execute_result" } ], "source": [ "answer(25.1, 3196, lambda:\n", " count_fits(schematics))" ] }, { "cell_type": "markdown", "id": "ce1c8e04-5297-4798-969d-3cc9210bfd9a", "metadata": {}, "source": [ "And with that, **we're done!** \n", "\n", "Thanks, [**Eric Wastl**](https://adventofcode.com/2024/about), and congratulations for ten years of AoC!\n", "\n", "" ] }, { "cell_type": "markdown", "id": "3e78ac0f-5866-4620-8114-1b05b5c44de1", "metadata": {}, "source": [ "# Summary\n", "\n", "Here are all the puzzle answers and timings. I got all the puzzles correct! And I did it before midnight (my time) on December 25th, a rarity for me. \n", "\n", "The median run time is about 5 milliseconds, with 3 puzzles taking over a second, but none taking 2 seconds (barely!). I didn't count the time that `parse` takes, but that is less than a millisecond per day. Some people in the Rust subreddit were talking about completing the puzzles in less than 10 seconds of run time. I managed to do that, even with Python's slow interpreter rather than [Rust](https://www.rust-lang.org/)'s fast compiler. But others were talking about doing all 10 years of puzzles in less than 10 seconds, and I can't compete with that." ] }, { "cell_type": "code", "execution_count": 313, "id": "34813fc9-a000-4cd8-88ae-692851b3242c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Puzzle 1.1: .000 seconds, answer 1830467 ok\n", "Puzzle 1.2: .000 seconds, answer 26674158 ok\n", "Puzzle 2.1: .000 seconds, answer 257 ok\n", "Puzzle 2.2: .002 seconds, answer 328 ok\n", "Puzzle 3.1: .001 seconds, answer 156388521 ok\n", "Puzzle 3.2: .000 seconds, answer 75920122 ok\n", "Puzzle 4.1: .021 seconds, answer 2401 ok\n", "Puzzle 4.2: .015 seconds, answer 1822 ok\n", "Puzzle 5.1: .001 seconds, answer 5762 ok\n", "Puzzle 5.2: .001 seconds, answer 4130 ok\n", "Puzzle 6.1: .002 seconds, answer 5329 ok\n", "Puzzle 6.2: 1.980 seconds, answer 2162 ok\n", "Puzzle 7.1: .014 seconds, answer 1985268524462 ok\n", "Puzzle 7.2: .611 seconds, answer 150077710195188 ok\n", "Puzzle 8.1: .003 seconds, answer 220 ok\n", "Puzzle 8.2: .003 seconds, answer 813 ok\n", "Puzzle 9.1: .019 seconds, answer 6332189866718 ok\n", "Puzzle 9.2: .021 seconds, answer 6353648390778 ok\n", "Puzzle 10.1: .005 seconds, answer 744 ok\n", "Puzzle 10.2: .006 seconds, answer 1651 ok\n", "Puzzle 11.1: .002 seconds, answer 194482 ok\n", "Puzzle 11.2: .059 seconds, answer 232454623677743 ok\n", "Puzzle 12.1: .051 seconds, answer 1402544 ok\n", "Puzzle 12.2: .045 seconds, answer 862486 ok\n", "Puzzle 13.1: .000 seconds, answer 29598 ok\n", "Puzzle 13.2: .000 seconds, answer 93217456941970 ok\n", "Puzzle 14.1: .000 seconds, answer 216027840 ok\n", "Puzzle 14.2: 1.898 seconds, answer 6876 ok\n", "Puzzle 15.1: .029 seconds, answer 1563092 ok\n", "Puzzle 15.2: .042 seconds, answer 1582688 ok\n", "Puzzle 16.1: .149 seconds, answer 103512 ok\n", "Puzzle 16.2: .873 seconds, answer 554 ok\n", "Puzzle 17.1: .000 seconds, answer 2,1,0,1,7,2,5,0,3 ok\n", "Puzzle 17.2: .004 seconds, answer 267265166222235 ok\n", "Puzzle 18.1: .014 seconds, answer 344 ok\n", "Puzzle 18.2: .032 seconds, answer 46,18 ok\n", "Puzzle 19.1: .004 seconds, answer 242 ok\n", "Puzzle 19.2: .188 seconds, answer 595975512785325 ok\n", "Puzzle 20.1: .022 seconds, answer 1343 ok\n", "Puzzle 20.2: .768 seconds, answer 982891 ok\n", "Puzzle 21.1: .000 seconds, answer 205160 ok\n", "Puzzle 21.2: .004 seconds, answer 252473394928452 ok\n", "Puzzle 22.1: .339 seconds, answer 14273043166 ok\n", "Puzzle 22.2: 1.157 seconds, answer 1667 ok\n", "Puzzle 23.1: .001 seconds, answer 1170 ok\n", "Puzzle 23.2: .003 seconds, answer bo,dd,eq,ik,lo,lu,ph,ro,rr,rw,uo,wx,yg ok\n", "Puzzle 24.1: .001 seconds, answer 36035961805936 ok\n", "Puzzle 24.2: .000 seconds, answer jqf,mdd,skh,wpd,wts,z11,z19,z37 ok\n", "Puzzle 25.1: .023 seconds, answer 3196 ok\n", "\n", "Correct: 49/49\n", "\n", "Time in seconds: 0.005 median, 0.172 mean, 8.414 total.\n" ] } ], "source": [ "summary(answers)" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.7" } }, "nbformat": 4, "nbformat_minor": 5 }