From 8bc539db28c5e1ed14c684f50b4877d353a5ace3 Mon Sep 17 00:00:00 2001 From: Peter Norvig Date: Mon, 13 Dec 2021 13:07:47 -0800 Subject: [PATCH] Add files via upload --- ipynb/Advent-2020.ipynb | 1741 +++++++++++++++------------------------ 1 file changed, 675 insertions(+), 1066 deletions(-) diff --git a/ipynb/Advent-2020.ipynb b/ipynb/Advent-2020.ipynb index 30f0766..ed22dd8 100644 --- a/ipynb/Advent-2020.ipynb +++ b/ipynb/Advent-2020.ipynb @@ -8,13 +8,13 @@ "\n", "# Advent of Code 2020\n", "\n", - "This year I return to [Advent of Code](https://adventofcode.com), as I did in [2016](Advent+of+Code), [17](Advent+2017), and [18](Advent-2018.ipynb). Thank you, [Eric Wastl](http://was.tl/)! This notebook describes each day's puzzle only briefly; you'll have to look at the [Advent of Code website](https://adventofcode.com/2020) if you want the full details. Each puzzle has a part 1 and a part 2.\n", + "This year I return to [Advent of Code](https://adventofcode.com), as I did in [2016](Advent+of+Code), [17](Advent+2017), and [18](Advent-2018.ipynb). Thank you, [**Eric Wastl**](http://was.tl/)! You'll have to look at the [Advent of Code website](https://adventofcode.com/2020) if you want the full description of each puzzle; this notebook gives only a brief summary. \n", "\n", - "For each day from 1 to 25, I'll write **four pieces of code** with the following format (and perhaps some auxiliary code). For example, on day 3:\n", - "- `in3: List[str] = data(3)`: the day's input data, parsed into an appropriate form (here, a list of string lines). Some days the data is so small I just copy and paste it. But most days the data comes from a file, read via the function `data(day, parser, sep)`, which breaks the file into sections/records separated by `sep` (newline by default), and applies a `parser` to each section (default is to leave the section as a `str`).\n", - "- `def day3_1(nums): ... `: a function that takes the day's data as input and returns the answer for part 1.\n", - "- `def day3_2(nums): ... `: a function that takes the day's data as input and returns the answer for part 2.\n", - "- `do(3)`: runs `day3_1(in3)`. I'll then use the result to hopefully unlock part 2 and define `day3_2`, which also gets run when I call `do(3)` again. Once I verify both answers, I'll change `do(3)` to `do(3, 167, 736527114)` to serve as a unit test.\n", + "For each day from 1 to 25, I'll write **four pieces of code**, each in a separate notebook cell. For example, on day 3:\n", + "- `in3: List[str] = data(3)`: the day's input data, parsed into an appropriate form (here, a list of string lines). Most days the data comes from a file, read via the function `data` (which has optional arguments to say how to split the data into sections/records and how to parse each one), but some days the data is so small I just copy and paste it.\n", + "- `def day3_1(nums): ... `: a function that takes the day's data as input and returns the answer for Part 1.\n", + "- `def day3_2(nums): ... `: a function that takes the day's data as input and returns the answer for Part 2.\n", + "- `do(3)`: executes the call `day3_1(in3)`. I'll then use the result to hopefully unlock part 2 and define `day3_2`, which also gets run when I call `do(3)` again. Once I verify both answers, I'll change `do(3)` to `do(3, 167, 736527114)` to serve as a unit test.\n", "\n", "# Day 0: Imports and Utility Functions\n", "\n", @@ -33,8 +33,9 @@ "from __future__ import annotations\n", "from collections import Counter, defaultdict, namedtuple, deque\n", "from itertools import permutations, combinations, product, chain\n", - "from functools import lru_cache\n", - "from typing import Dict, Tuple, Set, List, Iterator, Optional, Union\n", + "from functools import lru_cache, reduce\n", + "from typing import Dict, Tuple, Set, List, Iterator, Optional, Union, Sequence\n", + "from contextlib import contextmanager\n", "\n", "import operator\n", "import math\n", @@ -51,11 +52,12 @@ "source": [ "def data(day: int, parser=str, sep='\\n') -> list:\n", " \"Split the day's input file into sections separated by `sep`, and apply `parser` to each.\"\n", - " sections = open(f'data/advent2020/input{day}.txt').read().rstrip().split(sep)\n", - " return [parser(section) for section in sections]\n", + " with open(f'data/advent2020/input{day}.txt') as f:\n", + " sections = f.read().rstrip().split(sep)\n", + " return list(map(parser, sections))\n", " \n", - "def do(day, *answers) -> Dict[int, int]:\n", - " \"E.g., do(3) returns {1: day3_1(in3), 2: day3_2(in3)}. Verifies `answers` if given.\"\n", + "def do(day, *answers) -> List[int]:\n", + " \"E.g., do(3) returns [day3_1(in3), day3_2(in3)]. Verifies `answers` if given.\"\n", " g = globals()\n", " got = []\n", " for part in (1, 2):\n", @@ -65,6 +67,8 @@ " if len(answers) >= part: \n", " assert got[-1] == answers[part - 1], (\n", " f'{fname}(in{day}) got {got[-1]}; expected {answers[part - 1]}')\n", + " else:\n", + " got.append(None)\n", " return got" ] }, @@ -74,6 +78,13 @@ "metadata": {}, "outputs": [], "source": [ + "Number = Union[float, int]\n", + "Atom = Union[Number, str]\n", + "Char = str # Type used to indicate a single character\n", + "\n", + "cat = ''.join\n", + "flatten = chain.from_iterable\n", + "\n", "def quantify(iterable, pred=bool) -> int:\n", " \"Count the number of items in iterable for which pred is true.\"\n", " return sum(1 for item in iterable if pred(item))\n", @@ -82,49 +93,48 @@ " \"Return first item in iterable, or default.\"\n", " return next(iter(iterable), default)\n", "\n", - "def rest(sequence) -> object: return sequence[1:]\n", - "\n", - "def multimap(items: Iterable[Tuple]) -> dict:\n", - " \"Given (key, val) pairs, return {key: [val, ....], ...}.\"\n", - " result = defaultdict(list)\n", - " for (key, val) in items:\n", - " result[key].append(val)\n", - " return result\n", - "\n", - "def prod(numbers) -> float: # Will be math.prod in Python 3.8, but I'm in 3.7\n", + "def prod(numbers) -> Number:\n", " \"The product of an iterable of numbers.\" \n", - " result = 1\n", - " for n in numbers:\n", - " result *= n\n", - " return result\n", + " return reduce(operator.mul, numbers, 1)\n", + "\n", + "def dot(A, B) -> Number: \n", + " \"The dot product of two vectors of numbers.\"\n", + " return sum(a * b for a, b in zip(A, B))\n", "\n", "def ints(text: str) -> Tuple[int]:\n", " \"Return a tuple of all the integers in text.\"\n", - " return tuple(map(int, re.findall('-?[0-9]+', text)))\n", + " return mapt(int, re.findall('-?[0-9]+', text))\n", "\n", - "def atoms(text: str, ignore=r'', sep=None) -> Tuple[Union[int, str]]:\n", - " \"Parse text into atoms (numbers or strs), possibly ignoring a regex.\"\n", - " if ignore:\n", - " text = re.sub(ignore, '', text)\n", - " return tuple(map(atom, text.split(sep)))\n", + "def lines(text: str) -> List[str]:\n", + " \"Split the text into a list of lines.\"\n", + " return text.strip().splitlines()\n", "\n", - "def atom(text: str) -> Union[float, int, str]:\n", - " \"Parse text into a single float or int or str.\"\n", - " try:\n", - " val = float(text)\n", - " return round(val) if round(val) == val else val\n", - " except ValueError:\n", - " return text\n", - " \n", - "def dotproduct(A, B) -> float: return sum(a * b for a, b in zip(A, B))\n", - "\n", - "def mapt(fn, *args):\n", - " \"map(fn, *args) and return the result as a tuple.\"\n", + "def mapt(fn, *args): \n", + " \"Do map(fn, *args) and make the result a tuple.\"\n", " return tuple(map(fn, *args))\n", "\n", - "cat = ''.join\n", - "flatten = chain.from_iterable\n", - "Char = str # Type used to indicate a single character" + "def atoms(text: str, ignore=r'', sep=None) -> Tuple[Atom]:\n", + " \"Parse text (with regex `ignore` ignored) into atoms separated by `sep`\"\n", + " text = re.sub(ignore, '', text)\n", + " return mapt(atom, text.split(sep))\n", + "\n", + "def atom(text: str, types=(int, str)):\n", + " \"Parse text into one of the given types.\"\n", + " for typ in types:\n", + " try:\n", + " return typ(text)\n", + " except ValueError:\n", + " pass\n", + "\n", + "@contextmanager\n", + "def binding(**kwds):\n", + " \"Bind global variables within a context; revert to old values on exit.\"\n", + " old_values = {k: globals()[k] for k in kwds}\n", + " try:\n", + " globals().update(kwds)\n", + " yield # Stuff within the context gets run here.\n", + " finally:\n", + " globals().update(old_values)" ] }, { @@ -132,12 +142,12 @@ "metadata": {}, "source": [ "Notes:\n", - "- Since I'm not even attempting to compete for speed, I'll take the time to use reasonable variable names (not single-letter names), and to give type annotations for most of the functions I define (but not the `day` functions, which all return `int`).\n", + "- Since I'm not even attempting to compete to be among the first 100 people to find a solution, I'll take the time to write docstrings; to use reasonable variable names (not single-letter names); and to give type annotations for most functions (but not the `day` functions, which all return `int`, except `day21_2`).\n", "- Traditionally, a lot of AoC problems are solved by one of the following two forms:\n", " - `quantify(inputs, P)`: How many of your input items have property P?\n", " - `sum(map(F, inputs))`: What is the sum of the result of applying F to each input item?\n", - "- I will feel free to re-use a definition that I define one day in a subsequent day's puzzle.\n", - "- I will define a few test cases with `assert`, but far fewer test cases than if I was programming seriously." + "- Some days I will re-use code that was defined on a previous day.\n", + "- I will give a few tests using `assert`, but far fewer test cases than if I was programming seriously." ] }, { @@ -367,8 +377,6 @@ " ecl:gry pid:860033327 eyr:2020 hcl:#fffffd\n", " byr:1937 iyr:2017 cid:147 hgt:183cm\n", "\n", - " iyr:2013 ecl:amb cid:350 eyr:2023 pid:028048884 hcl:#cfa07d byr:1929\n", - "\n", " hcl:#ae17e1 iyr:2013\n", " eyr:2024 ecl:brn pid:760753108 byr:1931 hgt:179cm\n", " \n", @@ -401,9 +409,8 @@ "outputs": [], "source": [ "required_fields = {'byr', 'ecl', 'eyr', 'hcl', 'hgt', 'iyr', 'pid'}\n", - "valid_passport = required_fields.issubset\n", "\n", - "def day4_1(passports): return quantify(passports, valid_passport) " + "def day4_1(passports): return quantify(passports, required_fields.issubset) " ] }, { @@ -426,9 +433,8 @@ " ecl (Eye Color) - exactly one of: amb blu brn gry grn hzl oth.\n", " pid (Passport ID) - a nine-digit number, including leading zeroes.\n", " cid (Country ID) - ignored, missing or not.'''\n", - " return (valid_passport(passport)\n", - " and all(field_validator[field](passport[field])\n", - " for field in required_fields))\n", + " return all(field in passport and field_validator[field](passport[field])\n", + " for field in required_fields)\n", "\n", "field_validator = dict(\n", " byr=lambda v: 1920 <= int(v) <= 2002,\n", @@ -541,10 +547,6 @@ "\n", " abc\n", "\n", - " a\n", - " b\n", - " c\n", - "\n", " ab\n", " ac\n", " \n", @@ -558,9 +560,9 @@ "metadata": {}, "outputs": [], "source": [ - "in6: List[List[str]] = data(6, str.splitlines, sep='\\n\\n')\n", + "Group = List[str]\n", "\n", - "assert in6[1] == ['arke', 'qzr', 'plmgnr', 'uriq'] # A group is a list of strs" + "in6: List[Group] = data(6, lines, sep='\\n\\n')" ] }, { @@ -581,7 +583,7 @@ "metadata": {}, "outputs": [], "source": [ - "def day6_2(groups: List[List[str]]): \n", + "def day6_2(groups): \n", " \"For each group, compute the number of letters that EVERYONE got. Sum them.\"\n", " return sum(len(set.intersection(*map(set, group)))\n", " for group in groups)" @@ -617,7 +619,6 @@ "\n", " light red bags contain 1 bright white bag, 2 muted yellow bags.\n", " dark orange bags contain 3 bright white bags, 4 muted yellow bags.\n", - " bright white bags contain 1 shiny gold bag.\n", " \n", "1. How many bag colors must eventually contain at least one shiny gold bag?\n", "2. How many individual bags must be inside your single shiny gold bag?\n", @@ -676,13 +677,12 @@ "metadata": {}, "outputs": [], "source": [ - "def day7_2(rules, target='shiny gold'): \n", - " return num_contained_in(target, rules)\n", - "\n", - "def num_contained_in(target, rules) -> int:\n", + "def num_contained_in(rules, target='shiny gold') -> int:\n", " \"How many bags are contained (recursively) in the target bag?\"\n", - " return sum(n + n * num_contained_in(bag, rules) \n", - " for (bag, n) in rules[target].items() if n > 0)" + " return sum(n + n * num_contained_in(rules, inner) \n", + " for (inner, n) in rules[target].items() if n > 0)\n", + "\n", + "day7_2 = num_contained_in" ] }, { @@ -755,7 +755,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "I had to think about what to do for Part 2. Do I need to make a flow graph of where the loops are? That sounds hard. But I soon realized that I can just use brute force—try every alteration of an instruction (there are only $O(n)$ of them), and run each altered program to see if it terminates (that too takes only $O(n)$ time)." + "I had to think about what to do for Part 2. Do I need to make a flow graph of where the loops are? That sounds hard. But I soon realized that I can just use brute force—try every alteration of an instruction (there are only 638 instructions and at most one way to alter each instruction), and run each altered program to see if it terminates (that too takes no more than 638 steps each)." ] }, { @@ -946,6 +946,7 @@ "\n", "@lru_cache(None)\n", "def arrangements(jolts, prev) -> int:\n", + " \"The number of arrangements that go from prev to the end of `jolts`.\"\n", " first, rest = jolts[0], jolts[1:]\n", " if first - prev > 3:\n", " return 0\n", @@ -999,7 +1000,7 @@ "1. Simulate your seating area by applying the seating rules repeatedly until no seats change state. How many seats end up occupied?\n", "2. Same problem, but with two rule changes:\n", " - When considering adjacency, if there is a *floor* cell in some direction, skip over that to the next visible seat in that direction. \n", - " - Empty a seat only when there are 5 occupied neighbors, not 4. " + " - A seat becomes empty only when there are 5 occupied neighbors, not 4. " ] }, { @@ -1016,83 +1017,6 @@ "execution_count": 45, "metadata": {}, "outputs": [], - "source": [ - "Seats = List[str]\n", - "\n", - "floor, empty, occupied, off = \".L#?\"\n", - "\n", - "Contents = Char # The contents of each location is one of the above 4 characters\n", - "\n", - "crowded = 4\n", - " \n", - "deltas = ((-1, -1), (0, -1), (1, -1),\n", - " (-1, 0), (1, 0),\n", - " (-1, +1), (0, +1), (1, +1))\n", - " \n", - "def next_generation(seats) -> Seats:\n", - " \"The next generation, according to the rules.\"\n", - " return [cat(self.next_generation_at(x, y) for x in range(len(self[y])))\n", - " for y in range(len(self))]\n", - "\n", - "def next_generation_at(seats, x, y) -> Contents:\n", - " \"The contents of location (x, y) in the next generation.\"\n", - " old = seats[y][x]\n", - " N = self.neighbors(x, y).count(occupied)\n", - " return (occupied if old is empty and N == 0 else\n", - " empty if old is occupied and N >= crowded else\n", - " old)\n", - "\n", - "def neighbors(seats, x, y) -> List[Contents]: \n", - " \"The contents of the 8 neighboring locations.\"\n", - " return [seats.at(x + dx, y + dy) for dx, dy in self.deltas]\n", - "\n", - " def count(self, kind: Contents) -> int: return cat(self).count(kind)\n", - " \n", - " def at(self, x, y) -> Contents:\n", - " \"The contents of location (x, y): empty, occupied, floor, or off?\"\n", - " if 0 <= y < len(self) and 0 <= x < len(self[y]):\n", - " return self[y][x]\n", - " else:\n", - " return off\n", - " \n", - " def run(self) -> Layout:\n", - " \"Run until equilibrium.\"\n", - " new = self\n", - " while True:\n", - " new, old = new.next_generation(), new\n", - " if new == old:\n", - " return new\n", - "\n", - "def day11_1(seats): return Layout(seats).run().count(occupied)" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'Layout' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36mday11_1\u001b[0;34m(seats)\u001b[0m\n\u001b[1;32m 45\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mnew\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 46\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 47\u001b[0;31m \u001b[0;32mdef\u001b[0m \u001b[0mday11_1\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseats\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mLayout\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseats\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moccupied\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mNameError\u001b[0m: name 'Layout' is not defined" - ] - } - ], - "source": [ - "%time day11_1(in11)" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [], "source": [ "floor, empty, occupied, off = \".L#?\"\n", "\n", @@ -1147,7 +1071,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 46, "metadata": {}, "outputs": [], "source": [ @@ -1174,33 +1098,22 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 47, "metadata": {}, "outputs": [ { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36mdo\u001b[0;34m(day, *answers)\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0mfname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34mf'day{day}_{part}'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfname\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mg\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m \u001b[0mgot\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mg\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfname\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mg\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34mf'in{day}'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 14\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0manswers\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0mpart\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m assert got[-1] == answers[part - 1], (\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36mday11_2\u001b[0;34m(seats)\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mdef\u001b[0m \u001b[0mday11_2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseats\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mLayout2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseats\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moccupied\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0mLayout2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mLayout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\"A layout of seats (occupied or not) and floor space, with new rules.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[0mnew\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 44\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 45\u001b[0;31m \u001b[0mnew\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mold\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnext_generation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 46\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnew\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mold\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 47\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mnew\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36mnext_generation\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 16\u001b[0m seats = (cat(self.next_generation_at(x, y) for x in range(len(self[y])))\n\u001b[1;32m 17\u001b[0m for y in range(len(self)))\n\u001b[0;32m---> 18\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseats\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 19\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 20\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mnext_generation_at\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mContents\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;34m\"The next generation, according to the rules.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 16\u001b[0m seats = (cat(self.next_generation_at(x, y) for x in range(len(self[y])))\n\u001b[0;32m---> 17\u001b[0;31m for y in range(len(self)))\n\u001b[0m\u001b[1;32m 18\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseats\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 19\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mnext_generation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mLayout\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;34m\"The next generation, according to the rules.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m seats = (cat(self.next_generation_at(x, y) for x in range(len(self[y])))\n\u001b[0m\u001b[1;32m 17\u001b[0m for y in range(len(self)))\n\u001b[1;32m 18\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseats\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36mnext_generation_at\u001b[0;34m(self, x, y)\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0;34m\"The contents of location (x, y) in the next generation.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 22\u001b[0m \u001b[0mold\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m \u001b[0mN\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mneighbors\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moccupied\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 24\u001b[0m return (occupied if old is empty and N == 0 else\n\u001b[1;32m 25\u001b[0m \u001b[0mempty\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mold\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0moccupied\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mN\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcrowded\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36mneighbors\u001b[0;34m(self, x, y)\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mneighbors\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mList\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mContents\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;34m\"The contents of the nearest visible seat in each of the 8 directions.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisible\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdy\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mdx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdy\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdeltas\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mvisible\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdy\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mContents\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mneighbors\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mList\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mContents\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;34m\"The contents of the nearest visible seat in each of the 8 directions.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisible\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdy\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mdx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdy\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdeltas\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mvisible\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdy\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mContents\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36mvisible\u001b[0;34m(self, x, dx, y, dy)\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mvisible\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdy\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mContents\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[0;34m\"The contents of the first visible seat in direction (dx, dy).\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmaxsize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 15\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mdx\u001b[0m\u001b[0;34m;\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mdy\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 16\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m \u001b[0;34m<=\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;36m0\u001b[0m \u001b[0;34m<=\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] + "data": { + "text/plain": [ + "[2299, 2047]" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "%time do(11, 2299, 2047)" + "do(11, 2299, 2047)" ] }, { @@ -1208,7 +1121,7 @@ "metadata": {}, "source": [ "I have to confess that I \"cheated\" here: after seeing the problem description for Part 2, I went back and refactored the code for Part 1 in two places:\n", - "- `Layout`: Introduced the `crowded` attribute; it had been an inline literal `4`. Also made `deltas` an attribute.\n", + "- `Layout`: Introduced the `crowded` attribute; it had been an inline literal `4`. Also made `deltas` an attribute, not a global constant.\n", "- `next_generation`: Changed `Layout(seats)` to `type(self)(seats)`.\n", "\n", "There was more refactoring and less reuse in Part 2 than I would have liked, but I don't feel like I made bad choices in Part 1." @@ -1230,7 +1143,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 48, "metadata": {}, "outputs": [], "source": [ @@ -1239,7 +1152,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 49, "metadata": {}, "outputs": [], "source": [ @@ -1271,7 +1184,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 50, "metadata": {}, "outputs": [], "source": [ @@ -1289,7 +1202,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 51, "metadata": {}, "outputs": [ { @@ -1298,7 +1211,7 @@ "[439, 12385]" ] }, - "execution_count": 53, + "execution_count": 51, "metadata": {}, "output_type": "execute_result" } @@ -1320,19 +1233,19 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 52, "metadata": {}, "outputs": [], "source": [ "x = 0\n", "in13: Tuple[ID] = (29,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,41,x,x,x,x,x,x,x,x,x,577,\n", - " x,x,x,x,x,x,x,x,x,x,x,x,13,17,x,x,x,x,19,x,x,x,23,x,x,x,x,x,x,x,601,x,x,x,x,x,x,\n", - " x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,37)" + " x,x,x,x,x,x,x,x,x,x,x,x,13,17,x,x,x,x,19,x,x,x,23,x,x,x,x,x,x,x,601,x,x,x,x,x,\n", + " x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,37)" ] }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 53, "metadata": {}, "outputs": [], "source": [ @@ -1356,7 +1269,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 54, "metadata": {}, "outputs": [], "source": [ @@ -1380,20 +1293,9 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 55, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[174, 780601154795940]" - ] - }, - "execution_count": 57, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "def day13_2(ids):\n", " \"Find the time where all the buses arrive at the right offsets.\"\n", @@ -1404,8 +1306,26 @@ " while wait(schedule[t], time + t):\n", " time += step\n", " step *= schedule[t]\n", - " return time\n", - "\n", + " return time" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[174, 780601154795940]" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ "do(13, 174, 780601154795940)" ] }, @@ -1420,12 +1340,12 @@ "1. Execute the initialization program. What is the sum of all values left in memory after it completes?\n", "2. Execute the initialization program using an emulator for a version 2 decoder chip. What is the sum of all values left in memory after it completes?\n", "\n", - "A *mask* is a bit string but with three possible values at each position, 01X. I could make it into two bitstrings, but I choose to leave it as a `str`." + "A *mask* is a bit string but with three possible values at each position, `01X`. I could make it into two bitstrings, but I choose to leave it as a `str`." ] }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 57, "metadata": {}, "outputs": [], "source": [ @@ -1441,7 +1361,7 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 58, "metadata": {}, "outputs": [], "source": [ @@ -1462,14 +1382,14 @@ "\n", "def bin36(i) -> str: return f'{i:036b}'\n", "\n", - "assert bin36(255) == '000000000000000000000000000011111111'\n", + "assert bin36(255 + 2 ** 20) == '000000000000000100000000000011111111'\n", "\n", "def day14_1(program): return sum(run_docking(program).values())" ] }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 59, "metadata": {}, "outputs": [], "source": [ @@ -1492,7 +1412,7 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 60, "metadata": {}, "outputs": [ { @@ -1501,7 +1421,7 @@ "[11884151942312, 2625449018811]" ] }, - "execution_count": 61, + "execution_count": 60, "metadata": {}, "output_type": "execute_result" } @@ -1524,7 +1444,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 61, "metadata": {}, "outputs": [], "source": [ @@ -1533,7 +1453,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 62, "metadata": {}, "outputs": [], "source": [ @@ -1555,12 +1475,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Part 2 involves no changes, but looks for the 30 millionth number. If it had been 3 million, I'd think \"no problem!\" If it had been 30 billion, I'd think \"I need a more efficient solution!\" As it is, I'll run it and see how long it takes:" + "Part 2 involves no changes, but asks for the 30 millionth number. If it had been 3 million, I'd think \"no problem!\" If it had been 30 billion, I'd think \"I need a more efficient solution!\" As it is, I'll run it and see how long it takes:" ] }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 63, "metadata": {}, "outputs": [], "source": [ @@ -1569,17 +1489,15 @@ }, { "cell_type": "code", - "execution_count": 65, - "metadata": { - "scrolled": true - }, + "execution_count": 64, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 11.7 s, sys: 330 ms, total: 12 s\n", - "Wall time: 12.2 s\n" + "CPU times: user 7.31 s, sys: 114 ms, total: 7.42 s\n", + "Wall time: 7.42 s\n" ] }, { @@ -1588,7 +1506,7 @@ "[412, 243]" ] }, - "execution_count": 65, + "execution_count": 64, "metadata": {}, "output_type": "execute_result" } @@ -1610,6 +1528,19 @@ "source": [ "# Day 16: Ticket Translation\n", "\n", + "The input to this puzzle has three parts: some rules for valid fields; your ticket; and a set of nearby tickets. The puzzle is to figure out what field number corresponds to what field name (class, row, seat, etc.). The input looks like:\n", + "\n", + " class: 1-3 or 5-7\n", + " row: 6-11 or 33-44\n", + "\n", + " your ticket:\n", + " 7,1,14\n", + "\n", + " nearby tickets:\n", + " 7,3,47\n", + " 40,4,50\n", + "\n", + "\n", "1. Consider the validity of the nearby tickets you scanned. What is the sum of the values that are are not valid for any field?\n", "2. Discard invalid tickets. Use the remaining valid tickets to determine which field is which. Look for the six fields on your ticket that start with the word departure. What do you get if you multiply those six values together?\n", "\n", @@ -1618,7 +1549,7 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 65, "metadata": {}, "outputs": [], "source": [ @@ -1631,8 +1562,7 @@ " def __contains__(self, item): return any(item in s for s in self)\n", " \n", "def parse_ticket_sections(fieldstr: str, your: str, nearby: str) -> TicketData:\n", - " fields = dict(map(parse_ticket_line, fieldstr))\n", - " return TicketData(fields=fields, \n", + " return TicketData(fields=dict(map(parse_ticket_line, fieldstr)), \n", " your=Ticket(your[1]), \n", " nearby=[Ticket(line) for line in nearby[1:]])\n", "\n", @@ -1642,12 +1572,12 @@ " a, b, c, d = ints(line.replace('-', ' '))\n", " return field, Sets((range(a, b + 1), range(c, d + 1)))\n", "\n", - "in16 = parse_ticket_sections(*data(16, str.splitlines, sep='\\n\\n'))" + "in16 = parse_ticket_sections(*data(16, lines, sep='\\n\\n'))" ] }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 66, "metadata": {}, "outputs": [], "source": [ @@ -1672,7 +1602,7 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 67, "metadata": {}, "outputs": [], "source": [ @@ -1683,13 +1613,13 @@ " fields, your, nearby = ticket_data\n", " ranges = Sets(ticket_data.fields.values())\n", " valid = [t for t in nearby + [your] if valid_ticket(t, ranges)]\n", - " possible = [set(fields) for _ in range(len(your))]\n", - " while any(len(p) > 1 for p in possible):\n", + " possible = {i: set(fields) for i in range(len(your))}\n", + " while any(len(possible[i]) > 1 for i in possible):\n", " for field_name, i in invalid_fields(valid, fields):\n", " possible[i] -= {field_name}\n", " if len(possible[i]) == 1:\n", " eliminate_others(possible, i)\n", - " return {field: i for i, [field] in enumerate(possible)}\n", + " return {field: i for i, [field] in possible.items()}\n", "\n", "def invalid_fields(valid, fields) -> Iterable[Tuple[str, int]]:\n", " \"Yield (field_name, field_number) for all invalid fields.\"\n", @@ -1699,7 +1629,7 @@ "\n", "def eliminate_others(possible, i):\n", " \"Eliminate possible[i] from all other possible[j].\"\n", - " for j in range(len(possible)):\n", + " for j in possible:\n", " if j != i:\n", " possible[j] -= possible[i]\n", "\n", @@ -1712,7 +1642,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 68, "metadata": {}, "outputs": [ { @@ -1721,13 +1651,13 @@ "[21071, 3429967441937]" ] }, - "execution_count": 69, + "execution_count": 68, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "do(16)" + "do(16, 21071, 3429967441937)" ] }, { @@ -1736,7 +1666,28 @@ "source": [ "# Day 17: Conway Cubes\n", "\n", - "Now we are explicitly playing *Life*, but in three dimensions not two. I've coded this before; I'll adapt my [old version](Life.ipynb) to three dimensions. My implementation represents a generation as the set of active cell coordinates." + "Now we are explicitly playing *Life*, but in three dimensions, not two. I've coded this before; I'll adapt my [old version](Life.ipynb) to three dimensions (actually, make it `d` dimensions in general). My implementation represents a generation as the set of active cell coordinates.\n", + "\n", + "1. Starting with your given initial configuration, simulate six cycles. How many cubes are left in the active state after the sixth cycle?\n", + "2. Simulate six cycles in a 4-dimensional space. How many cubes are left in the active state after the sixth cycle?" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [], + "source": [ + "in17: Picture = lines('''\n", + "##.#....\n", + "...#...#\n", + ".#.#.##.\n", + "..#.#...\n", + ".###....\n", + ".##.#...\n", + "#.##..##\n", + "#.####..\n", + "''')" ] }, { @@ -1745,39 +1696,9 @@ "metadata": {}, "outputs": [], "source": [ - "in17: Picture = '''\n", - "##.#....\n", - "...#...#\n", - ".#.#.##.\n", - "..#.#...\n", - ".###....\n", - ".##.#...\n", - "#.##..##\n", - "#.####..'''.strip().splitlines()" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[291, 1524]" - ] - }, - "execution_count": 71, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "### New - Thu\n", - "\n", "Cell = Tuple[int,...]\n", "\n", - "def day17_1(picture, n=6, d=3):\n", + "def day17_1(picture, d=3, n=6):\n", " \"How many cells are active in the nth generation?\"\n", " return len(life(parse_cells(picture, d), n))\n", "\n", @@ -1799,7 +1720,7 @@ " if count == 3 or (count == 2 and cell in cells)}\n", "\n", "@lru_cache()\n", - "def cell_deltas(d: int): \n", + "def cell_deltas(d: int):\n", " return set(filter(any, product((-1, 0, +1), repeat=d)))\n", "\n", "def neighbor_counts(cells) -> Dict[Cell, int]:\n", @@ -1808,19 +1729,17 @@ "\n", "def neighbors(cell) -> List[cell]:\n", " \"All adjacent neighbors of cell in three dimensions.\"\n", - " return [tuple(map(operator.add, cell, delta)) \n", - " for delta in cell_deltas(len(cell))]\n", - "\n", - "def day17_2(picture): return day17_1(picture, d=4)\n", - "\n", - "do(17, 291, 1524)" + " return [tuple(map(operator.add, cell, delta))\n", + " for delta in cell_deltas(len(cell))]" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 71, "metadata": {}, + "outputs": [], "source": [ - "Part 2 asks us to move to 4 dimensions. I'll generalize the previous code to work in 3 or 4 dimensions:" + "def day17_2(picture): return day17_1(picture, d=4)" ] }, { @@ -1829,53 +1748,27 @@ "metadata": {}, "outputs": [ { - "ename": "IndentationError", - "evalue": "unexpected indent (, line 10)", - "output_type": "error", - "traceback": [ - "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m10\u001b[0m\n\u001b[0;31m \"How many cells are active in the nth generation in a d-dimensional world?\"\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unexpected indent\n" - ] + "data": { + "text/plain": [ + "[291, 1524]" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "def parse_cells(picture, d=3, active='#') -> Set[Cell]:\n", - " \"Convert a 2-d picture into a set of d-dimensional active cells.\"\n", - " return {(x, y, *(d - 2) * (0,) )\n", - " for (y, row) in enumerate(picture)\n", - " for x, cell in enumerate(row) if cell is active}\n", - "\n", - "def day17_1(picture): return day17_2(picture, n=6, d=3)\n", - "\n", - "\n", - " \"How many cells are active in the nth generation in a d-dimensional world?\"\n", - " cells = parse_cells(picture, d=d)\n", - " for g in range(n):\n", - " cells = next_generation(cells)\n", - " return len(cells)\n", - "\n", - "deltas = [set(product((-1, 0, +1), repeat=d)) - {(0,) * d}\n", - " for d in range(5)]\n", - "\n", - "def neighbors(cell) -> List[cell]:\n", - " \"All adjacent neighbors of cell in all dimensions.\"\n", - " return [tuple(map(operator.add, cell, delta)) \n", - " for delta in deltas[len(cell)]]" + "do(17, 291, 1524)" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Day 18: Operation Order\n", "\n", - "At first I thought I could just apply `eval` to each line, but alas, the operation order is non-standard. I could have used a parsing framework, but I decided to do it all from scratch.\n", + "At first I thought I could just apply `eval` to each line, but alas, the operation order is non-standard.\n", "\n", "1. All operations are done left-to-right. Evaluate the expression on each line of the homework; what is the sum of the resulting values?\n", "2. Addition is done before multiplication. What do you get if you add up the results of evaluating the homework problems using these new rules?" @@ -1883,7 +1776,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 73, "metadata": {}, "outputs": [], "source": [ @@ -1896,7 +1789,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 74, "metadata": {}, "outputs": [], "source": [ @@ -1916,7 +1809,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 75, "metadata": {}, "outputs": [], "source": [ @@ -1935,9 +1828,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 76, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[3885386961962, 112899558798666]" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "do(18, 3885386961962, 112899558798666)" ] @@ -1958,7 +1862,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 77, "metadata": { "scrolled": true }, @@ -1974,18 +1878,18 @@ "\n", "def parse_rule(line):\n", " \"Parse '1: 2 3' => (1, [2, 3]); '4: 5, 6 | 7' => (4, Choice(([5, 6], [7]))).\"\n", - " n, *rhs = atoms(line, ignore='[:\"]')\n", + " n, *rhs = atoms(line.replace(':', ' ').replace('\"', ' '))\n", " if '|' in rhs:\n", " i = rhs.index('|')\n", " rhs = [Choice((rhs[:i], rhs[i + 1:]))]\n", " return n, rhs\n", " \n", - "in19 = parse_messages(*data(19, str.splitlines, sep='\\n\\n'))" + "in19 = parse_messages(*data(19, lines, sep='\\n\\n'))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 78, "metadata": {}, "outputs": [], "source": [ @@ -2022,7 +1926,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 79, "metadata": {}, "outputs": [], "source": [ @@ -2037,9 +1941,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 80, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[190, 311]" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "do(19, 190, 311)" ] @@ -2058,7 +1973,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 81, "metadata": {}, "outputs": [], "source": [ @@ -2067,19 +1982,19 @@ " return {first(ints(header)): tile\n", " for (header, *tile) in sections}\n", " \n", - "in20 = jigsaw_tiles(data(20, str.splitlines, sep='\\n\\n'))" + "in20 = jigsaw_tiles(data(20, lines, sep='\\n\\n'))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "For Part 1, it is guaranteed that \"the outermost edges won't line up with any other tiles,\" but all the inside edges will. We'll define `edge_count` to count how many times an edge appears on any tile (using a `canonical` orientation, because tiles might be flipped). Then the corner tiles are ones that have two edges that have an edge count of 1." + "For Part 1, I can find the corners without knowing where all the other tiles go. It is guaranteed that \"the outermost edges won't line up with any other tiles,\" but all the inside edges will. We'll define `edge_count` to count how many times an edge appears on any tile (using a `canonical` orientation, because tiles might be flipped). Then the corner tiles are ones that have two edges that have an edge count of 1." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 82, "metadata": {}, "outputs": [], "source": [ @@ -2104,9 +2019,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 83, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[15670959891893, None]" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "do(20, 15670959891893) " ] @@ -2115,44 +2041,24 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Holiday preparations kept me from doing Part 2 on the night of the 19th, and unfortunately I didn't feel like coming back to it later: it seemed too tedious for too little reward. And I thought it was inelegant that a solid block of `#` pixels would be considered a sea monster with waves. " + "Family holiday preparations kept me from doing **Part 2** on the night it was released, and unfortunately I didn't feel like coming back to it later: it seemed too tedious for too little reward. I thought it was inelegant that a solid block of `#` pixels would be considered a sea monster with waves. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Timing\n", + "# Day 21: Allergen Assessment\n", "\n", - "Advent of Code [states that each day's puzzle should run in 15-seconds or less](https://adventofcode.com/2020/about)).\n", - "I met that goal, with only days 11 and 15 taking more than a second. Here's a report, with stars in the first column indicating run times on a logarithmic base-10 scale: zero stars for under 1/100 seconds up to 4 stars for over 10 seconds:" + "This is another Sudoku-like problem, similar to Day 16, involving ingredients and allergens. Crucially, each allergen is found in exactly one ingredient, but a food may not list every allergen. I can reuse the function `eliminate_others`, but the rest I need to define here. `day21_2` is the only `day` function that does not return an `int`.\n", + "\n", + "1. Determine which ingredients cannot possibly contain any of the allergens in your list. How many times do any of those ingredients appear?\n", + "2. What is your canonical dangerous ingredient list?" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import time\n", - "\n", - "def timing(days=range(1, 26)):\n", - " \"Report on timing of `do(day)` for all days.\"\n", - " results = []\n", - " for day in days:\n", - " t0 = time.time()\n", - " answers = do(day)\n", - " t = time.time() - t0\n", - " if answers:\n", - " stars = '*' * int(3 + math.log(t, 10))\n", - " print(f'{stars:>4} {day:2}: {t:6.3f} sec ⇒ {answers}')\n", - "\n", - "%time timing() " - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 84, "metadata": {}, "outputs": [], "source": [ @@ -2165,16 +2071,23 @@ " ingredients, allergens = line.split('(contains')\n", " return Food(set(atoms(ingredients)), set(atoms(allergens, ignore='[,)]')))\n", "\n", - "in21 = data(21, parse_food)\n", - "\n", + "in21 = data(21, parse_food)" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [], + "source": [ "def day21_1(foods):\n", + " \"How many times does an ingredient with an allergen appear?\"\n", " bad = bad_ingredients(foods)\n", " allergens = set(flatten(bad.values()))\n", " return sum(len(food.I - allergens) for food in foods)\n", "\n", "def bad_ingredients(foods) -> Dict[Allergen, Set[Ingredient]]:\n", - " \"A dict of {allergen: {set_of_ingredients_it_could_be}}\"\n", - " # Each allergen is found in exactly one ingredient.\n", + " \"A dict of {allergen: {set_of_ingredients_it_could_be}}; each set should have len 1.\"\n", " all_I = set(flatten(food.I for food in foods))\n", " all_A = set(flatten(food.A for food in foods))\n", " possible = {a: set(all_I) for a in all_A}\n", @@ -2183,19 +2096,39 @@ " for a in food.A:\n", " possible[a] &= food.I\n", " if len(possible[a]) == 1:\n", - " eliminate_others21(possible, a)\n", - " return possible\n", - "\n", - "def eliminate_others21(possible, a):\n", - " \"Eliminate possible[a] from all other allergens.\"\n", - " for a2 in possible:\n", - " if a2 != a:\n", - " possible[a2] -= possible[a]\n", - " \n", + " eliminate_others(possible, a)\n", + " return possible" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [], + "source": [ "def day21_2(foods) -> str:\n", + " \"What are the bad ingredients, sorted by the allergen name that contains them?\"\n", " bad = bad_ingredients(in21)\n", - " return ','.join(first(g[x]) for x in sorted(g))\n", - "\n", + " return ','.join(first(bad[a]) for a in sorted(bad))" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[2282, 'vrzkz,zjsh,hphcb,mbdksj,vzzxl,ctmzsr,rkzqs,zmhnj']" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ "do(21, 2282, 'vrzkz,zjsh,hphcb,mbdksj,vzzxl,ctmzsr,rkzqs,zmhnj')" ] }, @@ -2203,121 +2136,139 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Day 22: Crab Combat \n", + "# Day 22: Crab Combat\n", "\n", - "The card game *War*.\n", + "Part 1 is the card game *War* (here called *Combat*) with no ties. Part 2 is a more complex recursive version of the game.\n", "\n", - "1. Play the small crab in a game of Combat using the two decks you just dealt. What is the winning player's score?\n", + "1. Play a game of Combat using the two decks you just dealt. What is the winning player's score?\n", + "2. Play a game of Recursive Combat. What is the winning player's score?\n", "\n", - "Card = int\n", - "Player = int\n", - "Deal = Tuple[Card]\n", - "\n", - "in22 = ((12, 40, 50, 4, 24, 15, 22, 43, 18, 21, 2, 42, 27, 36, 6, 31, 35, 20, 32, 1, 41, 14, 9, 44, 8), \n", - " (30, 10, 47, 29, 13, 11, 49, 7, 25, 37, 33, 48, 16, 5, 45, 19, 17, 26, 46, 23, 34, 39, 28, 3, 38))\n", - " \n", - "def day22_1(deals): return combat_score(combat(deals))\n", - "\n", - "def combat_score(deals) -> int:\n", - " deal = deals[0] or deals[1]\n", - " return dotproduct(deal, reversed(range(1, len(deal) + 1)))\n", - " \n", - "def combat(deals: Tuple[Deal]) -> Tuple[Player, Deal]:\n", - " deals = mapt(deque, deals)\n", - " while deals[0] and deals[1]:\n", - " tops = mapt(deque.popleft, deals)\n", - " winner = 0 if tops[0] > tops[1] else 1\n", - " deals[winner].extend(sorted(tops)[::-1])\n", - " return deals\n", - " \n", - "def day22_2(deals): return combat_score(recursive_combat(deals))\n", - " \n", - "def recursive_combat(deals) -> Tuple[Deal, Deal]:\n", - " \"A game of Recursive Combat\"\n", - " printv('recursive game', mapt(len, deals))\n", - " assert sum(map(len, deals)) <= 50\n", - " previous = set()\n", - " P = (0, 1)\n", - " while deals[0] and deals[1]:\n", - " if sum(mapt(len, deals)) <= 11:\n", - " printv(' deals', deals)\n", - " if deals in previous:\n", - " printv('recursive game ends in repeat')\n", - " return (deals[0], ())\n", - " previous.add(deals)\n", - " tops = mapt(first, deals)\n", - " deals = mapt(rest, deals)\n", - " if all(len(deals[p]) >= tops[p] for p in P):\n", - " rec = recursive_combat(tuple(deals[p][:tops[p]] for p in P))\n", - " winner = 0 if rec[0] else 1\n", - " else:\n", - " winner = 0 if tops[0] > tops[1] else 1\n", - " def bounty(p): return (tops[winner], tops[1 - winner]) if p == winner else ()\n", - " deals = tuple(deals[p] + bounty(p) for p in P)\n", - " printv('game ends')\n", - " return deals\n", - "\n", - "verbose = False\n", - "n = [0]\n", - "def printv(*args): \n", - " n[0] += 1\n", - " #if n[0] > 100: 1/0\n", - " verbose and print(*args)\n", - "\n", - "#do(22) \n", - "\n", - "assert (recursive_combat(((9, 2, 6, 3, 1), (5, 8, 4, 7, 10)))\n", - " == ((), (7, 5, 6, 2, 4, 1, 10, 8, 9, 3)))" + "Each player holds a *deal* of cards, which I will represent as a `deque` so I can deal from the top and add cards to the bottom." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 88, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "Deal = Union[tuple, deque] # Cards are a tuple on input; a deque internally \n", + "Deals = Tuple[Deal, Deal] # Cards are split into two piles for the two players.\n", + "\n", + "in22: Deals = (\n", + " (12,40,50,4,24,15,22,43,18,21,2,42,27,36,6,31,35,20,32,1,41,14,9,44,8),\n", + " (30,10,47,29,13,11,49,7,25,37,33,48,16,5,45,19,17,26,46,23,34,39,28,3,38))" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 89, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "def day22_1(deals): return combat_score(combat(deals))\n", + "\n", + "def combat(deals: Deals) -> Deals:\n", + " \"Given two deals, play Combat and return the final deals (one of which will be empty).\"\n", + " deals = mapt(deque, deals)\n", + " while all(deals):\n", + " topcards = mapt(deque.popleft, deals)\n", + " winner = 0 if topcards[0] > topcards[1] else 1\n", + " deals[winner].extend(sorted(topcards, reverse=True))\n", + " return deals\n", + "\n", + "def combat_score(deals: Deals) -> int:\n", + " \"The winner's cards, each multiplied by their reverse index number, and summed.\"\n", + " winning = deals[0] or deals[1]\n", + " return dot(winning, range(len(winning), 0, -1))" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 90, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "def day22_2(deals): return combat_score(recursive_combat(deals))\n", + " \n", + "def recursive_combat(deals: Deals) -> Deals:\n", + " \"A game of Recursive Combat.\"\n", + " deals = mapt(deque, deals)\n", + " previously = set()\n", + " while all(deals):\n", + " if seen(deals, previously):\n", + " return (deals[0], ())\n", + " topcards = mapt(deque.popleft, deals)\n", + " if all(len(deals[p]) >= topcards[p] for p in (0, 1)):\n", + " deals2 = [tuple(deals[p])[:topcards[p]] for p in (0, 1)]\n", + " result = recursive_combat(deals2)\n", + " winner = 0 if result[0] else 1\n", + " else:\n", + " winner = 0 if topcards[0] > topcards[1] else 1\n", + " deals[winner].extend([topcards[winner], topcards[1 - winner]])\n", + " return deals\n", + "\n", + "def seen(deals, previously) -> bool:\n", + " \"Return True if we have seen this pair of deals previously; else just remember it.\"\n", + " hasht = mapt(tuple, deals)\n", + " if hasht in previously:\n", + " return True\n", + " else:\n", + " previously.add(hasht)\n", + " return False" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 91, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "[31809, 32835]" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "do(22, 31809, 32835)" + ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Day 23: Crab Cups" + "# Day 23: Crab Cups\n", + "\n", + "A game involving moving around some cups that are labelled with positive integers.\n", + "\n", + "1. Using your labeling, simulate 100 moves. What are the labels on the cups after cup 1?\n", + "2. With 1 million cups and 10 million moves, determine which two cups will end up immediately clockwise of cup 1. What do you get if you multiply their labels together?" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 92, "metadata": {}, "outputs": [], "source": [ - "# Day 23: Crab Cups\n", - "\n", - "in23 = '872495136'\n", - "\n", - "Cup = int\n", + "in23 = '872495136'" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [], + "source": [ + "Cup = int # The label on a cup (not the index of the cup in the list of cups)\n", "\n", "def day23_1(cupstr: str, n=100):\n", + " \"Return the int representing the cups, in order, after cup 1; resulting from n moves.\"\n", " cups = list(map(int, cupstr))\n", " current = cups[0]\n", " for i in range(n):\n", @@ -2336,687 +2287,345 @@ " picked += cups[:extra]\n", " cups[:extra] = []\n", " return picked\n", - " \n", - "def destination(cups, current) -> Cup: \n", + " \n", + "def destination(cups, current) -> Cup:\n", " \"The cup with label one less than current, or max(cups).\"\n", " return max((c for c in cups if c < current), default=max(cups))\n", "\n", "def clockwise(cups, current) -> Cup:\n", " \"The cup one clockwise of current.\"\n", - " i = cups.index(current)\n", - " return cups[(i + 1) % len(cups)]\n", + " return cups[(cups.index(current) + 1) % len(cups)]\n", "\n", "def place(cups, picked, dest):\n", " \"Put `picked` after `dest`\"\n", " i = cups.index(dest) + 1\n", " cups[i:i] = picked\n", - " \n", + "\n", + "def after(cup, cups) -> int:\n", + " \"All the cups after `cup`, in order.\"\n", + " i = cups.index(cup) + 1\n", + " string = cat(map(str, cups + cups))\n", + " return int(string[i:i+len(cups)])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Cup = int # The label on a cup (not the index of the cup in the list of cups)\n", + "\n", + "def day23_1(cupstr: str, n=100):\n", + " \"Return the int representing the cups, in order, after cup 1; resulting from n moves.\"\n", + " return after(1, play_cups(cupstr, n))\n", + "\n", + "def play_cups(cupstr: str, n=100, maxcup=0):\n", + " cups = list(map(int, cupstr))\n", + " if maxcup > max(cups):\n", + " cups.append(range(max(cups) + 1, maxcup + 1))\n", + " current = cups[0][0]\n", + " for i in range(n):\n", + " picked = pickup(cups, current)\n", + " dest = destination(cups, current)\n", + " place(cups, picked, dest)\n", + " current = clockwise(cups, current)\n", + " return cups\n", + "\n", + "def pickup(cups, current) -> List[Cup]:\n", + " \"Return the 3 cups clockwise of current; remove them from cups.\"\n", + " i = cups.index(current)\n", + " picked, cups[i+1:i+4] = cups[i+1:i+4], []\n", + " extra = 3 - len(picked)\n", + " if extra:\n", + " picked += cups[:extra]\n", + " cups[:extra] = []\n", + " return picked\n", + " \n", + "def destination(cups, current) -> Cup:\n", + " \"The cup with label one less than current, or max(cups).\"\n", + " return max((c for c in cups if c < current), default=max(cups))\n", + "\n", + "def clockwise(cups, current) -> Cup:\n", + " \"The cup one clockwise of current.\"\n", + " return cups[(cups.index(current) + 1) % len(cups)]\n", + "\n", + "def place(cups, picked, dest):\n", + " \"Put `picked` after `dest`\"\n", + " i = cups.index(dest) + 1\n", + " cups[i:i] = picked\n", + "\n", "def after(cup, cups) -> int:\n", " \"All the cups after `cup`, in order.\"\n", " i = cups.index(cup) + 1\n", " string = cat(map(str, cups + cups))\n", " return int(string[i:i+len(cups)])\n", - " \n", - "do(23)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "foo = [0,1,2,3,4]\n", - "foo[0:0] = ['hello', 'world']\n", - "foo" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "in24 = data(24)\n", "\n", - "def day24_1(lines: List[str]):\n", - " \"How many tiles are flipped an odd number of times?\"\n", - " counts = Counter(map(follow_hex, lines)).values()\n", - " return quantify(v % 2 for v in counts)\n", - "\n", - "hexdirs = dict(e=(1, 0), w=(-1, 0), ne=(1, -1), sw=(-1, 1), se=(0, 1), nw=(0, -1))\n", - "\n", - "def parse_hex(line) -> List[str]: return re.findall('|'.join(hexdirs), line)\n", - "\n", - "def follow_hex(line):\n", - " x, y = 0, 0\n", - " for d in parse_hex(line):\n", - " dx, dy = hexdirs[d]\n", - " x += dx \n", - " y += dy\n", - " return (x, y)\n", - "\n", - "#####################\n", - "\n", - "def day24_2(lines: List[str], days=100):\n", - " \"How many tiles are black after 100 days of Life?\"\n", - " counts = Counter(map(follow_hex, lines))\n", - " blacks = {c for c in counts if counts[c] % 2}\n", - " with binding(next_generation=next_generation24, cell_deltas=cell_deltas24):\n", - " return len(life(blacks, 100))\n", - "\n", - "def next_generation24(cells) -> Set[Cell]:\n", - " \"\"\"The set of live cells in the next generation.\"\"\"\n", - " counts = neighbor_counts(cells)\n", - " return ({c for c in cells if counts[c] in (1, 2)} |\n", - " {c for c in counts if c not in cells and counts[c] == 2})\n", - "\n", - "@lru_cache()\n", - "def cell_deltas24(d: int): \n", - " return set(hexdirs.values())\n", - " return set(filter(any, product((-1, 0, +1), repeat=d)))\n", - "\n", - "do(24)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "cell_deltas(2)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "test = Counter(mapt(follow_hex, '''sesenwnenenewseeswwswswwnenewsewsw\n", - "neeenesenwnwwswnenewnwwsewnenwseswesw\n", - "seswneswswsenwwnwse\n", - "nwnwneseeswswnenewneswwnewseswneseene\n", - "swweswneswnenwsewnwneneseenw\n", - "eesenwseswswnenwswnwnwsewwnwsene\n", - "sewnenenenesenwsewnenwwwse\n", - "wenwwweseeeweswwwnwwe\n", - "wsweesenenewnwwnwsenewsenwwsesesenwne\n", - "neeswseenwwswnwswswnw\n", - "nenwswwsewswnenenewsenwsenwnesesenew\n", - "enewnwewneswsewnwswenweswnenwsenwsw\n", - "sweneswneswneneenwnewenewwneswswnese\n", - "swwesenesewenwneswnwwneseswwne\n", - "enesenwswwswneneswsenwnewswseenwsese\n", - "wnwnesenesenenwwnenwsewesewsesesew\n", - "nenewswnwewswnenesenwnesewesw\n", - "eneswnwswnwsenenwnwnwwseeswneewsenese\n", - "neswnwewnwnwseenwseesewsenwsweewe\n", - "wseweeenwnesenwwwswnew'''.splitlines()))\n", - "test2 = {c for c in test if test[c] % 2}\n", - "len(test2)\n", - "test2" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "{i: len(life(test2, i)) for i in range(7)}" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from contextlib import contextmanager\n", - "\n", - "@contextmanager\n", - "def binding(**kwds):\n", - " \"Bind global variables in a context; revert to old values on exit.\"\n", - " temp = {k: globals()[k] for k in kwds}\n", - " try:\n", - " globals().update(kwds)\n", - " yield\n", - " finally:\n", - " globals().update(temp)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "foo = 42\n", - "print(foo)\n", - "with bind(foo=1):\n", - " print(foo)\n", - " 1/0\n", - "print(foo)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "foo" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "in25 = 1965712, 19072108\n", - "\n", - "def transform(subj) -> Iterator[int, int]: \n", - " val = 1\n", - " for i in range(1, sys.maxsize):\n", - " val = (val * subj) % 20201227\n", - " yield i, val\n", - " \n", - "def nth_transform(subj, n): return first(val for i, val in transform(subj) if i == n)\n", - "def transform_to(subj, val): return first(i for i, val in transform(subj) if val == final)\n", - "\n", - "def day25_1(keys):\n", - " loopsize = transform_to(7, keys[0])\n", - " return nth_transform(keys[1], loopsize)\n", - "\n", - "do(25, 16881444)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "last(transform(17807724, 8)), last(transform(5764801, 11))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from collections import Counter\n", - "import re\n", - "\n", - "def words(text): return re.findall(\"[a-z']+\", text.lower())\n", - "\n", - "def top(lyrics: str, n=10):\n", - " \"Top n most common words in lyrics.\"\n", - " return Counter(words(lyrics)).most_common(n)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "top('''Na na na na, na na na na, hey hey, goodbye\n", - "He'll never love you, the way that I love you\n", - "'Cause if he did, no no, he wouldn't make you cry\n", - "He might be thrillin' baby but a-my love\n", - "(My love, my love)\n", - "So dog-gone willin', so kiss him\n", - "(I wanna see you kiss him, wanna see you kiss him)\n", - "Go on and kiss him goodbye, now\n", - "Na na na na, hey hey, goodbye\n", - "Na na na na, na na na na, hey hey, goodbye\n", - "Listen to me now\n", - "He's never near you to comfort and cheer you\n", - "When all those sad tears are fallin' baby from your eyes\n", - "He might be thrillin' baby but a-my love\n", - "(My love, my love)\n", - "So dog-gone willin', so kiss him\n", - "(I wanna see you kiss him, I wanna see you kiss him)\n", - "Go on and kiss him goodbye, na na na na, na na na\n", - "Na na na na, hey hey, goodbye\n", - "Hey hey, goodbye\n", - "Na na na na, na na na na, hey hey, goodbye\n", - "Na na na na, na na na na, hey hey, goodbye\n", - "Na na na na, na na na na, hey hey, goodbye\n", - "Hey hey, goodbye\n", - "Na na na na, na na na na, hey hey, goodbye\n", - "Na na na na, na na na na, hey hey, goodbye\n", - "Na na na na, na na na na, hey hey, goodbye\n", - "Hey hey, goodbye\n", - "Na na na na, na na na na, hey hey, goodbye\n", - "Na na na na, na na na na, hey hey, goodbye\n", - "Na na na na, na na na na, hey hey, goodbye''')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "top('''Ain't no sunshine when she's gone\n", - "It's not warm when she's away\n", - "Ain't no sunshine when she's gone\n", - "And she's always gone too long\n", - "Anytime she's goes away\n", - "Wonder this time where she's gone\n", - "Wonder if she's gone to stay\n", - "Ain't no sunshine when she's gone\n", - "And this house just ain't no home\n", - "Anytime she goes away\n", - "And I know, I know, I know, I know\n", - "I know, I know, I know, I know, I know\n", - "I know, I know, I know, I know, I know\n", - "I know, I know, I know, I know, I know\n", - "I know, I know, I know, I know, I know\n", - "I know, I know\n", - "Hey I oughta leave young thing alone\n", - "But ain't no sunshine when she's gone, woh woh\n", - "Ain't no sunshine when she's gone\n", - "Only darkness every day\n", - "Ain't no sunshine when she's gone\n", - "And this house just ain't no home\n", - "Anytime she goes away\n", - "Anytime she goes away\n", - "Anytime she goes away\n", - "Anytime she goes away''')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "top('''Duke, Duke, Duke, Duke of Earl\n", - "Duke, Duke, Duke of Earl\n", - "Duke, Duke, Duke of Earl\n", - "Duke, Duke, Duke of Earl\n", - "Duke, Duke, Duke of Earl\n", - "Duke, Duke, Duke of Earl\n", - "Duke, Duke, Duke of Earl\n", - "Duke, Duke, Duke of Earl\n", - "As I walk through this world\n", - "Nothing can stop the Duke of Earl\n", - "And-a you, you are my girl\n", - "And no one can hurt you, oh no\n", - "Yes-a, I, oh I'm gonna love you, oh oh\n", - "Come on let me hold you darlin'\n", - "'Cause I'm the Duke of Earl\n", - "So hey yea yea yeah\n", - "And when I hold you\n", - "You'll be my Duchess, Duchess of Earl\n", - "We'll walk through my dukedom\n", - "And a paradise we will share\n", - "Yes-a, I, oh I'm gonna love you, oh oh\n", - "Nothing can stop me now\n", - "'Cause I'm the Duke of Earl\n", - "So hey yeah yeah yeah\n", - "Well, I, oh I'm gonna love you, oh oh\n", - "Nothing can stop me now\n", - "'Cause I'm the Duke of Earl\n", - "So hey yeah yeah yeah''')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def cut(times=15):\n", - " nums = {1}\n", - " for _ in range(times):\n", - " nums |= {n + 3 for n in nums}\n", - " return nums\n", - " \n", - "cut()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "'''Her true love, Marian, has issued a challenge. Robin must fire as many arrows as she can, such that each arrow is closer to the center of the target than the previous arrow. For example, if Robin fires three arrows, each closer to the center than the previous, but the fourth arrow is farther than the third, then she is done with the challenge and her score is four.'''" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "arrow()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import random\n", - "from typing import Iterable\n", - "from statistics import mean\n", - "Point = complex\n", - "\n", - "def sample_circle() -> Point:\n", - " \"\"\"Uniform sampling of a point within a circle of radius 1, via rejection.\"\"\"\n", - " point = Point(random.random(), random.random())\n", - " return point if abs(point) <= 1 else sample_circle()\n", - " \n", - "def sample_arrows() -> Iterable[Point]:\n", - " \"\"\"Uniform rejection sampling of a point within a circle of radius 1.\"\"\"\n", - " arrows = []\n", - " while True:\n", - " arrows.append(abs(sample_arrow()))\n", - " if arrows != sorted(arrows, reverse=True):\n", - " return arrows \n", - " \n", - "%time mean(len(sample_arrows()) for _ in range(1_000_000))\n", - "\n", - "That answer is approximately $e$ (2.718281828...). Could $e$ be the exact answer? The Taylor series for $e^x$ is as follows:\n", - "\n", - " $$e^x = \\sum_{i=0}^{\\infty} x^n / n! $$\n", - " \n", - "and thus\n", - "\n", - " $$e = e^1 = \\sum_{i=0}^{\\infty} 1 / n! $$\n", - " \n", - "That makes so much sense now! I worked hard to make sure that we were sampling points uniformly across all the area of the circle\n", - "\n", - "def sample_arrows2() -> Iterable[Point]:\n", - " \"\"\"Uniform rejection sampling of a point within a circle of radius 1.\"\"\"\n", - " arrows = []\n", - " while True:\n", - " arrows.append(abs(int(10 * abs(sample_arrow()))))\n", - " if not monotonic(arrows):\n", - " return arrows \n", - " \n", - "def monotonic(items): \n", - " pairs = (items[i:i + 2] for i in range(len(items) - 1))\n", - " return all(a > b for a, b in pairs) \n", - "\n", - "%time mean(len(sample_arrows2()) for _ in range(1_000_000))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "That answer is approximately $e$ (2.718281828...). Could $e$ be the exact answer? The Taylor series for $e^x$ is as follows:\n", - "\n", - " $$e^x = \\sum_{i=0}^{\\infty} x^n / n! $$\n", - " \n", - "and thus\n", - "\n", - " $$e = e^1 = \\sum_{i=0}^{\\infty} 1 / n! $$\n", - " \n", - "That makes so much sense now! I worked hard to make sure that we were sampling points uniformly across all the area of the circle" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from statistics import mean\n", - "import random" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "N = 100\n", - "\n", - "def candidates(N): return [random.randrange(1000) for _ in range(N)]\n", - "\n", - "def hiring(candidates, test_amount=math.exp(-1), ratio=1.0):\n", - " i = round(test_amount * len(candidates))\n", - " bar = max(candidates[:i])\n", - " return next((c for c in candidates[i:] if c > bar), candidates[-1])\n", - "\n", - "def score(test_amount=math.exp(-1), ratio=1.0, trials=10_000):\n", - " return mean(hiring(candidates(N), test_amount, ratio) for _ in range(trials))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "X = [i / 1000 for i in range(10, 500, 10)]\n", - "Y = [score(test_amount=x, trials=3000) for x in X]\n", - "plt.plot(X, Y, 'o-')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def ants(n, trials=10_000): \n", - " return mean(max(random.random() for a in range(n)) \n", - " for t in range(trials))\n", - "\n", - "X = range(1, 100)\n", - "Y = [ants(x) for x in X]\n", - "plt.plot(X, Y, '.:')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "[f'{n:3d}: {abs(ants(n, 100_000) - n/(n+1)):.4f} ' for n in range(1, 20)]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Lingo" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import random\n", - "from statistics import mean\n", - "from collections import defaultdict\n", - "\n", - "def read_dict(text):\n", - " W = re.findall(r'^[A-Z]{5}$', text, re.M)\n", - " D = defaultdict(list)\n", - " for w in W:\n", - " D[w[0]].append(w)\n", - " return W, D\n", - "\n", - "alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'\n", - "\n", - "W, D = read_dict(open('enable1.txt').read().upper())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "len(W), {L: len(D[L]) for L in alphabet}" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def unique_guesses(n=4):\n", - " random.shuffle(W)\n", - " letters, words = set(), []\n", - " for word in W:\n", - " S = set(word)\n", - " if len(S) == 5 and letters.isdisjoint(S):\n", - " words.append(word)\n", - " letters |= S\n", - " if len(words) == n:\n", - " return words\n", - " return unique_guesses(n, W)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "[unique_guesses() for _ in range(10)]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def possibles(guesses, secret):\n", - " L = secret[0]\n", - " return [w for w in W[L] if feasible(w, guesses)\n", - " \n", + "def day23_2(cupstr): \n", + " cups = play_cups(cupstr, 1_000_000, 100_000_000)\n", " " ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 94, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[278659341, None]" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "def reply(guess, secret):\n", - " regex, ins, outs = '', set(), set()\n", - " for g, s in list(zip(guess, secret)):\n", - " if g == s or g in secret:\n", - " regex += (g if g == s else '.')\n", - " ins.add(g)\n", - " secret = secret.replace(g, '', 1)\n", - " else:\n", - " regex += '.'\n", - " outs.add(g)\n", - " return regex, ins, outs\n", + "do(23, 278659341)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For Part 1, I aimed to be very explicit in my code, and the solution works fine for 9 cups and 100 moves (although it did end up being more lines of code than I wanted/expected). \n", "\n", - "def replies(guesses, secret):\n", - " return [reply(guess, secret) for guess in guesses]\n", + "However, my approach would not be efficient enough to do Part 2; thus it was a poor choice. For now I'll skip Part 2; maybe I'll come back to it later. I had an idea for a representation where each entry in `cups` is either a `list` or a `range` of cups; that way we are only breaking up and/or shifting small lists, not million-element lists. A skip list might also be a good approach." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Day 24: Lobby Layout\n", "\n", - "def consolidate(replies):\n", - " exacts = ''.join(max(reg[i] for reg, _, _ in replies) for i in range(5))\n", - " if '.' not in exacts:\n", - " return exacts, set(exacts)\n", - " letters = set().union(*(L for _, L, _ in replies))\n", - " return exacts, letters\n", + "This puzzle involves a hexagonal grid. The input is a list of directions to follow to identify a destination hex tile that should be flipped from white to black. I recall that Amit Patel of Red Blob Games has [covered hex grids topic thoroughly](https://www.redblobgames.com/grids/hexagons/); I followed his recommendation to use a (pointy) **axial coordinate** system. \n", "\n", - "def average_score(guesses):\n", - " return mean(score(guesses, L) for L in alphabet)\n", - "\n", - "def startswith(L, W=W):\n", - " return [w for w in W if w.startswith(L)]\n", - "\n", - "def matches(exacts, letters, L, W):\n", - " return [w for w in startswith(L, W) and match(w, exacts, letters)]\n", - "\n", - "def match(word, exacts, letters):\n", - " \n", - " \n", - "\n", - "p = pick_unique()\n", - "n = len(set(''.join(p)))\n", - "r = replies(p, 'ALOHA') \n", - "c = consolidate(r)\n", - "m = matches(*c, 'A', W)\n", - "p, n, r, c" + "1. Go through the renovation crew's list and determine which tiles they need to flip. After all of the instructions have been followed, how many tiles are left with the black side up?\n", + "2. Another version of *Life*, but on a hex grid, where a tile is live (black) if it was white and has two black neighbors, or it was black and has 1 or 2 black neighbors. How many tiles will be black after 100 days (generations)?" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 95, "metadata": {}, "outputs": [], "source": [ - "re.findall('.Z...', Wtext)" + "in24 = data(24)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 96, "metadata": {}, "outputs": [], "source": [ - "len(text)" + "def day24_1(lines: List[str]):\n", + " \"How many tiles are flipped an odd number of times?\"\n", + " counts = Counter(map(follow_hex, lines))\n", + " return quantify(counts[tile] % 2 for tile in counts)\n", + "\n", + "hexdirs = dict(e=(1, 0), w=(-1, 0), ne=(1, -1), sw=(-1, 1), se=(0, 1), nw=(0, -1))\n", + "\n", + "def parse_hex(line) -> List[str]: return re.findall('e|w|ne|sw|se|nw', line)\n", + "\n", + "def follow_hex(directions: str):\n", + " \"What (x, y) location do you end up at after following directions?\"\n", + " x, y = 0, 0\n", + " for dir in parse_hex(directions):\n", + " dx, dy = hexdirs[dir]\n", + " x += dx\n", + " y += dy\n", + " return (x, y)\n", + "\n", + "assert parse_hex('wsweesene') == ['w', 'sw', 'e', 'e', 'se', 'ne']\n", + "assert follow_hex('eeew') == (2, 0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I'll use `binding` to temporarily redefine `next_generation` and `cell_deltas` to work with this problem; then call `life`." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 97, "metadata": {}, "outputs": [], "source": [ - "Counter(''.join(W)).most_common(20)" + "def day24_2(lines: List[str], days=100):\n", + " \"How many tiles are black after 100 days of Life?\"\n", + " counts = Counter(map(follow_hex, lines))\n", + " blacks = {tile for tile in counts if counts[tile] % 2}\n", + " with binding(next_generation=next_generation24, \n", + " cell_deltas=cell_deltas24):\n", + " return len(life(blacks, 100))\n", + "\n", + "def next_generation24(cells) -> Set[Cell]:\n", + " \"The set of live cells in the next generation.\"\n", + " counts = neighbor_counts(cells)\n", + " return ({c for c in cells if counts[c] in (1, 2)} |\n", + " {c for c in counts if c not in cells and counts[c] == 2})\n", + "\n", + "@lru_cache()\n", + "def cell_deltas24(d) -> Iterable[Cell]:\n", + " \"The neighbors are the 6 surrounding hex squares.\"\n", + " return hexdirs.values()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 98, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[420, 4206]" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "'fuss'.replace('s', '', 1)" + "do(24, 420, 4206) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Day 25: Combo Breaker\n", + "\n", + "This puzzle involves breaking a cryptographic protocol (whose details I won't describe here).\n", + "\n", + "1. What encryption key is the handshake trying to establish?\n", + "2. The last rule of AoC: there is no Part 2 for Day 25." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 99, "metadata": {}, "outputs": [], "source": [ - "pick()" + "in25 = 1965712, 19072108" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [], + "source": [ + "def transform(subj) -> Iterator[int]:\n", + " \"A stream of transformed values, according to the protocol.\"\n", + " val = 1\n", + " while True:\n", + " val = (val * subj) % 20201227\n", + " yield val\n", + "\n", + "def day25_1(keys):\n", + " \"Find the loopsize for the first key; transform the other key that number of times.\"\n", + " loopsize = first(i for i, val in enumerate(transform(7)) if val == keys[0]) \n", + " return first(val for i, val in enumerate(transform(keys[1])) if i == loopsize)" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[16881444, None]" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "do(25, 16881444)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Postmortem: Timing\n", + "\n", + "Advent of Code suggests that each day's puzzle should run in [15 seconds or less](https://adventofcode.com/2020/about).\n", + "I met that goal, with days 11 and 15 taking about 8 seconds each, days 22 and 25 about 2 seconds, and the rest if the days (and the overall average) being under a second per day. (However, I skipped Part 2 on days 20 and 23.)\n", + "\n", + "Here's a report. Stars in the first column indicate run times on a log scale: 0 stars for under 1/100 seconds up to 4 stars for 10 seconds or more:" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Day Secs. Answers\n", + " === ===== =======\n", + " 1 0.000 [787776, 262738554]\n", + " 2 0.000 [383, 272]\n", + " 3 0.000 [167, 736527114]\n", + " 4 0.001 [237, 172]\n", + " 5 0.000 [906, 519]\n", + " 6 0.001 [6530, 3323]\n", + " 7 0.001 [103, 1469]\n", + " 8 0.008 [1521, 1016]\n", + " 9 0.003 [776203571, 104800569]\n", + " 10 0.000 [2346, 6044831973376]\n", + " *** 11 8.271 [2299, 2047]\n", + " 12 0.001 [439, 12385]\n", + " 13 0.000 [174, 780601154795940]\n", + " * 14 0.063 [11884151942312, 2625449018811]\n", + " *** 15 7.480 [412, 243]\n", + " ** 16 0.145 [21071, 3429967441937]\n", + " ** 17 0.273 [291, 1524]\n", + " 18 0.005 [3885386961962, 112899558798666]\n", + " ** 19 0.262 [190, 311]\n", + " 20 0.001 [15670959891893, None]\n", + " 21 0.001 [2282, 'vrzkz,zjsh,hphcb,mbdksj,vzzxl,ctmzsr,rkzqs,zmhnj']\n", + " *** 22 2.246 [31809, 32835]\n", + " 23 0.000 [278659341, None]\n", + " ** 24 0.724 [420, 4206]\n", + " *** 25 1.827 [16881444, None]\n", + "CPU times: user 21.3 s, sys: 62.1 ms, total: 21.3 s\n", + "Wall time: 21.3 s\n" + ] + } + ], + "source": [ + "import time\n", + "\n", + "def timing(days=range(1, 26)):\n", + " \"Report on timing of `do(day)` for all days.\"\n", + " print(' Day Secs. Answers')\n", + " print(' === ===== =======') \n", + " for day in days:\n", + " t0 = time.time()\n", + " answers = do(day)\n", + " t = time.time() - t0\n", + " if answers != [None, None]:\n", + " stars = '*' * int(3 + math.log(t, 10))\n", + " print(f'{stars:>4} {day:2} {t:6.3f} {answers}')\n", + "\n", + "%time timing()" ] }, { @@ -3043,7 +2652,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.7" + "version": "3.7.6" } }, "nbformat": 4,