diff --git a/ipynb/Advent-2020.ipynb b/ipynb/Advent-2020.ipynb index a0f7e24..20c4a0f 100644 --- a/ipynb/Advent-2020.ipynb +++ b/ipynb/Advent-2020.ipynb @@ -10,17 +10,21 @@ "\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", "\n", - "For each day from 1 to 25, I'll write **four pieces 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).\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). Most days the data comes from a file, read via the function `data`, 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 ass input and returns the answer for part 2.\n", - "- `do(3, 167, 736527114) `: checks that `day3_1(in3) == 167` and `day3_2(in3) == 736527114`.\n", - "\n", - "(During development, I can say just `do(3)` to see the output without checking it.)\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", "\n", "# Day 0: Imports and Utility Functions\n", "\n", - "Before Day 1 I prepared (a) some imports, (b) a way to read the day's data file and to print the output, and (c) some some useful utilities:" + "Preparations prior to Day 1:\n", + "- Some imports.\n", + "- A way to read the day's data file and to print/check the output.\n", + "- Some utilities that are likely to be useful.\n", + "\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`). Traditionally, a lot of problems are of the form \"How many of your input items have property P?\", for which I can do `quantify(inputs, P)` or \"What is the sum of the result of applying F to each input item?\", for which I can do `sum(map(F, inputs))`.\n", + "\n" ] }, { @@ -29,12 +33,16 @@ "metadata": {}, "outputs": [], "source": [ - "import re\n", + "from __future__ import annotations\n", "from collections import Counter, defaultdict, namedtuple, deque\n", - "from itertools import permutations, combinations, cycle, islice\n", + "from itertools import permutations, combinations, cycle, product, islice, chain\n", "from functools import lru_cache\n", "from typing import Dict, Tuple, Set, List, Iterator, Optional\n", - "from sys import maxsize" + "from sys import maxsize\n", + "\n", + "import re\n", + "import ast\n", + "import operator" ] }, { @@ -48,16 +56,17 @@ " sections = open(f'data/advent2020/input{day}.txt').read().rstrip().split(sep)\n", " return [parser(section) for section in sections]\n", " \n", - "def do(n, *answers) -> Tuple[Optional[int], Optional[int]]:\n", - " \"E.g., when n is 3, return [day3_1(in3), day3_2(in3)], and verify answers.\"\n", - " got = [None, None]\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", " g = globals()\n", - " for i in range(2):\n", - " fname = f'day{n}_{i + 1}'\n", + " got = {}\n", + " for part in (1, 2):\n", + " fname = f'day{day}_{part}'\n", " if fname in g: \n", - " got[i] = g[fname](g[f'in{n}'])\n", - " if len(answers) > i: \n", - " assert got[i] == answers[i], f'{fname} expected {answers[i]}; got {got[i]}'\n", + " got[part] = g[fname](g[f'in{day}'])\n", + " if len(answers) >= part: \n", + " assert got[part] == answers[part - 1], (\n", + " f'{fname}(in{day}) got {got[part]}; expected {answers[part - 1]}')\n", " return got" ] }, @@ -75,14 +84,27 @@ " \"Return first item in iterable, or default.\"\n", " return next(iter(iterable), default)\n", "\n", - "def multimap(items) -> dict:\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", - "cat = ''.join" + "def prod(numbers) -> float: # Will be math.prod in Python 3.8, but I'm in 3.7\n", + " \"The product of an iterable of numbers.\" \n", + " result = 1\n", + " for n in numbers:\n", + " result *= n\n", + " return result\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", + "\n", + "cat = ''.join\n", + "flatten = chain.from_iterable\n", + "Char = str # Type used to indicate a single character" ] }, { @@ -101,13 +123,7 @@ "metadata": {}, "outputs": [], "source": [ - "in1: Set[int] = set(data(1, int))\n", - "\n", - "def day1_1(nums):\n", - " \"Find 2 distinct numbers that sum to 2020, and return their product.\"\n", - " return first(x * y for x in nums \n", - " for y in nums & {2020 - x} \n", - " if x != y)" + "in1: Set[int] = set(data(1, int))" ] }, { @@ -116,25 +132,40 @@ "metadata": {}, "outputs": [], "source": [ - "def day1_2(nums):\n", - " \"Find 3 distinct numbers that sum to 2020, and return their product.\"\n", - " return first(x * y * z for x, y in combinations(nums, 2) \n", - " for z in nums & {2020 - x - y} \n", - " if x != z != y)" + "def day1_1(nums):\n", + " \"Find 2 distinct numbers that sum to 2020, and return their product.\"\n", + " return first(x * y \n", + " for x in nums \n", + " for y in nums & {2020 - x} \n", + " if x != y)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, + "outputs": [], + "source": [ + "def day1_2(nums):\n", + " \"Find 3 distinct numbers that sum to 2020, and return their product.\"\n", + " return first(x * y * z \n", + " for x, y in combinations(nums, 2) \n", + " for z in nums & {2020 - x - y} \n", + " if x != z != y)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[787776, 262738554]" + "{1: 787776, 2: 262738554}" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -149,23 +180,32 @@ "source": [ "# Day 2: Password Philosophy\n", "\n", - "1. A password policy is of the form `1-3 b: cdefg` meaning that the password must contain 1 to 3 instances of `b`; `cdefg` is invalid under this policy. How many passwords in your input file are valid according to their policies?\n", - "- JK! The policy actually means that exactly one of positions 1 and 3 must contain the letter `b`. How many passwords are valid according to the new interpretation of the policies?" + "1. A password policy is of the form \"`1-3 b: cdefg`\" meaning that the password must contain 1 to 3 instances of `b`; `cdefg` is invalid under this policy. How many passwords in your input file are valid according to their policies?\n", + "- JK! The policy actually means that exactly one of positions 1 and 3 (1-based) must contain the letter `b`. How many passwords are valid according to the new interpretation of the policies?" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ - "def password_policy(policy) -> tuple:\n", - " \"Given policy='1-3 L: password', return (1, 3, 'L', 'password').\"\n", - " a, b, L, pw = re.findall(r'[^-:\\s]+', policy)\n", + "Policy = Tuple[int, int, Char, str]\n", + "\n", + "def parse_password_policy(line: str) -> Policy:\n", + " \"Given '1-3 b: cdefg', return (1, 3, 'b', 'cdefg').\"\n", + " a, b, L, pw = re.findall(r'[^-:\\s]+', line)\n", " return (int(a), int(b), L, pw)\n", "\n", - "in2: List[tuple] = data(2, password_policy)\n", - "\n", + "in2: List[tuple] = data(2, parse_password_policy)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ "def valid_password(policy) -> bool: \n", " \"Does policy's pw have between a and b instances of letter L?\"\n", " a, b, L, pw = policy\n", @@ -176,30 +216,30 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "def day2_2(policies): return quantify(policies, valid_password_2)\n", "\n", - "def valid_password_2(line) -> bool: \n", + "def valid_password_2(policy) -> bool: \n", " \"Does line's pw have letter L at position a or b (1-based), but not both?\"\n", - " a, b, L, pw = line\n", - " return (L == pw[a-1]) ^ (L == pw[b-1])" + " a, b, L, pw = policy\n", + " return (L == pw[a - 1]) ^ (L == pw[b - 1])" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[383, 272]" + "{1: 383, 2: 272}" ] }, - "execution_count": 9, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -230,21 +270,30 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ - "in3: List[str] = data(3)\n", + "Picture = List[str]\n", "\n", + "in3: Picture = data(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ "def day3_1(rows, dx=3, dy=1, tree='#'): \n", " \"How many trees are on the coordinates on the slope dy/dx?\"\n", - " return quantify(row[dx * y % len(row)] == tree\n", + " return quantify(row[(dx * y) % len(row)] == tree\n", " for y, row in enumerate(rows[::dy]))" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -256,16 +305,16 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[167, 736527114]" + "{1: 167, 2: 736527114}" ] }, - "execution_count": 12, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -291,27 +340,33 @@ " eyr:2024 ecl:brn pid:760753108 byr:1931 hgt:179cm\n", " \n", " \n", - "1. Count the number of valid passports — those that have all seven required fields (byr, ecl, eyr, hcl, hgt, iyr, pid). \n", + "1. Count the number of valid passports — those that have all seven required fields (`byr, ecl, eyr, hcl, hgt, iyr, pid`). \n", "2. Count the number of valid passports — those that have valid values for all required fields (see the rules in `valid_fields`). " ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ - "Passport = dict\n", + "Passport = dict # e.g. {'iyr': '2013', ...}\n", "\n", - "def passport(text: str) -> Passport:\n", + "def parse_passport(text: str) -> Passport:\n", " \"Make a dict of the 'key:val' entries in text.\"\n", " return Passport(re.findall(r'([a-z]+):([^\\s]+)', text))\n", "\n", - "assert passport('''a:1 b:2\n", - "see:3 d:four''') == {'a': '1', 'b': '2', 'see': '3', 'd': 'four'}\n", - "\n", - "in4: List[Passport] = data(4, passport, '\\n\\n') # Passports are separated by blank lines\n", + "assert parse_passport('''a:1 b:two\\nsee:3''') == {'a': '1', 'b': 'two', 'see': '3'}\n", "\n", + "in4: List[Passport] = data(4, parse_passport, '\\n\\n') # Passports are separated by blank lines" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ "required_fields = {'byr', 'ecl', 'eyr', 'hcl', 'hgt', 'iyr', 'pid'}\n", "\n", "def valid_passport(passport) -> bool: return required_fields.issubset(passport)\n", @@ -321,13 +376,13 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ - "def day4_2(passports): return quantify(passports, valid_fields)\n", + "def day4_2(passports): return quantify(passports, valid_passport_fields)\n", "\n", - "def valid_fields(passport) -> bool:\n", + "def valid_passport_fields(passport) -> bool:\n", " '''Validate fields according to the following rules:\n", " byr (Birth Year) - four digits; at least 1920 and at most 2002.\n", " iyr (Issue Year) - four digits; at least 2010 and at most 2020.\n", @@ -347,25 +402,25 @@ " byr=lambda v: 1920 <= int(v) <= 2002,\n", " iyr=lambda v: 2010 <= int(v) <= 2020,\n", " eyr=lambda v: 2020 <= int(v) <= 2030,\n", - " hcl=lambda v: re.match('^#[0-9a-f]{6}$', v),\n", - " ecl=lambda v: v in ('amb', 'blu', 'brn', 'gry', 'grn', 'hzl', 'oth'),\n", - " pid=lambda v: len(v) == 9 and v.isnumeric(),\n", + " hcl=lambda v: re.match('#[0-9a-f]{6}$', v),\n", + " ecl=lambda v: re.match('(amb|blu|brn|gry|grn|hzl|oth)$', v),\n", + " pid=lambda v: re.match('[0-9]{9}$', v),\n", " hgt=lambda v: ((v.endswith('cm') and 150 <= int(v[:-2]) <= 193) or\n", " (v.endswith('in') and 59 <= int(v[:-2]) <= 76)))" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[237, 172]" + "{1: 237, 2: 172}" ] }, - "execution_count": 15, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -380,7 +435,7 @@ "source": [ "# Day 5: Binary Boarding\n", "\n", - "The input is a list of boarding passes, such as `BFFFBBFRRR`. Each boarding pass corrsponds to a **seat ID** using an encoding where B and F stand for the back and front half of the plane; R and L stand for right and left half of a row. The encoding is the same as substituting 0 for F or L and 1 for B or R and treating the result as a binary number.\n", + "The input is a list of boarding passes, such as `BFFFBBFRRR`. Each boarding pass corrsponds to a **seat ID** using an encoding where B and F stand for the back and front half of the remaining part of the plane; R and L stand for right and left half of a row. (The encoding is the same as substituting 0 for F or L, and 1 for B or R, and treating the result as a binary number.)\n", "\n", "1. What is the highest seat ID on a boarding pass?\n", "- What is the one missing seat ID, between the minimum and maximum IDs, that is not on the list of boarding passes?" @@ -388,7 +443,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -398,35 +453,42 @@ "\n", "assert seat_id('FBFBBFFRLR') == 357\n", "\n", - "in5: List[int] = data(5, seat_id)\n", - "\n", + "in5: List[int] = data(5, seat_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ "day5_1 = max # Find the maximum seat id." ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "def day5_2(ids):\n", - " \"Find the one missing seat id.\"\n", + " \"The one missing seat id.\"\n", " [missing] = set(range(min(ids), max(ids))) - set(ids)\n", " return missing" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[906, 519]" + "{1: 906, 2: 519}" ] }, - "execution_count": 18, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -458,14 +520,21 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "in6: List[List[str]] = data(6, str.splitlines, '\\n\\n')\n", "\n", - "assert in6[1] == ['arke', 'qzr', 'plmgnr', 'uriq'] # A group is a list of strs\n", - "\n", + "assert in6[1] == ['arke', 'qzr', 'plmgnr', 'uriq'] # A group is a list of strs" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ "def day6_1(groups): \n", " \"For each group, compute the number of letters that ANYONE got. Sum them.\"\n", " return sum(len(set(cat(group)))\n", @@ -474,7 +543,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -486,16 +555,16 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[6530, 3323]" + "{1: 6530, 2: 3323}" ] }, - "execution_count": 21, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -519,38 +588,43 @@ "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", "\n", - "I wasn't quite sure, but it appears that \"light red\" and \"dark red\" are different colors." + "I wasn't quite sure, but it turns out that \"light red\" and \"dark red\" are different colors." ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "Bag = str\n", + "BagRules = Dict[Bag, Dict[Bag, int]] # {outer: {inner: count, ...}, ...}\n", "\n", "def parse_bag_rule(line: str) -> Tuple[Bag, Dict[Bag, int]]:\n", " \"Return (outer_bag, {inner_bag: num, ...})\"\n", " line = re.sub(' bags?|[.]', '', line) # Remove redundant info\n", " outer, inner = line.split(' contain ')\n", - " return outer, dict(map(parse_bags, inner.split(', ')))\n", + " return outer, dict(map(parse_inner, inner.split(', ')))\n", "\n", - "def parse_bags(text) -> Tuple[Bag, int]:\n", - " \"Return the color and number of bags.\"\n", + "def parse_inner(text) -> Tuple[Bag, int]:\n", + " \"Return the color and number of inner bags.\"\n", " n, bag = text.split(maxsplit=1)\n", " return bag, (0 if n == 'no' else int(n))\n", "\n", - "in7: Dict[Bag, Dict[Bag, int]] = dict(data(7, parse_bag_rule))\n", + "assert parse_inner('3 muted gray') == ('muted gray', 3)\n", "\n", - "# in7 is of the following form:\n", - "assert (dict([parse_bag_rule(\"light gray bags contain 3 shiny gold bags, 1 dark red bag.\"),\n", - " parse_bag_rule(\"shiny gold bags contain 4 bright blue bags\")])\n", - " == {'light gray': {'shiny gold': 3, 'dark red': 1},\n", - " 'shiny gold': {'bright blue': 4}})\n", - "\n", - "assert parse_bags('3 muted gray') == ('muted gray', 3)\n", + "assert (dict([parse_bag_rule(\"shiny gold bags contain 4 bright blue bags\")])\n", + " == {'shiny gold': {'bright blue': 4}})\n", "\n", + "in7: BagRules = dict(data(7, parse_bag_rule))" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ "def day7_1(rules, target='shiny gold'):\n", " \"How many colors of bags can contain the target color bag?\"\"\"\n", " return quantify(contains(bag, target, rules) for bag in rules)\n", @@ -564,30 +638,30 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "def day7_2(rules, target='shiny gold'): return num_contained_in(target, rules)\n", "\n", "def num_contained_in(target, rules) -> int:\n", - " \"How many bags are contained in the target bag?\"\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)" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[103, 1469]" + "{1: 103, 2: 1469}" ] }, - "execution_count": 24, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -610,19 +684,19 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "Instruction = Tuple[str, int] # e.g. ('jmp', +4)\n", "Program = List[Instruction]\n", "\n", - "def instruction(line: str) -> Program:\n", + "def parse_instruction(line: str) -> Instruction:\n", " \"Parse a line of assembly code into an Instruction: an ('opcode', int) pair.\"\n", " opcode, arg = line.split()\n", " return opcode, int(arg)\n", " \n", - "in8: Program = data(8, instruction)\n", + "in8: Program = data(8, parse_instruction)\n", " \n", "def day8_1(program):\n", " \"Execte the program until it loops; then return accum.\"\n", @@ -649,13 +723,14 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "def day8_2(program): \n", " \"Return the accumulator from the first altered program that terminates.\"\n", - " return first(accum for (terminates, accum) in map(run, altered_programs(program))\n", + " programs = altered_programs(program)\n", + " return first(accum for (terminates, accum) in map(run_program, programs)\n", " if terminates)\n", "\n", "def altered_programs(program, other=dict(jmp='nop', nop='jmp')) -> Iterator[Program]:\n", @@ -664,7 +739,7 @@ " if opcode in other:\n", " yield [*program[:i], (other[opcode], arg), *program[i + 1:]]\n", "\n", - "def run(program) -> Tuple[bool, int]:\n", + "def run_program(program) -> Tuple[bool, int]:\n", " \"Run the program until it loops or terminates; return (terminates, accum)\"\n", " pc = accum = 0\n", " executed = set()\n", @@ -683,16 +758,16 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[1521, 1016]" + "{1: 1521, 2: 1016}" ] }, - "execution_count": 27, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -717,23 +792,24 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ - "in9 = data(9, int)\n", + "in9: List[int] = data(9, int)\n", "\n", "def day9_1(nums, p=25):\n", - " \"\"\"Find the first number in the list of numbers (after a preamble of p numbers) \n", + " \"\"\"Find the first number in the list of numbers (after a preamble of p=25 numbers) \n", " which is not the sum of two of the p numbers before it.\"\"\"\n", - " return first(x for i, x in enumerate(nums) if i > p and x not in sum2(nums[i-p:i]))\n", + " return first(x for i, x in enumerate(nums) \n", + " if i > p and x not in twosums(nums[i-p:i]))\n", "\n", - "def sum2(nums): return map(sum, combinations(nums, 2))" + "def twosums(nums): return map(sum, combinations(nums, 2))" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ @@ -742,7 +818,7 @@ " subseq = find_subseq(nums, target)\n", " return max(subseq) + min(subseq)\n", "\n", - "def find_subseq(nums, target) -> deque:\n", + "def find_subseq(nums, target) -> Optional[deque]:\n", " \"Find a contiguous subsequence of nums that sums to target.\"\n", " subseq = deque()\n", " total = 0\n", @@ -750,24 +826,25 @@ " if total < target:\n", " subseq.append(x)\n", " total += x\n", - " if total == target:\n", + " if total == target and len(subseq) >= 2:\n", " return subseq\n", " while total > target:\n", - " total -= subseq.popleft()" + " total -= subseq.popleft()\n", + " return None" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[776203571, 104800569]" + "{1: 776203571, 2: 104800569}" ] }, - "execution_count": 30, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" } @@ -780,43 +857,1063 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Summary" + "# Day 10: Adapter Array\n", + "\n", + "You are given a bunch of *joltage adapters*, each with a listed joltage output; each can take an input source that is 1, 2, or 3 jolts lower than the output. There is a charging outlet rated 0 jolts, and you want to chargwe a device that is 3 jolts higher than the maximum adapter.\n", + "\n", + "1. Find a chain that uses all of your adapters to connect the charging outlet to your device's built-in adapter and count the joltage differences between the charging outlet, the adapters, and your device. What is the number of 1-jolt differences multiplied by the number of 3-jolt differences?\n", + "2. What is the total number of distinct ways you can arrange the adapters to connect the charging outlet to your device?\n", + "\n", + "Note: at first I thought this was a search problem. But then I realized that the only possibility is to increase joltage from source to adapter, so that means the adapters must appear in sorted order. For part 2, some adapters can be left out." ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "in10: List[int] = data(10, int) # Input is the joltage of each adapter\n", + "\n", + "def day10_1(jolts):\n", + " \"\"\"Arrange the joltages in order; count the number of each size difference;\n", + " return the product of 1- and 3-jolt differences.\"\"\"\n", + " jolts = [0, *sorted(jolts), max(jolts) + 3]\n", + " diffs = Counter(jolts[i + 1] - jolts[i] \n", + " for i in range(len(jolts) - 1))\n", + " assert {1, 2, 3}.issuperset(diffs)\n", + " return diffs[1] * diffs[3]" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "def day10_2(jolts): return arrangements(tuple(sorted(jolts)), 0)\n", + "\n", + "@lru_cache(None)\n", + "def arrangements(jolts, prev) -> int:\n", + " \"\"\"The number of ways to attach some of `jolts` to `prev`.\"\"\"\n", + " first, rest = jolts[0], jolts[1:]\n", + " if first - prev > 3:\n", + " return 0\n", + " elif not rest:\n", + " return 1\n", + " else:\n", + " return (arrangements(rest, first) + # Use first\n", + " arrangements(rest, prev)) # Skip first\n", + " \n", + "assert arrangements((3, 6, 9, 12), 0) == 1\n", + "assert arrangements((3, 6, 9, 13), 0) == 0\n", + "assert arrangements((1, 2, 3, 4), 0) == 7" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1: 2346, 2: 6044831973376}" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "do(10, 2346, 6044831973376)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Day 11: Seating System\n", + "\n", + "This is a version of Conway's *Life*, except that:\n", + "- The world is bounded, not infinite. \n", + "- Cells (seats) have three states, not two: *floor* as well as the traditional *occupied* and *empty*.\n", + "- The rules for what changes between occupied and empty in the next generation are different: \n", + "\n", + " - If a seat is empty (`L`) and there are no occupied seats adjacent to it, the seat becomes occupied.\n", + " - If a seat is occupied (`#`) and four or more seats adjacent to it are also occupied, the seat becomes empty.\n", + " - Otherwise, the seat's state does not change.\n", + "\n", + " \n", + "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. " + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "in11: List[str] = data(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "floor, empty, occupied, off = \".L#?\"\n", + "\n", + "Contents = Char # The contents of each location is one of the above 4 characters\n", + "\n", + "class Layout(list):\n", + " \"\"\"A layout of seats (occupied or not) and floor space.\"\"\"\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(self) -> Layout:\n", + " \"The next generation, according to the rules.\"\n", + " seats = (cat(self.next_generation_at(x, y) for x in range(len(self[y])))\n", + " for y in range(len(self)))\n", + " return type(self)(seats)\n", + "\n", + " def next_generation_at(self, x, y) -> Contents:\n", + " \"The contents of location (x, y) in the next generation.\"\n", + " old = self[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 >= self.crowded else\n", + " old)\n", + "\n", + " def neighbors(self, x, y) -> List[Contents]: \n", + " \"The contents of the 8 neighboring locations.\"\n", + " return [self.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": 43, + "metadata": {}, + "outputs": [], + "source": [ + "def day11_2(seats): return Layout2(seats).run().count(occupied)\n", + "\n", + "class Layout2(Layout):\n", + " \"\"\"A layout of seats (occupied or not) and floor space, with new rules.\"\"\"\n", + "\n", + " crowded = 5\n", + " \n", + " def neighbors(self, x, y) -> List[Contents]:\n", + " \"The contents of the nearest visible seat in each of the 8 directions.\"\n", + " return [self.visible(x, dx, y, dy) for dx, dy in self.deltas]\n", + " \n", + " def visible(self, x, dx, y, dy) -> Contents:\n", + " \"The contents of the first visible seat in direction (dx, dy).\"\n", + " for i in range(1, maxsize):\n", + " x += dx; y += dy\n", + " if not (0 <= y < len(self) and 0 <= x < len(self[y])):\n", + " return off\n", + " if self[y][x] is not floor:\n", + " return self[y][x] " + ] + }, + { + "cell_type": "code", + "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 226 ms, sys: 3.2 ms, total: 229 ms\n", - "Wall time: 231 ms\n" + "CPU times: user 9.62 s, sys: 30.7 ms, total: 9.65 s\n", + "Wall time: 9.7 s\n" ] }, { "data": { "text/plain": [ - "{1: [787776, 262738554],\n", - " 2: [383, 272],\n", - " 3: [167, 736527114],\n", - " 4: [237, 172],\n", - " 5: [906, 519],\n", - " 6: [6530, 3323],\n", - " 7: [103, 1469],\n", - " 8: [1521, 1016],\n", - " 9: [776203571, 104800569]}" + "{1: 2299, 2: 2047}" ] }, - "execution_count": 31, + "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "%time {i: do(i) for i in range(1, 10)}" + "%time do(11, 2299, 2047)" + ] + }, + { + "cell_type": "markdown", + "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", + "- `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." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Day 12: Rain Risk \n", + "\n", + "Another problem involving interpreting a kind of assembly language, with navigation instructions for a ship. \n", + "\n", + "1. Figure out where the navigation instructions lead. What is the Manhattan distance between that location and the ship's starting position?\n", + "2. Figure out where the navigation instructions *actually* lead, with the updated interpretation. What is the Manhattan distance between that location and the ship's starting position?\n", + "\n", + "The difference between Part 1 and Part 2 comes down to the initial value of the heading/waypoint, and whether the N/E/W/S commands alter the location or the waypoint. Everything else is the same between the two parts." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "in12: List[Instruction] = data(12, lambda line: (line[0], int(line[1:])))" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "Point = Heading = Tuple[int, int]\n", + "\n", + "directions = dict(N=(0, 1), E=(1, 0), S=(0, -1), W=(-1, 0))\n", + "\n", + "def navigate(instructions, loc=(0, 0), heading=directions['E']) -> Point:\n", + " \"Follow instructions to change ship's loc and heading; return final loc.\"\n", + " for op, n in instructions:\n", + " if op == 'R': heading = turn(n, *heading)\n", + " elif op == 'L': heading = turn(-n, *heading)\n", + " elif op == 'F': loc = go(n, *loc, *heading)\n", + " else: loc = go(n, *loc, *directions[op])\n", + " return loc\n", + "\n", + "def turn(degrees, x, y) -> Heading:\n", + " \"Turn `degrees` from the current (x, y) heading.\"\n", + " return (x, y) if degrees % 360 == 0 else turn(degrees - 90, y, -x)\n", + " \n", + "def go(n, x, y, dx, dy) -> Point: \n", + " \"Go n steps in the (dx, dy) direction from (x, y).\"\n", + " return (x + n * dx, y + n * dy)\n", + "\n", + "def manhatten_distance(point) -> int: return sum(map(abs, point))\n", + "\n", + "def day12_1(instructions): return manhatten_distance(navigate(instructions))" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "def navigate2(instructions, loc=(0, 0), way=(10, 1)) -> Point:\n", + " \"Follow updated instructions to change ship's loc and waypoint; return final loc.\"\n", + " for op, n in instructions:\n", + " if op == 'R': way = turn(n, *way)\n", + " elif op == 'L': way = turn(-n, *way)\n", + " elif op == 'F': loc = go(n, *loc, *way)\n", + " else: way = go(n, *way, *directions[op])\n", + " return loc\n", + "\n", + "def day12_2(instructions): return manhatten_distance(navigate2(instructions))" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1: 439, 2: 12385}" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "do(12, 439, 12385)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Day 13: Shuttle Search\n", + "\n", + "A bus with ID *d* leaves the terminal at times 0, *d*, 2*d*, 3*d*, ... You are given bus IDs and an earliest time you can leave.\n", + "1. What is the ID of the earliest bus you can take, multiplied by the number of minutes you'll need to wait for that bus?\n", + "2. What is the earliest timestamp such that all of the listed bus IDs depart at offsets matching their positions in the list?" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "x = 0\n", + "in13: Tuple[int] = (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)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "def day13_1(ids, start=1000001):\n", + " \"Find the id of the earliest bus after start; return id * wait.\"\n", + " ids = set(ids) - {x}\n", + " id = min(ids, key=lambda id: wait(id, start))\n", + " return id * wait(id, start)\n", + "\n", + "def wait(id, t): \n", + " \"How long you have to wait from t for bus id.\"\n", + " return 0 if t % id == 0 else id - t % id" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here's a brute-force solution for Part 2 that works for the simple test cases:" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "def day13_2(ids):\n", + " \"Find the time where all the buses arrive at the right offsets.\"\n", + " schedule = {t: id for t, id in enumerate(ids) if id != x}\n", + " step = schedule[0]\n", + " return first(t for t in range(0, maxsize, step) \n", + " if all(wait(schedule[i], t) == i for i in schedule))\n", + "\n", + "assert day13_2((7,13,x,x,59,x,31,19)) == 1068781\n", + "assert day13_2((1789,37,47,1889)) == 1202161486" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "However, it is clear this will be too slow for the real input data. Instead of looking at every multiple of the first number, I'll incrementally update the `step` as we go through the numbers. Out of all the puzzles so far, this is the one I had to think most carefully about. For each bus id, we want to find a time where we get that id right, then step the time by a multiple of all the ids encountered so far:" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1: 174, 2: 780601154795940}" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def day13_2(ids):\n", + " \"Find the time where all the buses arrive at the right offsets.\"\n", + " time = 0\n", + " step = 1\n", + " schedule = {t: id for t, id in enumerate(ids) if id != x}\n", + " for t in schedule:\n", + " while wait(schedule[t], time + t):\n", + " time += step\n", + " step *= schedule[t]\n", + " return time\n", + "\n", + "do(13, 174, 780601154795940)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Day 14: Docking Data\n", + "\n", + "Another \"interpret assembly code\" puzzle, with two different versions of the instructions (which I won't describe here).\n", + "\n", + "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`." + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "def parse_docking(line: str) -> tuple:\n", + " \"Parse 'mask = XX10' to ('mask', 'XX10') and 'mem[8] = 11' to (8, 11)\"\n", + " if line.startswith('mask'):\n", + " return ('mask', line.split()[-1])\n", + " else:\n", + " return ints(line)\n", + "\n", + "in14 = data(14, parse_docking)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "Memory = Dict[int, int]\n", + "\n", + "def run_docking(program) -> Memory:\n", + " \"Execute the program and return memory.\"\n", + " mask = bin36(0)\n", + " mem = defaultdict(int)\n", + " for addr, val in program:\n", + " if addr == 'mask':\n", + " mask = val\n", + " else:\n", + " mem[addr] = int(cat(m if m in '01' else v\n", + " for m, v in zip(mask, bin36(val))),\n", + " base=2)\n", + " return mem\n", + "\n", + "def bin36(i) -> str: return f'{i:036b}'\n", + "\n", + "def day14_1(program): return sum(run_docking(program).values())" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "def day14_2(program): return sum(run_docking2(program).values())\n", + " \n", + "def run_docking2(program) -> Memory:\n", + " \"Execute the program using version 2 instructions and return memory.\"\n", + " mask = '0' * 36\n", + " mem = defaultdict(int)\n", + " for addr, val in program:\n", + " if addr == 'mask':\n", + " mask = val\n", + " else:\n", + " addr = cat(a if m == '0' else '1' if m == '1' else '{}'\n", + " for m, a in zip(mask, bin36(addr)))\n", + " for bits in product('01', repeat=addr.count('{')):\n", + " mem[int(addr.format(*bits), base=2)] = val\n", + " return mem" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1: 11884151942312, 2: 2625449018811}" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "do(14, 11884151942312, 2625449018811)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Day 15: Rambunctious Recitation\n", + "\n", + "This puzzle involves a game where players speak a new number each turn, based on previous numbers.\n", + "\n", + "1. Given your starting numbers, what will be the 2020th number spoken?\n", + "2. Given your starting numbers, what will be the 30,000,000th number spoken?" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "in15 = 10,16,6,0,1,17" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "def day15_1(starting: Tuple[int], nth=2020) -> int:\n", + " \"Return the nth (1-based) number spoken.\"\n", + " last = starting[-1]\n", + " # `spoken` is a mapping of {number: turn_when_last_spoken}\n", + " spoken = defaultdict(int, {n: t for t, n in enumerate(starting[:-1])})\n", + " for t in range(len(starting), nth):\n", + " new = 0 if last not in spoken else t - 1 - spoken[last]\n", + " spoken[last] = t - 1\n", + " last = new\n", + " return last\n", + " \n", + "assert day15_1((0, 3, 6), 2020) == 436" + ] + }, + { + "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!\" Can 30 million be done in 15 seconds, which [AoC's about page](https://adventofcode.com/2020/about) says is the maximum run time? I'm not sure; let's try it:" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "def day15_2(starting): return day15_1(starting, nth=30_000_000)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 11.5 s, sys: 273 ms, total: 11.8 s\n", + "Wall time: 11.8 s\n" + ] + }, + { + "data": { + "text/plain": [ + "{1: 412, 2: 243}" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%time do(15, 412, 243)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Day 16: Ticket Translation\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", + "First parse the input file, introducing the class `TicketData` to hold the three parts of the input file (the fields, your ticket, and nearby tickets), and the class `Sets` for a tuple of ranges or other set-like objects, so that we can easily test a number is an element of any one of a number of possibilities. For Part 1, just go through the ticket values and see which values are not in any range. " + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "TicketData = namedtuple('TicketData', 'fields, your, nearby')\n", + "\n", + "Ticket = ints # A ticket is a tuple of ints\n", + "\n", + "class Sets(tuple):\n", + " \"A tuple of set-like objects (such as ranges); supports `in`.\"\n", + " 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", + " your=Ticket(your[1]), \n", + " nearby=[Ticket(line) for line in nearby[1:]])\n", + "\n", + "def parse_ticket_line(line: str) -> Tuple[str, Sets]:\n", + " \"Parse 'row: 10-20 or 30-40' to ('row', Sets((range(10, 21), range(30, 41)))).\"\n", + " field = line.split(':')[0]\n", + " 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'))" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "def day16_1(ticket_data):\n", + " \"The sum of the invalid entries in the nearby tickets.\"\n", + " ranges = Sets(ticket_data.fields.values())\n", + " return sum(v for ticket in ticket_data.nearby for v in ticket\n", + " if v not in ranges)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For part 2, we're playing a simplified variant of Sudoku:\n", + "- First find the valid tickets. \n", + "- Then start with the assumption that any field name is `possible` for any index number in the tickets.\n", + "- Determine what field names are invalid for what ticket index numbers.\n", + "- Remove the field name from the possibilities for that index, and\n", + " - If there is only one possible field name left, then remove it from all other index positions." + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [], + "source": [ + "def valid_ticket(ticket, ranges) -> bool: return all(v in ranges for v in ticket)\n", + " \n", + "def decode_tickets(ticket_data) -> Dict[str, int]:\n", + " \"Return a mapping of {field_name: field_number} (index into ticket).\"\n", + " 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", + " 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", + "\n", + "def invalid_fields(valid, fields) -> Iterable[Tuple[str, int]]:\n", + " \"Yield (field_name, field_number) for all invalid fields.\"\n", + " return ((field_name, i) for ticket in valid for i in range(len(ticket))\n", + " for field_name in fields \n", + " if ticket[i] not in fields[field_name])\n", + "\n", + "def eliminate_others(possible, i):\n", + " \"Eliminate possible[i] from all other possible[j].\"\n", + " for j in range(len(possible)):\n", + " if j != i:\n", + " possible[j] -= possible[i]\n", + "\n", + "def day16_2(ticket_data):\n", + " \"The product of the 6 fields that start with 'departure'.\"\n", + " code = decode_tickets(ticket_data)\n", + " return prod(ticket_data.your[code[field]] \n", + " for field in code if field.startswith('departure'))" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1: 21071, 2: 3429967441937}" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "do(16)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "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." + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "in17: Picture = '''\n", + "##.#....\n", + "...#...#\n", + ".#.#.##.\n", + "..#.#...\n", + ".###....\n", + ".##.#...\n", + "#.##..##\n", + "#.####..'''.strip().splitlines()" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "Cell = tuple # of (x, y, z) int coordinates\n", + "\n", + "def day17_1(picture, n=6):\n", + " \"How many cells are active in the nth generation?\"\n", + " cells = parse_cells(picture)\n", + " for g in range(n):\n", + " cells = next_generation(cells)\n", + " return len(cells)\n", + "\n", + "def parse_cells(picture, active='#') -> Set[Cell]:\n", + " \"Convert a 2-d picture into a set of 3-d active cells.\"\n", + " return {(x, y, 0) for (y, row) in enumerate(picture)\n", + " for x, cell in enumerate(row) if cell is active}\n", + "\n", + "def next_generation(cells) -> Set[Cell]:\n", + " \"\"\"The set of live cells in the next generation.\"\"\"\n", + " return {cell for cell, count in neighbor_counts(cells).items()\n", + " if count == 3 or (count == 2 and cell in cells)}\n", + "\n", + "def neighbor_counts(cells) -> Dict[Cell, int]:\n", + " \"The number of live neighbors for each cell that has neighbors.\"\n", + " return Counter(flatten(map(neighbors, cells)))\n", + "\n", + "deltas3d = set(product((-1, 0, +1), repeat=3)) - {(0, 0, 0)}\n", + "\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 deltas3d]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Part 2 asks us to move to 4 dimensions. I'll generalize the previous code to work in 3 or 4 dimensions:" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "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", + "def day17_2(picture, n=6, d=4):\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)]]" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1: 291, 2: 1524}" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "do(17, 291, 1524)" + ] + }, + { + "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 different. I could have used a parsing framework, but I decided to do it all from scratch.\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?" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [], + "source": [ + "def parse_expr(line) -> tuple: \n", + " \"Parse an expression: '2 + 3 * 4' => (2, '+', 3, '*', 4).\"\n", + " return ast.literal_eval(re.sub('([+*])', r\",'\\1',\", line))\n", + "\n", + "in18 = data(18, parse_expr)" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [], + "source": [ + "operators = {'+': operator.add, '*': operator.mul}\n", + "\n", + "def evaluate(expr) -> int:\n", + " \"Evaluate an expression under left-to-right rules.\"\n", + " if isinstance(expr, int):\n", + " return expr\n", + " else:\n", + " a, op, b, *rest = expr\n", + " x = operators[op](evaluate(a), evaluate(b))\n", + " return x if not rest else evaluate((x, *rest))\n", + " \n", + "def day18_1(exprs): return sum(map(evaluate, exprs))" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [], + "source": [ + "def evaluate2(expr) -> int:\n", + " \"Evaluate an expression under addition-first rules.\"\n", + " if isinstance(expr, int):\n", + " return expr\n", + " else:\n", + " expr = list(expr) # Make expr mutable\n", + " while '+' in expr: # Change [... 3, '+', 4 ...] to [... 7 ...]\n", + " i = expr.index('+')\n", + " expr[i-1:i+2] = [evaluate2(expr[i - 1]) + evaluate2(expr[i + 1])]\n", + " return prod(evaluate2(x) for x in expr if x not in operators)\n", + " \n", + "def day18_2(exprs): return sum(map(evaluate2, exprs))" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1: 3885386961962, 2: 112899558798666}" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "do(18, 3885386961962, 112899558798666)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Summary, and Timing\n", + "\n", + "So far, two of the puzzles run slowly (but under the 15 second cap). All the other 16 puzzles combined run in under a second total." + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 817 ms, sys: 5.42 ms, total: 823 ms\n", + "Wall time: 825 ms\n" + ] + }, + { + "data": { + "text/plain": [ + "{1: {1: 787776, 2: 262738554},\n", + " 2: {1: 383, 2: 272},\n", + " 3: {1: 167, 2: 736527114},\n", + " 4: {1: 237, 2: 172},\n", + " 5: {1: 906, 2: 519},\n", + " 6: {1: 6530, 2: 3323},\n", + " 7: {1: 103, 2: 1469},\n", + " 8: {1: 1521, 2: 1016},\n", + " 9: {1: 776203571, 2: 104800569},\n", + " 10: {1: 2346, 2: 6044831973376},\n", + " 12: {1: 439, 2: 12385},\n", + " 13: {1: 174, 2: 780601154795940},\n", + " 14: {1: 11884151942312, 2: 2625449018811},\n", + " 16: {1: 21071, 2: 3429967441937},\n", + " 17: {1: 291, 2: 1524},\n", + " 18: {1: 3885386961962, 2: 112899558798666},\n", + " 19: {},\n", + " 20: {},\n", + " 21: {},\n", + " 22: {},\n", + " 23: {},\n", + " 24: {},\n", + " 25: {}}" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "advent = set(range(1, 26))\n", + "slow = {11, 15}\n", + "\n", + "def doall(days): return {i: do(i) for i in days}\n", + "\n", + "%time doall(advent - slow) " + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 10.6 s, sys: 41.2 ms, total: 10.6 s\n", + "Wall time: 10.7 s\n" + ] + }, + { + "data": { + "text/plain": [ + "{1: 2299, 2: 2047}" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%time do(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 10.9 s, sys: 254 ms, total: 11.1 s\n", + "Wall time: 11.2 s\n" + ] + }, + { + "data": { + "text/plain": [ + "{1: 412, 2: 243}" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%time do(15)" ] } ],