Advent of Code 2021.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "50407312",
   "metadata": {},
   "source": [
    "# Advent of Code 2021 - APL\n",
    "\n",
    "[Advent of Code](https://adventofcode.com/) is a daily programming puzzle\n",
    "challenge published each December. The puzzles are pretty easy for experienced\n",
    "programmers, so they're a great way to play around with new programming\n",
    "languages and tools. This year I'm trying out\n",
    "[APL](https://en.wikipedia.org/wiki/APL_(programming_language)), a famously\n",
    "terse array language from the 60s. You may have seen its memeable program for\n",
    "[Conway's game of life](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "78f8656a",
   "metadata": {},
   "outputs": [],
   "source": [
    "gol ← {≢⍸⍵}⌺3 3∊¨3+0,¨⊢ ⍝ Generate the next generation 🤯"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d94842b",
   "metadata": {},
   "source": [
    "A few people expressed interest, so about halfway through December I decided\n",
    "to try publishing a Jupyter notebook with my solutions in literate programming\n",
    "fashion. Caveat that I'm a complete APL newb so some of my answers may be\n",
    "really bad/ugly! But I'm having fun. After a few weeks, the funny symbols are\n",
    "starting to make some sense, and I'm contemplating buying a special keyboard..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6cfccec",
   "metadata": {},
   "source": [
    "## Resources\n",
    "\n",
    "[Dyalog](https://www.dyalog.com/) seems to be the APL that most people use.\n",
    "Some good online resources are [APLcart](https://aplcart.info/),\n",
    "[Learning APL](https://xpqz.github.io/learnapl/), and\n",
    "[Mastering Dyalog APL](https://mastering.dyalog.com/README.html).\n",
    "\n",
    "A few days in, YouTube's algorithm told me about another crazy person solving\n",
    "AoC in APL! [code_report](https://www.youtube.com/c/codereport) seems to be much\n",
    "better at it and for the first few days, I compared notes with their videos\n",
    "and learned a ton."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "277e7b36",
   "metadata": {},
   "source": [
    "## Day 1\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/1)\n",
    "\n",
    "### Part 1\n",
    "\n",
    "Today we're just supposed to count increasing numbers in a list, which takes\n",
    "all of 5 characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "032091c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "test1←199 200 208 210 200 207 240 269 260 263"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "07658e3f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">7\n",
       "</span>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+/2</test1 ⍝ reduce test1 pairwise on < then sum the resulting boolean array"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4de10808",
   "metadata": {},
   "source": [
    "Note that APL is read right to left. The parser is really, really basic, and\n",
    "I keep shooting myself in the foot by forgetting parentheses.\n",
    "\n",
    "The pinacle of APL style is \"tacit\" programming involving just \"trains\" of\n",
    "functions and operators smushed together with no explicit arguments. We can\n",
    "store and reuse the solution for day 1, part 1, thusly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "4fefe893",
   "metadata": {},
   "outputs": [],
   "source": [
    "day1_1←+/2</⊢ ⍝ the ⊢ means \"I'm with stupid\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "5415a8b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">7\n",
       "</span>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day1_1 test1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bea8742",
   "metadata": {},
   "source": [
    "Reading stuff from a file took embarrasingly long to figure out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "2b25b368",
   "metadata": {},
   "outputs": [],
   "source": [
    "data1←⍎¨⊃⎕NGET 'day1-input.txt' 1 ⍝ read lines and eval each one turning strings to numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "14e2c1b2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1390\n",
       "</span>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day1_1 data1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3cc3e66",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Instead we need to sum every three adjacent elements and then count increases,\n",
    "which takes a whole 8 characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "355db889",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">5\n",
       "</span>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+/2</3+/test1 ⍝ reduce test1 on 3-wise sums, pairwise compare, and sum increases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "b7d78888",
   "metadata": {},
   "outputs": [],
   "source": [
    "day1_2←+/2</3+/⊢"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "55cfbb31",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1457\n",
       "</span>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day1_2 data1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4985843d",
   "metadata": {},
   "source": [
    "## Day 2\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/2)\n",
    "\n",
    "Today we have to deal with words to drive a submarine around. APL strings are\n",
    "(predictably) just arrays, and there don't seem to be special string libraries.\n",
    "So let's turn this all into numbers to simplify life.\n",
    "\n",
    "We'll use a \"dfn\" i.e. a function to parse lines. The dfn grammar is powerful\n",
    "enough that once you understand it, you can basically use APL as a terrible\n",
    "functional language."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "41466d79",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "parse_sub_command←{\n",
    "  ⍝ converts a command like 'forward 5' into two numbers\n",
    "  dir delta←' '(≠⊆⊢)⍵      ⍝ split on space (i.e. partition on not-equal ' ')\n",
    "  dir≡'forward':(⍎delta)0  ⍝ 'forward x': x 0\n",
    "  dir≡'down':0(⍎delta)     ⍝ 'down x': 0 x\n",
    "  0(-⍎delta)               ⍝ 'up x': 0 -x\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "5a7e401e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───┬───┬───┬────┬───┬───┐\n",
       "│5 0│0 5│8 0│0 ¯3│0 8│2 0│\n",
       "└───┴───┴───┴────┴───┴───┘\n",
       "</span>"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test2←parse_sub_command¨⊃⎕NGET 'day2-test.txt' 1 ⍝ map parser over lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "3da05ba9",
   "metadata": {},
   "outputs": [],
   "source": [
    "data2←parse_sub_command¨⊃⎕NGET 'day2-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4670253",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "First we're supposed to move the sub, then return its position times its\n",
    "depth to prove we parsed the commands ok. We can just add up our tuples\n",
    "then multiply the components."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "07f0bc07",
   "metadata": {},
   "outputs": [],
   "source": [
    "day2_1←×/∘↑(+/⊢) ⍝ sum reduce, unbox, then multiply"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "70614eef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">150\n",
       "</span>"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day2_1 test2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "12b37f97",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1938402\n",
       "</span>"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day2_1 data2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5f1cee0",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "jk actually there's another state variable aim. We can make this variable\n",
    "explicit using a scan which is a reduce that gives you partial answers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "94f8c08b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 5 5 2 10 10\n",
       "</span>"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+\\2⊃¨test2 ⍝ + scan over seconds of test2 (i.e. up/down amounts)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79cbb7e5",
   "metadata": {},
   "source": [
    "So to get depth we multiply aim by the X for forward commands, then sum.\n",
    "Horizontal pos is just the sum of the firsts as before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "e584c936",
   "metadata": {},
   "outputs": [],
   "source": [
    "day2_2←{(+/⊃¨⍵)×+/(+\\2⊃¨⍵)×(⊃¨⍵)} ⍝ sum aim×X, then multiply horizontal pos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "015a589a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">900\n",
       "</span>"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day2_2 test2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "301866c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1947878632\n",
       "</span>"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day2_2 data2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6ccc5e2",
   "metadata": {},
   "source": [
    "If you wanted you could probably trim some characters and write this tacitly\n",
    "but it's already needlessly obtuse imo, and reads better with some names for\n",
    "things."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "bf96c4cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "day2_2←{\n",
    "  forward up_down←↓⍉↑⍵ ⍝ forward is firsts, up_down is seconds \n",
    "  aim←+\\up_down        ⍝ aim is sum of ups and downs\n",
    "  depth←+/aim×forward  ⍝ depths are sum of aim times forward\n",
    "  pos←+/forward        ⍝ pos is sum of forward\n",
    "  depth×pos\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "b6cdd0c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">900\n",
       "</span>"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day2_2 test2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afd40b5f",
   "metadata": {},
   "source": [
    "## Day 3\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/3)\n",
    "\n",
    "Today our data is a list of binary numbers we need to look at bitwise,\n",
    "so we'll want that as a bit matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "134526cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 1 0 0\n",
       "1 1 1 1 0\n",
       "1 0 1 1 0\n",
       "1 0 1 1 1\n",
       "1 0 1 0 1\n",
       "0 1 1 1 1\n",
       "0 0 1 1 1\n",
       "1 1 1 0 0\n",
       "1 0 0 0 0\n",
       "1 1 0 0 1\n",
       "0 0 0 1 0\n",
       "0 1 0 1 0\n",
       "</span>"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test3←↑⍎¨¨⊃⎕NGET 'day3-test.txt' 1 ⍝ mix (unbox as rows) eval'd digits from lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "00bb0e2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "data3←↑⍎¨¨⊃⎕NGET 'day3-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c33e8af5",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "We're supposed to form two binary numbers by taking the most and least\n",
    "commmon bits each in each position. We can sum bits in each column to\n",
    "find the most common bit, e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "4470603b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 0 1 1 0\n",
       "</span>"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2÷⍨≢test3)<+⌿test3 ⍝ bit mask where 6 < column sums of test3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fc0bc46",
   "metadata": {},
   "source": [
    "APL has fancy operators for base conversion too so this can be smushed\n",
    "into another ridiculous one liner. It could even probably be _more_ condensed,\n",
    "in case it's already too readable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "6d50da86",
   "metadata": {},
   "outputs": [],
   "source": [
    "day3_1←2⊥((2÷⍨(≢⊢))<+⌿)×2⊥(2÷⍨(≢⊢))>+⌿  ⍝ sorry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "2cdc180b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">198\n",
       "</span>"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day3_1 test3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "b4960951",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">3429254\n",
       "</span>"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day3_1 data3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "803053cf",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Now we gotta find a row in our bit matrix, by taking only rows with the majority\n",
    "bit in the first position, then from those only rows with the majority bit in\n",
    "the second position, and so on until we only have one row left. This requires\n",
    "iteratively filtering a set of things which, unsurprisingly, we can do in one\n",
    "line of terrible code. (Sorry.)\n",
    "\n",
    "Finding the majority bit in the leftmost position is easy. Using ≤ means that\n",
    "when there are an equal number of 0s and 1s we prefer 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "316bcacb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⊃((2÷⍨(≢⊢))≤+⌿)test3  ⍝ take first from bit mask where 6 ≤ column sums"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a5824fd",
   "metadata": {},
   "source": [
    "Here is one way to get the first (leftmost) bit of each row."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "367c27c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 1 1 1 1 0 0 1 1 1 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⊣/test3  ⍝ i.e. first column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "30c0c366",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 1 1 1 1 0 0 1 1 1 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(⊃((2÷⍨(≢⊢))≤+⌿)test3)=⊣/test3  ⍝ bit mask of rows matching majority bit..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "0db23cc1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 1 1 1 0\n",
       "1 0 1 1 0\n",
       "1 0 1 1 1\n",
       "1 0 1 0 1\n",
       "1 1 1 0 0\n",
       "1 0 0 0 0\n",
       "1 1 0 0 1\n",
       "</span>"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((⊃((2÷⍨(≢⊢))≤+⌿)test3)=⊣/test3)⌿test3  ⍝ select just the matching rows"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd84121e",
   "metadata": {},
   "source": [
    "Now we just need to rotate the masks and then iterate this n times\n",
    "where n is the number of bits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "1e649bcd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 1 1 0 1\n",
       "0 1 1 0 1\n",
       "0 1 1 1 1\n",
       "0 1 0 1 1\n",
       "1 1 0 0 1\n",
       "0 0 0 0 1\n",
       "1 0 0 1 1\n",
       "</span>"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1⌽((⊃((2÷⍨(≢⊢))≤+⌿)test3)=⊣/test3)⌿test3  ⍝ rotate left"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "f642a04e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 0 1 1 1\n",
       "</span>"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "({1⌽((⊃((2÷⍨(≢⊢))≤+⌿)⍵)=⊣/⍵)⌿⍵}⍣5)test3  ⍝ star dot means do 5 times"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55672762",
   "metadata": {},
   "source": [
    "This idea almost works, except we have to deal with the case where there is\n",
    "just one match left. Then we need to keep it for the next iteration whether or\n",
    "not its current bit is 1 (the tiebreaker). Also, our result will actually be a\n",
    "2d matrix with one row; the , operator converts it back down to a vector.\n",
    "\n",
    "Now we can do this again for the minority bits and then convert to decimal\n",
    "and multiply to get the answer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "id": "f5dea755",
   "metadata": {},
   "outputs": [],
   "source": [
    "o2_rating←,{({1⌽(((⊃((2÷⍨(≢⊢))≤+⌿)⍵)=⊣/⍵)∨((≢⍵)=1))⌿⍵}⍣(2⊃⍴⍵))⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "id": "b75af373",
   "metadata": {},
   "outputs": [],
   "source": [
    "co2_rating←,{({1⌽(((⊃((2÷⍨(≢⊢))>+⌿)⍵)=⊣/⍵)∨((≢⍵)=1))⌿⍵}⍣(2⊃⍴⍵))⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "id": "b19c0416",
   "metadata": {},
   "outputs": [],
   "source": [
    "day3_2←2⊥o2_rating×2⊥co2_rating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "id": "547b5522",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">230\n",
       "</span>"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day3_2 test3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "id": "da051796",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">5410338\n",
       "</span>"
      ]
     },
     "execution_count": 232,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day3_2 data3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ae2a953",
   "metadata": {},
   "source": [
    "## Day 4\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/4)\n",
    "\n",
    "We're playing bingo today. Calls are on the first input line, and\n",
    "cards follow separated by blank lines. Rather than try to parse this\n",
    "into one array and unbox it again later, we'll just split it out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "id": "1346fcdb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">7 4 9 5 11 17 23 2 0 14 21 24 10 16 13 6 15 25 12 22 18 20 8 19 3 26 1\n",
       "</span>"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test4_calls←⍎¨','(≠⊆⊢)⊃⊃⎕NGET 'day4-test.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "id": "20747df4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">22 13 17 11  0\n",
       " 8  2 23  4 24\n",
       "21  9 14 16  7\n",
       " 6 10  3 18  5\n",
       " 1 12 20 15 19\n",
       "              \n",
       " 3 15  0  2 22\n",
       " 9 18 13 17  5\n",
       "19  8  7 25 23\n",
       "20 11 10 24  4\n",
       "14 21 16 12  6\n",
       "              \n",
       "14 21 17 24  4\n",
       "10 16 15  9 19\n",
       "18  8 23 26 20\n",
       "22 11 13  6  5\n",
       " 2  0 12  3  7\n",
       "</span>"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test4_cards←↑↑⍎¨¨{((''≢⊢)¨⍵)⊆⍵}2↓⊃⎕NGET'day4-test.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "id": "10c7b0ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "data4_calls←⍎¨','(≠⊆⊢)⊃⊃⎕NGET 'day4-input.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "id": "526b99a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "data4_cards←↑↑⍎¨¨{((''≢⊢)¨⍵)⊆⍵}2↓⊃⎕NGET'day4-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbcf756b",
   "metadata": {},
   "source": [
    "We'll be using 5x5 bit matrices to match called positions.\n",
    "In this variant of bingo, diagonals don't count, so we just need\n",
    "to sum up 1s in each row and column to detect bingos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "id": "78aa25dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "bingo←∨/5=((+/⊢),+⌿)  ⍝ or over boolean 5 = row sums cat col sums"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9aa4e326",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "We compute bit matrices of marked numbers for each prefix of calls."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 349,
   "id": "071d5077",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─┬───┬─────┬───────┬──────────┐\n",
       "│7│7 4│7 4 9│7 4 9 5│7 4 9 5 11│\n",
       "└─┴───┴─────┴───────┴──────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 349,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5↑,\\test4_calls  ⍝ e.g. scan cat to get prefixes of calls (5 shown for example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 352,
   "id": "c250502e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 0 0 0\n",
       "0 0 0 1 0\n",
       "0 1 0 0 1\n",
       "0 0 0 0 0\n",
       "0 0 0 0 0\n",
       "         \n",
       "0 0 0 0 0\n",
       "1 0 0 0 0\n",
       "0 0 1 0 0\n",
       "0 0 0 0 1\n",
       "0 0 0 0 0\n",
       "         \n",
       "0 0 0 0 1\n",
       "0 0 0 1 0\n",
       "0 0 0 0 0\n",
       "0 0 0 0 0\n",
       "0 0 0 0 1\n",
       "</span>"
      ]
     },
     "execution_count": 352,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+⌿7 4 9∘.⍷test4_cards  ⍝ e.g. sum ⍷ to mark positions of 7 4 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 355,
   "id": "b21065cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "test4_game←{(+⌿(¯1,⍵)∘.⍷test4_cards)}¨,\\test4_calls  ⍝ mark cards for each call prefix"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3afe9888",
   "metadata": {},
   "source": [
    "Then we can find the first bingo round and board."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 357,
   "id": "238b8a80",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">12 3\n",
       "</span>"
      ]
     },
     "execution_count": 357,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⊃1(⍸⍷)↑((bingo⍤2)¨test4_game)  ⍝ bingo over 2nd axis submatrices, find first one"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a93f5787",
   "metadata": {},
   "source": [
    "Probably this could all go in some kind of horrible one liner but instead\n",
    "I will put it into a dfn with names and things."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 360,
   "id": "8b3b59b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "day4_1←{\n",
    "  cards calls←⍵\n",
    "  game←{(+⌿(¯1,⍵)∘.⍷cards)}¨,\\calls   ⍝ bit matrices for each prefix of calls \n",
    "  round card←⊃1(⍸⍷)↑((bingo⍤2)¨game)  ⍝ round and card of first bingo\n",
    "  ⍝ score is winning call times sum of uncalled numbers on winning card\n",
    "  (round⌷calls)×(+/+/(~card⌷↑round⌷game)×(card⌷cards))\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 361,
   "id": "b9918727",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">4512\n",
       "</span>"
      ]
     },
     "execution_count": 361,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day4_1 test4_cards test4_calls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 362,
   "id": "2e7a87d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">63424\n",
       "</span>"
      ]
     },
     "execution_count": 362,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day4_1 data4_cards data4_calls"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9acf2ed",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Now we need to cheat instead and find the last winning card."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 365,
   "id": "6b2ebb48",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "day4_2←{\n",
    "  cards calls←⍵\n",
    "  game←{(+⌿(¯1,⍵)∘.⍷cards)}¨,\\calls\n",
    "  ⍝ last card to win and round in which it wins\n",
    "  ⍝ (sum 1s for each non-winning row of col per card)\n",
    "  round card←(⌈/,⊢⍳⌈/)1++⌿~↑((bingo⍤2)¨game)\n",
    "  (round⌷calls)×(+/+/(~card⌷↑round⌷game)×(card⌷cards))\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 366,
   "id": "5d3e04d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1924\n",
       "</span>"
      ]
     },
     "execution_count": 366,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day4_2 test4_cards test4_calls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 367,
   "id": "08e6e10f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">23541\n",
       "</span>"
      ]
     },
     "execution_count": 367,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day4_2 data4_cards data4_calls"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "248686a1",
   "metadata": {},
   "source": [
    "## Day 5\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/5)\n",
    "\n",
    "Today we get to plot lines. Splitting on ',' and ' -> ' is a little\n",
    "different since usually we split on one character; ∊ gives an\n",
    "array with 1s for delimiter chars ~ flips it for partition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 369,
   "id": "195a3082",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 9 5 9\n",
       "8 0 0 8\n",
       "9 4 3 4\n",
       "2 2 2 1\n",
       "7 0 7 4\n",
       "6 4 2 0\n",
       "0 9 2 9\n",
       "3 4 1 4\n",
       "0 0 8 8\n",
       "5 5 8 2\n",
       "</span>"
      ]
     },
     "execution_count": 369,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test5←↑⍎¨¨{', -> '(~⍤∊⍨⊆⊢)⍵}¨⊃⎕NGET'day5-test.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 370,
   "id": "ac311b7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "data5←↑⍎¨¨{', -> '(~⍤∊⍨⊆⊢)⍵}¨⊃⎕NGET'day5-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9749be6",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "We are supposed to consider just horizontal or vertical lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 371,
   "id": "52ca2235",
   "metadata": {},
   "outputs": [],
   "source": [
    "h_or_v←{((1⌷⍵)=(3⌷⍵))∨((2⌷⍵)=(4⌷⍵))}  ⍝ same x or y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa21badd",
   "metadata": {},
   "source": [
    "To find all the intersections we'll just plot them all."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "id": "06600e94",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "day5_1←{\n",
    "  ⍝ counts overlapping points for horizontal and vertical lines only \n",
    "  grid←1000 1000⍴0\n",
    "  plot_hv←{\n",
    "    ⍝ plots a horizontal or vertical line in grid\n",
    "    line←⍵                  ⍝ x1 y1 x2 y2\n",
    "    p1←line[1 2]⌊line[3 4]  ⍝ p1 is lower leftmost\n",
    "    p2←line[1 2]⌈line[3 4]  ⍝ p2 is upper rightmost\n",
    "    pts←(,⍳(1+p2-p1))+¨⊂p1  ⍝ indices from p1 to p2 inclusive\n",
    "    grid[pts]+←1            ⍝ plot the points\n",
    "    ⍬\n",
    "  }\n",
    "  hv←((h_or_v⍤1)⍵)⌿⍵  ⍝ reduce lines over h_or_v on each row\n",
    "  _←plot_hv¨↓hv       ⍝ plot the lines\n",
    "  (+/,)grid≥2         ⍝ sum where grid ≥ 2\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 377,
   "id": "7a2b3487",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">5\n",
       "</span>"
      ]
     },
     "execution_count": 377,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day5_1 test5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 378,
   "id": "9ea5b118",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">4655\n",
       "</span>"
      ]
     },
     "execution_count": 378,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day5_1 data5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30f69f15",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Now we are supposed to consider all the lines. This is actually a\n",
    "little easier. The trickiest bit is just generating the plot indices.\n",
    "The key idea is that ×p2-p1 is a unit vector from p1 to p2 (scalar ×\n",
    "is the sign function)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 379,
   "id": "8223907a",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "day5_2←{\n",
    "  ⍝ counts overlapping points for horizontal, vertical, and diagonal lines\n",
    "  grid←1000 1000⍴0\n",
    "  plot←{\n",
    "    ⍝ plots a line in the grid\n",
    "    line←⍵\n",
    "    p1←line[1 2]\n",
    "    p2←line[3 4]\n",
    "    ⍝ iota length times unit vector\n",
    "    ds←((⍳(1+⌈/|p2-p1))-1)∘.×(×p2-p1)\n",
    "    pts←ds+((⍴ds)⍴(1 1+p1))  ⍝ add back p1\n",
    "    grid[↓pts]+←1\n",
    "    ⍬\n",
    "  }\n",
    "  _←plot¨↓⍵   ⍝ plot the lines\n",
    "  (+/,)grid≥2 ⍝ sum where grid ≥ 2\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 380,
   "id": "5b63b86c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">12\n",
       "</span>"
      ]
     },
     "execution_count": 380,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day5_2 test5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 381,
   "id": "8fed3262",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">20500\n",
       "</span>"
      ]
     },
     "execution_count": 381,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day5_2 data5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d389f36",
   "metadata": {},
   "source": [
    "## Day 6\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/6)\n",
    "\n",
    "Today we have to simulate fish reproduction. Great."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 383,
   "id": "3d8abbe8",
   "metadata": {},
   "outputs": [],
   "source": [
    "test6←3 4 3 1 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 396,
   "id": "30857b93",
   "metadata": {},
   "outputs": [],
   "source": [
    "data6←⊃⍎¨¨','(≠⊆⊢)¨⊃⎕NGET'day6-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "240cea07",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "For small numbers of fish this is just a one liner. We concatenate\n",
    "new 8s for each 0, replace 0s with 7s, and decrement everything so\n",
    "really 0s become 6s. The starfish operator iterates (appropriately)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 390,
   "id": "141b6f93",
   "metadata": {},
   "outputs": [],
   "source": [
    "day6_1←≢({(7×(0=⍵))+(⍵-1)},{8+⍵/⍨(0∘=)⍵})⍣80"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 391,
   "id": "8797b5e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">5934\n",
       "</span>"
      ]
     },
     "execution_count": 391,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day6_1 test6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 397,
   "id": "d3064469",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">377263\n",
       "</span>"
      ]
     },
     "execution_count": 397,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day6_1 data6"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95d0a613",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "All right, 256 days is too many to cheese this. We will keep a census\n",
    "of fish in the population instead of storing one number per fish."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 399,
   "id": "9b16304e",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "day6_2←{\n",
    "  ⍝ (n day6_2 fish) returns population size after n generations\n",
    "  n←⍺\n",
    "  census←9⍴0     ⍝ init to zero of each age\n",
    "  census[1+⍵]+←1 ⍝ add 1 to count of age for each fish\n",
    "  ⍝ 1⊖ rotates the current ages down 1\n",
    "  generation←{(1⊖⍵)+(0 0 0 0 0 0,⍵[1],0 0)}\n",
    "  +/(generation⍣n)census\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 403,
   "id": "655c9f97",
   "metadata": {},
   "outputs": [],
   "source": [
    "⎕PP←16  ⍝ we need more precision, apparently"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 404,
   "id": "a74ace78",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">26984457539\n",
       "</span>"
      ]
     },
     "execution_count": 404,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "256 day6_2 test6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 405,
   "id": "562f9c3a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1695929023803\n",
       "</span>"
      ]
     },
     "execution_count": 405,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "256 day6_2 data6"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23f06674",
   "metadata": {},
   "source": [
    "## Day 7\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/7)\n",
    "\n",
    "Something with crabs. I can't even with this today."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 431,
   "id": "daa6037f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">16 1 2 0 4 2 7 1 2 14\n",
       "</span>"
      ]
     },
     "execution_count": 431,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test7←⍎¨','(≠⊆⊢)⊃⊃⎕NGET 'day7-test.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 432,
   "id": "f1dbb51f",
   "metadata": {},
   "outputs": [],
   "source": [
    "data7←⍎¨','(≠⊆⊢)⊃⊃⎕NGET 'day7-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "baad5bb5",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "Find the minimum fuel cost for all crabs to align. It makes no sense\n",
    "to move away from all the other crabs so this will clearly occur at a\n",
    "point inside the convex hull of the crabs.\n",
    "\n",
    "For part 1 this should occur at some crab's current position. Consider\n",
    "a non-crab position with M crabs to the left and N crabs to the right,\n",
    "where the nearest crab in either direction is m or n units away.\n",
    "Choosing the nearest left crab's position instead would reduce cost by\n",
    "δ=(M-N)m; right would reduce by δ=(N-M)n. m>0, n>0, and either M-N≥0 or\n",
    "N-M≥0 or both so this is the same or better."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 433,
   "id": "be0e79fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "day7_1←{v←⍵ ⋄ ⌊/{+/(|⍵-⍨v)}¨v}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 434,
   "id": "b3d17181",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">37\n",
       "</span>"
      ]
     },
     "execution_count": 434,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day7_1 test7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 435,
   "id": "06b01c16",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">357353\n",
       "</span>"
      ]
     },
     "execution_count": 435,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day7_1 data7"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "319f97a4",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "The new cost function uses triangular numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 462,
   "id": "80b4f259",
   "metadata": {},
   "outputs": [],
   "source": [
    "tri←{(⍵×(⍵+1))÷2}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81295497",
   "metadata": {},
   "source": [
    "The minimum fuel cost isn't at some crab's current position anymore.\n",
    "For example, now it costs 1+1 for x=0 and x=2 to meet at x=1, but it\n",
    "would cost 1+2 for them to meet at x=0 or x=2. But the minimum is\n",
    "still in the convex hull, so just search over the whole range. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 463,
   "id": "8c7378f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "day7_2←{v←⍵ ⋄ ⌊/{+/tri(|⍵-v)}¨⍳⌈/v}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 464,
   "id": "0e0b90d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">168\n",
       "</span>"
      ]
     },
     "execution_count": 464,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day7_2 test7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 465,
   "id": "e1f4f9ad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">104822130\n",
       "</span>"
      ]
     },
     "execution_count": 465,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day7_2 data7"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9db9628",
   "metadata": {},
   "source": [
    "## Day 8\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/8)\n",
    "\n",
    "We're sorting out really specifically mangled wiring today."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 467,
   "id": "255776d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───────────────────────────────────────────────────────────┬──────────────────\n",
       "│be cfbegad cbdgef fgaecd cgeb fdcge agebfd fecdb fabcd edb │ fdgacbe cefdb cef\n",
       "├───────────────────────────────────────────────────────────┼──────────────────\n",
       "│edbfga begcd cbg gc gcadebf fbgde acbgfd abcde gfcbed gfec │ fcgedb cgb dgebac\n",
       "├───────────────────────────────────────────────────────────┼──────────────────\n",
       "│fgaebd cg bdaec gdafb agbcfd gdcbef bgcad gfac gcb cdgabef │ cg cg fdcagb cbg \n",
       "├───────────────────────────────────────────────────────────┼──────────────────\n",
       "│fbegcd cbd adcefb dageb afcb bc aefdc ecdab fgdeca fcdbega │ efabcd cedba gadf\n",
       "├───────────────────────────────────────────────────────────┼──────────────────\n",
       "│aecbfdg fbg gf bafeg dbefa fcge gcbea fcaegb dgceab fcbdga │ gecf egdcabf bgf \n",
       "├───────────────────────────────────────────────────────────┼──────────────────\n",
       "│fgeab ca afcebg bdacfeg cfaedg gcfdb baec bfadeg bafgc acf │ gebdcfa ecba ca f\n",
       "├───────────────────────────────────────────────────────────┼──────────────────\n",
       "│dbcfg fgd bdegcaf fgec aegbdf ecdfab fbedc dacgb gdcebf gf │ cefg dcbef fcge g\n",
       "├───────────────────────────────────────────────────────────┼──────────────────\n",
       "│bdfegc cbegaf gecbf dfcage bdacg ed bedf ced adcbefg gebcd │ ed bcgafe cdgba c\n",
       "├───────────────────────────────────────────────────────────┼──────────────────\n",
       "│egadfb cdbfeg cegd fecab cgb gbdefca cg fgcdab egfdb bfceg │ gbdfcae bgc cg cg\n",
       "├───────────────────────────────────────────────────────────┼──────────────────\n",
       "│gcafb gcf dcaebfg ecagb gf abcdeg gaef cafbge fdbac fegbdc │ fgae cfgab fg bag\n",
       "└───────────────────────────────────────────────────────────┴──────────────────\n",
       "\n",
       "      ────────┐\n",
       "      bgd gcbe│\n",
       "      ────────┤\n",
       "      f gc    │\n",
       "      ────────┤\n",
       "              │\n",
       "      ────────┤\n",
       "      ec cb   │\n",
       "      ────────┤\n",
       "      bfgea   │\n",
       "      ────────┤\n",
       "      adegcb  │\n",
       "      ────────┤\n",
       "      bcadfe  │\n",
       "      ────────┤\n",
       "      bgef    │\n",
       "      ────────┤\n",
       "      b       │\n",
       "      ────────┤\n",
       "      ce      │\n",
       "      ────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 467,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test8←↑'|'(≠⊆⊢)¨⊃⎕NGET'day8-test.txt' 1  ⍝ extra spaces are ok"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 469,
   "id": "c28487c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "data8←↑'|'(≠⊆⊢)¨⊃⎕NGET'day8-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "552811bf",
   "metadata": {},
   "source": [
    "In theory one could probably do this with boolean algebra and logic.  But\n",
    "we are absolutely going to cheese this instead, so will be needing a way to\n",
    "generate permutations. I got this from APLcart. Instead of thinking about\n",
    "fancy lightbulbs, let's think about how it works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 470,
   "id": "94f83167",
   "metadata": {},
   "outputs": [],
   "source": [
    "permutations←{(⍳⍵)(,[⍳2](⊢,⍤1 0~)⍤1)⍣⍵⍉⍪⍬}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26344979",
   "metadata": {},
   "source": [
    "It is iterating something ⍵ times on ⍳⍵ and ⍉⍪⍬. That something is ,[⍳2](⊢,⍤1 0~)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 471,
   "id": "de573910",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">  ┌──┴──┐  \n",
       "  [1·2] ⍤  \n",
       "┌─┘   ┌─┴─┐\n",
       ",   ┌─┼─┐ 1\n",
       "    ⊢ ⍤ ~  \n",
       "     ┌┴┐   \n",
       "     , 1 0 \n",
       "</span>"
      ]
     },
     "execution_count": 471,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ",[⍳2](⊢,⍤1 0~)⍤1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc22f919",
   "metadata": {},
   "source": [
    ",⍤1 0 pairs the left vector with each element from the right; (⊢(,⍤1 0)~) instead pairs the right vector with each element from the left less those from the right.  ,[⍳2] is catenate with an axis specification [1 2] presumably to put things into rows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 486,
   "id": "aaea6e50",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "2\n",
       "3\n",
       "</span>"
      ]
     },
     "execution_count": 486,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←d8p1←1 2 3(,[⍳2](⊢,⍤1 0~)⍤1)⍉⍪⍬"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 488,
   "id": "021272f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 2\n",
       "1 3\n",
       "2 1\n",
       "2 3\n",
       "3 1\n",
       "3 2\n",
       "</span>"
      ]
     },
     "execution_count": 488,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←d8p2←1 2 3(,[⍳2](⊢,⍤1 0~)⍤1)d8p1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 489,
   "id": "00797f06",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 2 3\n",
       "1 3 2\n",
       "2 1 3\n",
       "2 3 1\n",
       "3 1 2\n",
       "3 2 1\n",
       "</span>"
      ]
     },
     "execution_count": 489,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 2 3(,[⍳2](⊢,⍤1 0~)⍤1)d8p2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be148194",
   "metadata": {},
   "source": [
    "So this is iteratively catenating new rows with each element of ⍳3 not in the left. Kinda mind blowing."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff985b69",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "For part 1 we are just supposed to count up strings of certain lengths..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 490,
   "id": "70e8ff2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "day8_1←{+/(2 3 4 7)∊⍨≢¨,↑' '(≠⊆⊢)¨(1∘↓⍤1)⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 491,
   "id": "afbc7071",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">26\n",
       "</span>"
      ]
     },
     "execution_count": 491,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day8_1 test8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 492,
   "id": "24124f2e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">470\n",
       "</span>"
      ]
     },
     "execution_count": 492,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day8_1 data8"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea0a8f74",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Now we have to figure out what's up with the wiring. We first define the\n",
    "canonical set of segments for each digit from 0 to 9."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 493,
   "id": "d725160a",
   "metadata": {},
   "outputs": [],
   "source": [
    "digits←'abcefg' 'cf' 'acdeg' 'acdfg' 'bcdf' 'abdfg' 'abdefg' 'acf' 'abcdefg' 'abcdfg'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3425d002",
   "metadata": {},
   "source": [
    "We will also need a helper which translates corresponding values from one array to another, also from APLcart."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 494,
   "id": "12a0c2a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "translate←{⍺⍺(⍵⍵⌷⍨∘⊂⍳)@(∊∘⍺⍺)⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 495,
   "id": "aff070a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">ebcda\n",
       "</span>"
      ]
     },
     "execution_count": 495,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "('12345'translate'abcde')'52341'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 496,
   "id": "8bdfa19f",
   "metadata": {},
   "outputs": [],
   "source": [
    "permutations_of_length_7←permutations 7"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f359c4b9",
   "metadata": {},
   "source": [
    "To decode the scrambled up displays, we will just try all 5040 permutations\n",
    "on the scrambled digit set until we get the canonical digit set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 502,
   "id": "368f17a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "decode_display←{\n",
    "  patterns←{⍵[⍋⍵]}¨' '(≠⊆⊢)⊃(1↑⍵)  ⍝ scrambled segment sets for each digit\n",
    "  readout←{⍵[⍋⍵]}¨' '(≠⊆⊢)⊃(1↓⍵)   ⍝ segment sets we are supposed to decode\n",
    "  trial←{\n",
    "    assignment←'abcdefg'[⊃⍵]  ⍝ segment permutation to assume\n",
    "    ⍝ find index of each remapped pattern in canonical digits\n",
    "    code←digits⍳({⍵[⍋⍵]}¨(assignment translate'abcdefg')¨patterns)\n",
    "    ⍝ if all digits found, decode the readout \n",
    "    (∧/code≤10):10⊥code[patterns⍳readout]-1\n",
    "    ((≢⍵)=0):'error'\n",
    "    ∇(1↓⍵)\n",
    "  }\n",
    "  trial(↓permutations_of_length_7)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 499,
   "id": "c328e5cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "day8_2←{+/decode_display¨↓⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 500,
   "id": "a37db909",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">61229\n",
       "</span>"
      ]
     },
     "execution_count": 500,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day8_2 test8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 501,
   "id": "4bde8a61",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">989396\n",
       "</span>"
      ]
     },
     "execution_count": 501,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day8_2 data8"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b9cd488",
   "metadata": {},
   "source": [
    "## Day 9\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/9)\n",
    "\n",
    "Woo hoo, today looks really array-ish."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 504,
   "id": "d5c2e8d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">2 1 9 9 9 4 3 2 1 0\n",
       "3 9 8 7 8 9 4 9 2 1\n",
       "9 8 5 6 7 8 9 8 9 2\n",
       "8 7 6 7 8 9 6 7 8 9\n",
       "9 8 9 9 9 6 5 6 7 8\n",
       "</span>"
      ]
     },
     "execution_count": 504,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test9←↑⍎¨¨⊃⎕NGET 'day9-test.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 793,
   "id": "09ed2b40",
   "metadata": {},
   "outputs": [],
   "source": [
    "data9←↑⍎¨¨⊃⎕NGET 'day9-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1387e089",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "APL's ⌺ operator lets us count in neighborhoods really easily.\n",
    "Technically this problem doesn't include diagonal neighbors but it\n",
    "works anyways because of what we're doing and I reaaallly wanna use\n",
    "it, ok?\n",
    "\n",
    "We find a bit matrix of all the 3x3s where the center element is\n",
    "≤ all its neighbors, dropping those that are padding. Then get the\n",
    "values at those indices and add 1 and sum reduce. Whee..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 507,
   "id": "a54be57a",
   "metadata": {},
   "outputs": [],
   "source": [
    "day9_1←{+/1+⍵[⍸(∧/¨,¨({⊂⍺↓((2 2)⌷⍵)≤⍵}⌺3 3⊢⍵))]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 508,
   "id": "ad8e828c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">15\n",
       "</span>"
      ]
     },
     "execution_count": 508,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day9_1 test9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 509,
   "id": "1d268e5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">545\n",
       "</span>"
      ]
     },
     "execution_count": 509,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day9_1 data9"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2117d369",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "We have to count the sizes of connected regions in an array. Originally I just\n",
    "solved this with a chesy flood fill, but I was hoping there would be a clever\n",
    "morphological image processing way to do this.\n",
    "\n",
    "The idea would be to build a bit matrix and have the 1s \"flow\" to\n",
    "adjacent cells. But there's ambiguity about which way they should flow. For\n",
    "example, the test has an 8 surrounded by two 7s. The flow could \"split\",\n",
    "but then that's nonlocal. So I guess I'll stick with the flood fill."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 789,
   "id": "97babb0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "flood_fill←{\n",
    "  to_visit←⊃1⌷⍵\n",
    "  visited←⊃2⌷⍵\n",
    "  regions←⊃3⌷⍵\n",
    "  ((≢to_visit)=0):visited\n",
    "  next←1↑to_visit\n",
    "  already_visited←∨/∨/next⍷visited\n",
    "  outside←next{3::1 ⋄ 0=((⊃⍺)⌷↑⍵)}regions\n",
    "  (already_visited∨outside):∇((1↓to_visit)visited regions)\n",
    "  nextp←(next+((1 0)(0 1)(¯1 0)(0 ¯1))),1↓to_visit\n",
    "  visitedp←visited,next\n",
    "  ∇(nextp visitedp regions)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 790,
   "id": "8613f76e",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "day9_2←{\n",
    "  sinks←{⍸(∧/¨,¨({⊂⍺↓((2 2)⌷⍵)≤⍵}⌺3 3⊢⍵))}⍵  ⍝ sink positions\n",
    "  basins←~9=⍵  ⍝ bitmask of basins\n",
    "  region_size←≢1↓{flood_fill(⊂⍵)(⊂⍬)(⊂basins)}\n",
    "  sizes←region_size¨sinks\n",
    "  ×/sizes[3↑⍒sizes]\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 791,
   "id": "5efe1c02",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1134\n",
       "</span>"
      ]
     },
     "execution_count": 791,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day9_2 test9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 794,
   "id": "9fa5e507",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">950600\n",
       "</span>"
      ]
     },
     "execution_count": 794,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day9_2 data9"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "237ec26d",
   "metadata": {},
   "source": [
    "## Day 10\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/10)\n",
    "\n",
    "Parsing stuff today. Not really APL's strong suit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 796,
   "id": "5ec84499",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌────────────────────────┬──────────────────────┬────────────────────────┬─────\n",
       "│[({(&lt;(())[]&gt;[[{[]{&lt;()&lt;&gt;&gt;│[(()[&lt;&gt;])]({[&lt;{&lt;&lt;[]&gt;&gt;(│{([(&lt;{}[&lt;&gt;[]}&gt;{[]{[(&lt;()&gt;│(((({\n",
       "└────────────────────────┴──────────────────────┴────────────────────────┴─────\n",
       "\n",
       "      ──────────────────┬──────────────────────┬───────────────────────┬───────\n",
       "      &lt;&gt;}&lt;{&lt;{&lt;&gt;}{[]{[]{}│[[&lt;[([]))&lt;([[{}[[()]]]│[{[{({}]{}}([{[{{{}}([]│{&lt;[[]]&gt;\n",
       "      ──────────────────┴──────────────────────┴───────────────────────┴───────\n",
       "\n",
       "      ────────────────┬──────────────────────┬──────────────────────┬──────────\n",
       "      }&lt;{[{[{[]{()[[[]│[&lt;(&lt;(&lt;(&lt;{}))&gt;&lt;([]([]()│&lt;{([([[(&lt;&gt;()){}]&gt;(&lt;&lt;{{│&lt;{([{{}}[&lt;\n",
       "      ────────────────┴──────────────────────┴──────────────────────┴──────────\n",
       "\n",
       "      ──────────────┐\n",
       "      [[[&lt;&gt;{}]]]&gt;[]]│\n",
       "      ──────────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 796,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test10←⊃⎕NGET 'day10-test.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 797,
   "id": "c70a9f7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "data10←⊃⎕NGET 'day10-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f92c97c",
   "metadata": {},
   "source": [
    "There's nothing particularly hard here but Dyalog really liked to crash with\n",
    "a mysterious error 139 a lot. So some of the code is a little awkward because\n",
    "I kept modifying it not to break the interpreter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 799,
   "id": "10664bc7",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "parse_chunks←{\n",
    "  expr←⍵\n",
    "  stack←⍬\n",
    "  next_char←{\n",
    "    i←⍵\n",
    "    i>≢expr:0\n",
    "    c←expr[i]\n",
    "    ⍝ for opening chars, push the expected closing char\n",
    "    _←{c='[':stack,←']' ⋄ 0}0\n",
    "    _←{c='{':stack,←'}' ⋄ 0}0\n",
    "    _←{c='(':stack,←')' ⋄ 0}0\n",
    "    _←{c='<':stack,←'>' ⋄ 0}0\n",
    "    c∊'[{(<':∇(i+1)\n",
    "    ⍝ for closing chars, check if they match\n",
    "    match←{\n",
    "      top←¯1↑stack\n",
    "      stack⊢←¯1↓stack\n",
    "      c=top\n",
    "    }0\n",
    "    match:∇(i+1)  ⍝ char matches keep going\n",
    "    ⍝ wrong closing char score it\n",
    "    c=')':3\n",
    "    c=']':57\n",
    "    c='}':1197\n",
    "    c='>':25137\n",
    "  }\n",
    "  next_char 1\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3b4d592",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "Score the mismatched closing chars."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 800,
   "id": "3837eefc",
   "metadata": {},
   "outputs": [],
   "source": [
    "day10_1←+/(parse_chunks¨⊢)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 801,
   "id": "bf119e1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">26397\n",
       "</span>"
      ]
     },
     "execution_count": 801,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day10_1 test10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 802,
   "id": "b521f179",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">343863\n",
       "</span>"
      ]
     },
     "execution_count": 802,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day10_1 data10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdfd7d3f",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Now we need to add up the stack contents instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 804,
   "id": "9e97b1c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "parse_chunks2←{\n",
    "  expr←⍵\n",
    "  stack←⍬\n",
    "  next_char←{\n",
    "    i←⍵\n",
    "    i>≢expr:0\n",
    "    c←expr[i]\n",
    "    ⍝ for opening chars, push the expected closing char\n",
    "    _←{c='[':stack,←']' ⋄ 0}0\n",
    "    _←{c='{':stack,←'}' ⋄ 0}0\n",
    "    _←{c='(':stack,←')' ⋄ 0}0\n",
    "    _←{c='<':stack,←'>' ⋄ 0}0\n",
    "    c∊'[{(<':∇(i+1)\n",
    "    ⍝ for closing chars, check if they match\n",
    "    match←{\n",
    "      top←¯1↑stack\n",
    "      stack⊢←¯1↓stack\n",
    "      c=top\n",
    "    }0\n",
    "    match:∇(i+1)  ⍝ char matches keep going\n",
    "    1  ⍝ this is a corrupted line skip it\n",
    "  }\n",
    "  corrupt←next_char 1\n",
    "  corrupt:0\n",
    "  ⍝ score the expected completion if not corrupt\n",
    "  5⊥{⍵=')':1 ⋄ ⍵=']':2 ⋄ ⍵='}':3 ⋄ ⍵='>':4}¨⌽stack\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 815,
   "id": "79adbb91",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "day10_2←{\n",
    "  scores←(0∘≠){⍵/⍨⍺⍺ ⍵}parse_chunks2¨⍵  ⍝ nonzero scores\n",
    "  ({(⊂⍋⍵)⌷⍵}scores)[⌈(≢scores)÷2]       ⍝ middle of sorted scores\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 816,
   "id": "f2f1cc80",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">288957\n",
       "</span>"
      ]
     },
     "execution_count": 816,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day10_2 test10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 817,
   "id": "35112cde",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">2924734236\n",
       "</span>"
      ]
     },
     "execution_count": 817,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day10_2 data10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c267601d",
   "metadata": {},
   "source": [
    "## Day 11\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/11)\n",
    "\n",
    "Cool trippy looking octopus simulation today."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 819,
   "id": "4334ef6f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">5 4 8 3 1 4 3 2 2 3\n",
       "2 7 4 5 8 5 4 7 1 1\n",
       "5 2 6 4 5 5 6 1 7 3\n",
       "6 1 4 1 3 3 6 1 4 6\n",
       "6 3 5 7 3 8 5 4 7 8\n",
       "4 1 6 7 5 2 4 6 4 5\n",
       "2 1 7 6 8 4 1 7 2 1\n",
       "6 8 8 2 8 8 1 1 3 4\n",
       "4 8 4 6 8 4 8 5 5 4\n",
       "5 2 8 3 7 5 1 5 2 6\n",
       "</span>"
      ]
     },
     "execution_count": 819,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test11←↑↑⍎¨¨⊃⎕NGET 'day11-test.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 820,
   "id": "5d837b75",
   "metadata": {},
   "outputs": [],
   "source": [
    "data11←↑↑⍎¨¨⊃⎕NGET 'day11-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b83ade08",
   "metadata": {},
   "source": [
    "We need a little dfn to simulate the octopi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 821,
   "id": "f6c49ad6",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "step_octopi←{\n",
    "  grid←1+⍵\n",
    "  already_flashed←(⍴grid)⍴0\n",
    "  do_flashes←{\n",
    "    flash←(grid>9)∧~already_flashed\n",
    "    ((+/+/flash)=0):grid\n",
    "    grid+←{+/1↓¯5⌽,⍵}⌺3 3⊢flash\n",
    "    already_flashed∨←flash\n",
    "    ∇ 0\n",
    "  }\n",
    "  grid←do_flashes 0\n",
    "  (~(grid>9))×grid\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a506848",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "Count flashes after 100 steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 824,
   "id": "4e522344",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "day11_1←{\n",
    "  flashes←0\n",
    "  n←⍺\n",
    "  grid←⍵\n",
    "  (n=0):flashes\n",
    "  grid←step_octopi grid\n",
    "  flashes+←+/+/0=grid\n",
    "  flashes+(n-1)∇ grid\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 825,
   "id": "63bccf80",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1656\n",
       "</span>"
      ]
     },
     "execution_count": 825,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "100 day11_1 test11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 826,
   "id": "d2ce645b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1591\n",
       "</span>"
      ]
     },
     "execution_count": 826,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "100 day11_1 data11"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46a65d98",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Find the step when all octopi flash."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 829,
   "id": "262aa37e",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "day11_2←{\n",
    "  ⍺←1\n",
    "  n←⍺\n",
    "  grid←⍵\n",
    "  grid←step_octopi grid\n",
    "  ((×/⍴grid)=+/+/0=grid):n\n",
    "  (n+1)∇ grid\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 830,
   "id": "345b6082",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">195\n",
       "</span>"
      ]
     },
     "execution_count": 830,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day11_2 test11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 831,
   "id": "e503df96",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">314\n",
       "</span>"
      ]
     },
     "execution_count": 831,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day11_2 data11"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fc7b343",
   "metadata": {},
   "source": [
    "## Day 12\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/12)\n",
    "\n",
    "Bleh graph search today. APL really isn't especially great at this.\n",
    "\n",
    "I'll write out test12_1 longhand so that you can notice that 'x' is\n",
    "a scalar and not a vector. But 'xx' is an array. So strings may be\n",
    "arrays or not arrays depending on their length. This is somewhat\n",
    "error-prone when trying things in the REPL."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 839,
   "id": "36330fd2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─────────┬─────────┬─────┬─────┬─────┬───────┬───────┐\n",
       "│┌─────┬─┐│┌─────┬─┐│┌─┬─┐│┌─┬─┐│┌─┬─┐│┌─┬───┐│┌─┬───┐│\n",
       "││start│A│││start│b│││A│c│││A│b│││b│d│││A│end│││b│end││\n",
       "│└─────┴─┘│└─────┴─┘│└─┴─┘│└─┴─┘│└─┴─┘│└─┴───┘│└─┴───┘│\n",
       "└─────────┴─────────┴─────┴─────┴─────┴───────┴───────┘\n",
       "</span>"
      ]
     },
     "execution_count": 839,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test12_1←('start' (,'A'))('start' (,'b'))((,'A') (,'c'))((,'A') (,'b'))((,'b') (,'d'))((,'A') 'end')((,'b') 'end')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 833,
   "id": "8f901bd5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌────────┬──────────┬──────────┬──────────┬───────┬───────┬────────┬───────┬───\n",
       "│┌──┬───┐│┌──┬─────┐│┌─────┬──┐│┌──┬─────┐│┌──┬──┐│┌──┬──┐│┌──┬───┐│┌──┬──┐│┌──\n",
       "││dc│end│││HN│start│││start│kj│││dc│start│││dc│HN│││LN│dc│││HN│end│││kj│sa│││kj\n",
       "│└──┴───┘│└──┴─────┘│└─────┴──┘│└──┴─────┘│└──┴──┘│└──┴──┘│└──┴───┘│└──┴──┘│└──\n",
       "└────────┴──────────┴──────────┴──────────┴───────┴───────┴────────┴───────┴───\n",
       "\n",
       "      ────┬───────┐\n",
       "      ┬──┐│┌──┬──┐│\n",
       "      │HN│││kj│dc││\n",
       "      ┴──┘│└──┴──┘│\n",
       "      ────┴───────┘\n",
       "</span>"
      ]
     },
     "execution_count": 833,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test12_2←'-'(≠⊆⊢)¨⊃⎕NGET'day12-test2.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 834,
   "id": "15423f84",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌────────┬───────┬───────┬──────────┬───────┬────────┬───────┬───────┬───────┬─\n",
       "│┌──┬───┐│┌──┬──┐│┌──┬──┐│┌─────┬──┐│┌──┬──┐│┌───┬──┐│┌──┬──┐│┌──┬──┐│┌──┬──┐│┌\n",
       "││fs│end│││he│DX│││fs│he│││start│DX│││pj│DX│││end│zg│││zg│sl│││zg│pj│││pj│he│││\n",
       "│└──┴───┘│└──┴──┘│└──┴──┘│└─────┴──┘│└──┴──┘│└───┴──┘│└──┴──┘│└──┴──┘│└──┴──┘│└\n",
       "└────────┴───────┴───────┴──────────┴───────┴────────┴───────┴───────┴───────┴─\n",
       "\n",
       "      ──────┬───────┬───────┬───────┬──────────┬───────┬───────┬───────┬───────\n",
       "      ──┬──┐│┌──┬──┐│┌──┬──┐│┌──┬──┐│┌─────┬──┐│┌──┬──┐│┌──┬──┐│┌──┬──┐│┌─────┬\n",
       "      RW│he│││fs│DX│││pj│RW│││zg│RW│││start│pj│││he│WI│││zg│he│││pj│fs│││start│\n",
       "      ──┴──┘│└──┴──┘│└──┴──┘│└──┴──┘│└─────┴──┘│└──┴──┘│└──┴──┘│└──┴──┘│└─────┴\n",
       "      ──────┴───────┴───────┴───────┴──────────┴───────┴───────┴───────┴───────\n",
       "\n",
       "      ───┐\n",
       "      ──┐│\n",
       "      RW││\n",
       "      ──┘│\n",
       "      ───┘\n",
       "</span>"
      ]
     },
     "execution_count": 834,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test12_3←'-'(≠⊆⊢)¨⊃⎕NGET'day12-test3.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 835,
   "id": "30b8c6f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "data12←'-'(≠⊆⊢)¨⊃⎕NGET'day12-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5e2c3af",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "Count all paths visiting small letter caves at most once. We'll just use\n",
    "a recursive dfn to enumerate them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 845,
   "id": "bea7ed9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "paths←{\n",
    "  graph←⍵\n",
    "  xs←⊃¨graph\n",
    "  ys←2⊃¨graph\n",
    "  is_lower←∧/(1∘⎕C≠⊢)  ⍝ 1 if c is lowercase\n",
    "  visit←{\n",
    "    cur←⊃⍵[1]  ⍝ current node\n",
    "    pps←⊃⍵[2]  ⍝ open partial paths\n",
    "    (cur≡'end'):(⊂'end')∘,¨pps  ⍝ open paths stop at end\n",
    "    ⍝ collect adjacent vertices\n",
    "    nexts←{(xs/⍨(,⍵)∘≡¨ys),(ys/⍨(,⍵)∘≡¨xs)}cur\n",
    "    ⍝ prune paths that have gone through cur before if small \n",
    "    small←is_lower cur\n",
    "    open_pps←pps/⍨((~small)∨(∧/¨(,cur∘≢¨¨pps)))\n",
    "    ((≢open_pps)=0):0  ⍝ dead end\n",
    "    ⍝ return all the paths here\n",
    "    next_pps←(⊂cur)∘,¨open_pps\n",
    "    here←,↑{visit(⍵ next_pps)}¨nexts\n",
    "    ((1∘≠)≢¨here)/here\n",
    "  }\n",
    "  ⍝ this filters out annoying empty paths\n",
    "  paths_with_ghosts←visit('start'(,'-'))\n",
    "  ('-'∊¨paths_with_ghosts)/paths_with_ghosts\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 846,
   "id": "e0a354ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "day12_1←(≢paths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 847,
   "id": "a7397122",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">10\n",
       "</span>"
      ]
     },
     "execution_count": 847,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day12_1 test12_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 848,
   "id": "5cacf3f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">19\n",
       "</span>"
      ]
     },
     "execution_count": 848,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day12_1 test12_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 849,
   "id": "0803ce89",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">226\n",
       "</span>"
      ]
     },
     "execution_count": 849,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day12_1 test12_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 850,
   "id": "c00f8b27",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">3761\n",
       "</span>"
      ]
     },
     "execution_count": 850,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day12_1 data12"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8c1b16a",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "How many paths are there if we can revisit one small letter cave twice?\n",
    "\n",
    "Originally, I modified my recursive dfn from part 1 to solve this part,\n",
    "and it blew Dyalog's stack limit. So I rewrote the search to be iterative\n",
    "instead. That worked but took so long that I wrote a naive Python solution\n",
    "instead of waiting for it to finish (the runtime was 5 seconds).\n",
    "\n",
    "I eventually figured out that \"drop\" is slow linear time and so it is really\n",
    "easy to make things n^2 by mistake.\n",
    "\n",
    "This uses \"tradfns\" and Dyalog's procedural programming keywords, which\n",
    "feels super gross."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 862,
   "id": "f867f7c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    " result←paths2_non_recursive graph;xs;ys;is_lower;q;n;i;cur;pps;open_pps;nexts;next_pps\n",
    " xs←⊃¨graph\n",
    " ys←2⊃¨graph\n",
    " is_lower←∧/(1∘⎕C≠⊢)\n",
    "\n",
    " paths_with_ghosts←⍬\n",
    " ⍝ trying to pop a queue is absurdly slow, so instead\n",
    " ⍝ keep our own running start index and length\n",
    " ⍝q←⊂('start'(,'-'))\n",
    " ⍝:While (≢q)>0\n",
    "     ⍝cur←⊃⊃q\n",
    "     ⍝pps←2⊃⊃q\n",
    "     ⍝q←(1↓q)\n",
    " q←(,↓('start'(,'-')))\n",
    " n←1\n",
    " i←1\n",
    " :While n>0\n",
    "     cur←⊃⊃q[i]\n",
    "     pps←2⊃⊃q[i]\n",
    "     n-←1\n",
    "     i+←1\n",
    "     :If (cur≡'end')\n",
    "         paths_with_ghosts,←(⊂'end')∘,¨pps\n",
    "         :Continue\n",
    "     :EndIf\n",
    "     open_pps←({cur is_open ⍵}¨pps)/pps\n",
    "     :If (≢open_pps)=0\n",
    "         :Continue\n",
    "     :EndIf\n",
    "     nexts←{(xs/⍨(,⍵)∘≡¨ys),(ys/⍨(,⍵)∘≡¨xs)}cur\n",
    "     next_pps←(⊂cur)∘,¨open_pps\n",
    "     q,←{(⍵ next_pps)}¨nexts\n",
    "     n+←≢nexts\n",
    " :EndWhile\n",
    " result←('-'∊¨paths_with_ghosts)/paths_with_ghosts"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a785e9e",
   "metadata": {},
   "source": [
    "I extracted a separate procedure for is_open in an effort to see\n",
    "if it would speed up the search. It did not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 863,
   "id": "814b924b",
   "metadata": {},
   "outputs": [],
   "source": [
    " ]dinput\n",
    " result←cur is_open pp;ppt;count\n",
    " :If (~(is_lower cur))\n",
    "     result←1\n",
    "     :Return\n",
    " :EndIf\n",
    " :If ((cur≡'start')∧((≢pp)>1))\n",
    "     result←0\n",
    "     :Return\n",
    " :EndIf\n",
    " ppt←(⊂cur),pp\n",
    " count←{(≢⍵)}⌸((is_lower¨ppt)/ppt)\n",
    " :If (∨/(>∘2)count)\n",
    "     result←0\n",
    "     :Return\n",
    " :EndIf\n",
    " :If ((+/(=∘2)count)>1)\n",
    "     result←0\n",
    "     :Return\n",
    " :EndIf\n",
    " result←1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 856,
   "id": "018678d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "day12_2←(≢paths2_non_recursive)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 864,
   "id": "601ecbcf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">36\n",
       "</span>"
      ]
     },
     "execution_count": 864,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day12_2 test12_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 865,
   "id": "1e999f87",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">103\n",
       "</span>"
      ]
     },
     "execution_count": 865,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day12_2 test12_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 866,
   "id": "3975e00e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">3509\n",
       "</span>"
      ]
     },
     "execution_count": 866,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day12_2 test12_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 860,
   "id": "c9700ef3",
   "metadata": {},
   "outputs": [],
   "source": [
    "⍝day12_2 data12  ⍝ still really slow"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "006afedb",
   "metadata": {},
   "source": [
    "## Day 13\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/13)\n",
    "\n",
    "Ooh, origami today, that sounds cool."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "3296e30a",
   "metadata": {},
   "outputs": [],
   "source": [
    "test13 ← ⊃⎕NGET 'day13-test.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "3095ec7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "data13 ← ⊃⎕NGET 'day13-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a37ad17",
   "metadata": {},
   "source": [
    "Let's start by parsing out the points and the folding instructions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 421,
   "id": "208e101d",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "parse_folds←{\n",
    "  ⍝ given lines like ('0,0')('3,2')('fold along x=5')('fold along y=4')\n",
    "  ⍝ returns (points folds) where points are (x y)s and folds are (x 0)\n",
    "  ⍝ for vertical folds and (0 y) for horizontal folds \n",
    "  parse_line←{\n",
    "    ⍝ note that we add 1 to x ys because APL arrays are 1-indexed\n",
    "    ','∊⍵:1,(⌽1+⍎¨','(≠⊆⊢)⍵) ⍝ ',' lines: 1 x+1 y+1 \n",
    "    'x'∊⍵:2(⍎2⊃'='(≠⊆⊢)⍵)0   ⍝ 'x' lines: 2 x 0\n",
    "    'y'∊⍵:2 0(⍎2⊃'='(≠⊆⊢)⍵)  ⍝ 'y' lines: 2 0 y\n",
    "    0                        ⍝ ignore extra newlines\n",
    "  }\n",
    "  ⍝ selects rows with first element =⍺, dropping that element\n",
    "  select←{1↓¨(⍺=⊃¨⍵)/⍵}\n",
    "  ⍝ collect 1 lines (i.e. points) and then 2 lines (i.e. folds)\n",
    "  (⊂∘(1∘select),⊂∘(2∘select))parse_line¨⍵\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8b98607",
   "metadata": {},
   "source": [
    "We can sanity check this with a little plotting helper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "f81b4f0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "plot←{\n",
    "  points←⍵\n",
    "  paper←(↑⌈/points)⍴0  ⍝ 0s as wide and tall as max x and max y\n",
    "  paper[points]←1      ⍝ plot 1s at each point\n",
    "  paper\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 422,
   "id": "73a1f2b5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 0 1 0 0 1 0 0 1 0\n",
       "0 0 0 0 1 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 0 0 0 0 0\n",
       "1 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 1 0 0 0 0 1 0 1\n",
       "0 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 0 0 0 0 0\n",
       "0 1 0 0 0 0 1 0 1 1 0\n",
       "0 0 0 0 1 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 1 0 0 0 1\n",
       "1 0 0 0 0 0 0 0 0 0 0\n",
       "1 0 1 0 0 0 0 0 0 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 422,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←x←plot ⊃parse_folds test13"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1806dcba",
   "metadata": {},
   "source": [
    "To fold, we can just reflect the matrix horizontally or vertically\n",
    "and or it with itself, and then take only the upper or left part."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "b6622f05",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 0 1 1 0 0 1 0 0 1 0\n",
       "1 0 0 0 1 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 1 0 0 0 1\n",
       "1 0 0 0 1 0 0 0 0 0 0\n",
       "0 1 0 1 0 0 1 0 1 1 1\n",
       "0 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 0 0 0 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←x←7↑x∨⊖x   ⍝ e.g. fold up and keep 7 rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "d3fcd824",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 1 1 1 1\n",
       "1 0 0 0 1\n",
       "1 0 0 0 1\n",
       "1 0 0 0 1\n",
       "1 1 1 1 1\n",
       "0 0 0 0 0\n",
       "0 0 0 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←x←5↑[2]x∨⌽x ⍝ now fold left and keep 5 cols"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bfa79d1",
   "metadata": {},
   "source": [
    "Let's just write a general program for any number of folds and then\n",
    "have it only do the first to solve part 1. It isn't really that much\n",
    "different."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "2eb0b5d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "fold←{\n",
    "  points folds←⍵\n",
    "  paper←plot points ⍝ make bitmap of points\n",
    "  fold_left←{\n",
    "    ⍝ modify paper, or'ing right-to-left and keeping left ⍵ cols\n",
    "    paper⊢←⍵↑[2]paper∨⌽paper ⋄ 0\n",
    "  }\n",
    "  fold_up←{\n",
    "    ⍝ modify paper, or'ing top-to-bottom and keeping top ⍵ rows\n",
    "    paper⊢←⍵↑paper∨⊖paper ⋄ 0\n",
    "  }\n",
    "  _←{\n",
    "    left up←⍵   ⍝ each element has x/y fold amount  \n",
    "    (left≠0):fold_left left\n",
    "    fold_up up\n",
    "  }¨folds\n",
    "  paper\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "f3ed9ce2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 1 1 1 1\n",
       "1 0 0 0 1\n",
       "1 0 0 0 1\n",
       "1 0 0 0 1\n",
       "1 1 1 1 1\n",
       "0 0 0 0 0\n",
       "0 0 0 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fold parse_folds test13"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b524fd3f",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "To prove this works, count up points after doing just the first fold.\n",
    "The inline dfn here keeps all the points and only the first fold from\n",
    "instructions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "d848df2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "day13_1←{+/+/fold{(⊃⍵)(⊂(⊃2⊃⍵))}parse_folds ⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "ac21087d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">17\n",
       "</span>"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day13_1 test13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "498bed9e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">842\n",
       "</span>"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day13_1 data13"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43a4a0ca",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Then we do the whole thing and get a bitmap to answer with."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "d40b7f10",
   "metadata": {},
   "outputs": [],
   "source": [
    "day13_2 ← fold parse_folds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "8b8d2572",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 1 1 0 0 1 1 1 1 0 1 0 0 1 0 1 1 1 0 0 0 1 1 0 0 0 0 1 1 0 1 1 1 1 0 1 0 0 1 0\n",
       "1 0 0 1 0 1 0 0 0 0 1 0 1 0 0 1 0 0 1 0 1 0 0 1 0 0 0 0 1 0 0 0 0 1 0 1 0 0 1 0\n",
       "1 1 1 0 0 1 1 1 0 0 1 1 0 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 1 0 0 1 0 0 1 0\n",
       "1 0 0 1 0 1 0 0 0 0 1 0 1 0 0 1 1 1 0 0 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0 1 0 0 1 0\n",
       "1 0 0 1 0 1 0 0 0 0 1 0 1 0 0 1 0 1 0 0 1 0 0 1 0 1 0 0 1 0 1 0 0 0 0 1 0 0 1 0\n",
       "1 1 1 0 0 1 0 0 0 0 1 0 0 1 0 1 0 0 1 0 0 1 1 0 0 0 1 1 0 0 1 1 1 1 0 0 1 1 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day13_2 data13"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2ee0a6c",
   "metadata": {},
   "source": [
    "## Day 14\n",
    "\n",
    "Today we get to do string shenanigans, substituting pairs for letters.\n",
    "APL doesn't really seem to have dictionaries so I guess I'll roll my own..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "id": "32908050",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌──┬─┐\n",
       "│NN│C│\n",
       "├──┼─┤\n",
       "│NC│B│\n",
       "├──┼─┤\n",
       "│CB│H│\n",
       "└──┴─┘\n",
       "</span>"
      ]
     },
     "execution_count": 242,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←polymers←↑('NN' (,'C'))('NC' (,'B'))('CB' (,'H'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "id": "13adbeaa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">B\n",
       "</span>"
      ]
     },
     "execution_count": 245,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↑polymers[⍸(⌽'NC'∘≡¨polymers)]  ⍝ lookup letter where adjacent column is 'NC'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "id": "56b200ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌──┬──┬──┐\n",
       "│NN│NC│CB│\n",
       "└──┴──┴──┘\n",
       "</span>"
      ]
     },
     "execution_count": 246,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2,/'NNCB'  ⍝ get pairs from string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "id": "7ae0dcb6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">CBH\n",
       "</span>"
      ]
     },
     "execution_count": 249,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{⊃⊃polymers[⍸(⌽⍵∘≡¨polymers)]}¨2,/'NNCB'  ⍝ lookup letter for each pair"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfdbf247",
   "metadata": {},
   "source": [
    "We're supposed to squidge the letters between the pairs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "id": "69a65bca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">NCNBCHB\n",
       "</span>"
      ]
     },
     "execution_count": 250,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{(⊃,/{(⊃⍵),⊃⊃polymers[⍸(⌽⍵∘≡¨polymers)]}¨2,/⍵),¯1↑⍵}'NNCB'  ⍝ put pair letters around lookups"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "id": "07598553",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "polymerize←{\n",
    "  pairs←⍺\n",
    "  template←⍵\n",
    "  lookup←{⊃⊃pairs[⍸(⌽⍵∘≡¨pairs)]}\n",
    "  (⊃,/{(⊃⍵),lookup⍵}¨2,/template),¯1↑template\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "id": "12ad42c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">NCNBCHB\n",
       "</span>"
      ]
     },
     "execution_count": 264,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "polymers polymerize 'NNCB'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9ddc324",
   "metadata": {},
   "source": [
    "Ok, time to read inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "id": "a7f59845",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">NNCB\n",
       "</span>"
      ]
     },
     "execution_count": 258,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test14_template←⊃⊃⎕NGET'day14-test.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "id": "ff911730",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌──┬─┐\n",
       "│CH│B│\n",
       "├──┼─┤\n",
       "│HH│N│\n",
       "├──┼─┤\n",
       "│CB│H│\n",
       "├──┼─┤\n",
       "│NH│C│\n",
       "├──┼─┤\n",
       "│HB│C│\n",
       "├──┼─┤\n",
       "│HC│B│\n",
       "├──┼─┤\n",
       "│HN│C│\n",
       "├──┼─┤\n",
       "│NN│C│\n",
       "├──┼─┤\n",
       "│BH│H│\n",
       "├──┼─┤\n",
       "│NC│B│\n",
       "├──┼─┤\n",
       "│NB│B│\n",
       "├──┼─┤\n",
       "│BN│B│\n",
       "├──┼─┤\n",
       "│BB│N│\n",
       "├──┼─┤\n",
       "│BC│B│\n",
       "├──┼─┤\n",
       "│CC│N│\n",
       "├──┼─┤\n",
       "│CN│C│\n",
       "└──┴─┘\n",
       "</span>"
      ]
     },
     "execution_count": 259,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test14_pairs←↑{' -> '(~⍤∊⍨⊆⊢)⍵}¨2↓⊃⎕NGET'day14-test.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "id": "f4bddb37",
   "metadata": {},
   "outputs": [],
   "source": [
    "data14_template←⊃⊃⎕NGET'day14-input.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "id": "96f3d5d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "data14_pairs←↑{' -> '(~⍤∊⍨⊆⊢)⍵}¨2↓⊃⎕NGET'day14-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93f93918",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "Polymerize repeatedly..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "id": "3eae9d1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">NBBNBNBBCCNBCNCCNBBNBBNBBBNBBNBBCBHCBHHNHCBBCBHCB\n",
       "</span>"
      ]
     },
     "execution_count": 274,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((test14_pairs∘polymerize)⍣4) test14_template"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de674657",
   "metadata": {},
   "source": [
    "and find the most common minus the least common character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "id": "caabda12",
   "metadata": {},
   "outputs": [],
   "source": [
    "most_minus_least←(⌈/-⌊/){≢⍵}⌸∘⊢  ⍝ tally keys, then take max-min "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "id": "beb53dfd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">4\n",
       "</span>"
      ]
     },
     "execution_count": 283,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "most_minus_least 'ABBBCCCCC'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "id": "42aa3c35",
   "metadata": {},
   "outputs": [],
   "source": [
    "day14_1←{most_minus_least ((⍺∘polymerize)⍣10) ⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "id": "36265010",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1588\n",
       "</span>"
      ]
     },
     "execution_count": 285,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test14_pairs day14_1 test14_template"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "id": "d1474a66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">2587\n",
       "</span>"
      ]
     },
     "execution_count": 289,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data14_pairs day14_1 data14_template"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7e03e30",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Now we have to do this 40 times in a row. Naive string substitution\n",
    "won't work anymore; Dyalog bogs down at around 16 or 17 iterations.\n",
    "\n",
    "Notice that in each generation, each pair yields 2 new pairs: xy -> z\n",
    "gives xz and zy. The order isn't important, so we can just count them.\n",
    "First we have to count pairs in the template."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "id": "314e1ab6",
   "metadata": {},
   "outputs": [],
   "source": [
    "count_pairs←{⍵ 1}¨2,/⊢  ⍝ (pair 1) for each pair in template"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "id": "cd875a35",
   "metadata": {},
   "outputs": [],
   "source": [
    "test14_census←count_pairs test14_template"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 329,
   "id": "f093519b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬─\n",
       "│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌\n",
       "││VH│1│││HC│1│││CK│1│││KB│1│││BF│1│││FO│1│││OV│1│││VC│1│││CH│1│││HH│1│││HK│1│││\n",
       "│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└\n",
       "└──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴─\n",
       "\n",
       "      ─────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┐\n",
       "      ──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│\n",
       "      KO│1│││OH│1│││HB│1│││BP│1│││PN│1│││NC│1│││CK│1│││KO│1││\n",
       "      ──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│\n",
       "      ─────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┘\n",
       "</span>"
      ]
     },
     "execution_count": 329,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←data14_census←count_pairs data14_template"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15245230",
   "metadata": {},
   "source": [
    "Note that CK and KO are duplicated, so we need to collect counts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 331,
   "id": "006e8e1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "merge_counts←{c←⍵ ⋄ ↓{(⊃⍺)(+/⊢/↑c[⍵])}⌸⊣/↑c}  ⍝ sum counts for duplicate keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "id": "d41b6999",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬─\n",
       "│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌\n",
       "││VH│1│││HC│1│││CK│2│││KB│1│││BF│1│││FO│1│││OV│1│││VC│1│││CH│1│││HH│1│││HK│1│││\n",
       "│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└\n",
       "└──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴─\n",
       "\n",
       "      ─────┬──────┬──────┬──────┬──────┬──────┐\n",
       "      ──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│\n",
       "      KO│2│││OH│1│││HB│1│││BP│1│││PN│1│││NC│1││\n",
       "      ──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│\n",
       "      ─────┴──────┴──────┴──────┴──────┴──────┘\n",
       "</span>"
      ]
     },
     "execution_count": 332,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "merge_counts data14_census"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d634f63f",
   "metadata": {},
   "source": [
    "We can now polymerize pair counts rather than strings, which ought to be\n",
    "much more efficient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 345,
   "id": "01f16598",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "polymerize2←{\n",
    "  ⍝ update association list of (pair count) by inserting two new pairs\n",
    "  ⍝ for each existing pair according to substitution instructions\n",
    "  pairs←⍺   ⍝ (pair letter) substitution instructions\n",
    "  census←⍵  ⍝ (pair count) current counts\n",
    "  lookup←{⊃⊃pairs[⍸(⌽⍵∘≡¨pairs)]}\n",
    "  merge_counts,↑{\n",
    "    pair count←⍵\n",
    "    letter←lookup pair\n",
    "    left←(1↑pair),letter\n",
    "    right←letter,(¯1↑pair)\n",
    "    (left count)(right count)\n",
    "  }¨census\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 346,
   "id": "12b4c888",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌──────┬──────┬──────┬──────┬──────┬──────┐\n",
       "│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│\n",
       "││NC│1│││CN│1│││NB│1│││BC│1│││CH│1│││HB│1││\n",
       "│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│\n",
       "└──────┴──────┴──────┴──────┴──────┴──────┘\n",
       "</span>"
      ]
     },
     "execution_count": 346,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test14_pairs polymerize2 test14_census"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8762e1d3",
   "metadata": {},
   "source": [
    "But in the final analysis, we need to count letters, not pairs. Each\n",
    "pair contributes one distinct letter except the last pair which\n",
    "contributes two. We can refine merge to leave out the last pair."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 333,
   "id": "89d985be",
   "metadata": {},
   "outputs": [],
   "source": [
    "merge_counts←{c←¯1↓⍵ ⋄ (↓{(⊃⍺)(+/⊢/↑c[⍵])}⌸⊣/↑c),(¯1↑⍵)}  ⍝ merge all but last pair counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 334,
   "id": "c5d21dfd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬─\n",
       "│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌\n",
       "││VH│1│││HC│1│││CK│2│││KB│1│││BF│1│││FO│1│││OV│1│││VC│1│││CH│1│││HH│1│││HK│1│││\n",
       "│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└\n",
       "└──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴─\n",
       "\n",
       "      ─────┬──────┬──────┬──────┬──────┬──────┬──────┐\n",
       "      ──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│┌──┬─┐│\n",
       "      KO│1│││OH│1│││HB│1│││BP│1│││PN│1│││NC│1│││KO│1││\n",
       "      ──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│└──┴─┘│\n",
       "      ─────┴──────┴──────┴──────┴──────┴──────┴──────┘\n",
       "</span>"
      ]
     },
     "execution_count": 334,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←data14_census←merge_counts data14_census"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95c6c611",
   "metadata": {},
   "source": [
    "This way the last pair in the census will always be the literal last pair."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 335,
   "id": "f9b43332",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌────────┬────────┬────────┬────────┬───────┬────────┬───────┬────────┬───────┬\n",
       "│┌──┬───┐│┌──┬───┐│┌──┬───┐│┌──┬───┐│┌──┬──┐│┌──┬───┐│┌──┬──┐│┌──┬───┐│┌──┬──┐│\n",
       "││NB│796│││BB│812│││BN│735│││BC│120│││CC│60│││CN│102│││NC│42│││CB│114│││BH│81││\n",
       "│└──┴───┘│└──┴───┘│└──┴───┘│└──┴───┘│└──┴──┘│└──┴───┘│└──┴──┘│└──┴───┘│└──┴──┘│\n",
       "└────────┴────────┴────────┴────────┴───────┴────────┴───────┴────────┴───────┴\n",
       "\n",
       "      ───────┬───────┬───────┬───────┬───────┬───────┬──────┐\n",
       "      ┌──┬──┐│┌──┬──┐│┌──┬──┐│┌──┬──┐│┌──┬──┐│┌──┬──┐│┌──┬─┐│\n",
       "      │HC│76│││HH│32│││HN│27│││NH│27│││CH│21│││HB│26│││CB│1││\n",
       "      └──┴──┘│└──┴──┘│└──┴──┘│└──┴──┘│└──┴──┘│└──┴──┘│└──┴─┘│\n",
       "      ───────┴───────┴───────┴───────┴───────┴───────┴──────┘\n",
       "</span>"
      ]
     },
     "execution_count": 335,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((test14_pairs∘polymerize2)⍣10) test14_census"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a127d551",
   "metadata": {},
   "source": [
    "Finally we just have to write a horrible function to sum up letter counts given\n",
    "pair counts. It merges the counts of the first letters of each pair, plus the\n",
    "last letter of the last pair, then takes the max count minus the min count."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "id": "29626469",
   "metadata": {},
   "outputs": [],
   "source": [
    "letter_diff_from_census←{(⌈/-⌊/)⊢⌿⍉↑¯1↓(merge_counts ({((⊃⊃(⍵[1]))(⍵[2]))}¨⍵),(⊂((2⊃⊃⊃(¯1↑⍵)) 1)),0)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 337,
   "id": "f5eaadd4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1588\n",
       "</span>"
      ]
     },
     "execution_count": 337,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letter_diff_from_census ((test14_pairs∘polymerize2)⍣10) test14_census"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 338,
   "id": "dd243528",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">2587\n",
       "</span>"
      ]
     },
     "execution_count": 338,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letter_diff_from_census ((data14_pairs∘polymerize2)⍣10) data14_census"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5ea3485",
   "metadata": {},
   "source": [
    "Since it seems to work we can try it out on the problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 339,
   "id": "193374fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "day14_2 ← {letter_diff_from_census ((⍺∘polymerize2)⍣40) ⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 340,
   "id": "105cb3ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">2.18819E12\n",
       "</span>"
      ]
     },
     "execution_count": 340,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test14_pairs day14_2 test14_census"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 342,
   "id": "511fa358",
   "metadata": {},
   "outputs": [],
   "source": [
    "⎕PP←16  ⍝ we need more precision, apparently"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 343,
   "id": "f4a19349",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">2188189693529\n",
       "</span>"
      ]
     },
     "execution_count": 343,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test14_pairs day14_2 test14_census"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "id": "d21b6fb9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">3318837563123\n",
       "</span>"
      ]
     },
     "execution_count": 344,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data14_pairs day14_2 data14_census"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a213beeb",
   "metadata": {},
   "source": [
    "## Day 15\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/15)\n",
    "\n",
    "Find a shortest path from top left to bottom right in a grid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 406,
   "id": "d3673fd3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 1 6 3 7 5 1 7 4 2\n",
       "1 3 8 1 3 7 3 6 7 2\n",
       "2 1 3 6 5 1 1 3 2 8\n",
       "3 6 9 4 9 3 1 5 6 9\n",
       "7 4 6 3 4 1 7 1 1 1\n",
       "1 3 1 9 1 2 8 1 3 7\n",
       "1 3 5 9 9 1 2 4 2 1\n",
       "3 1 2 5 4 2 1 6 3 9\n",
       "1 2 9 3 1 3 8 5 2 1\n",
       "2 3 1 1 9 4 4 5 8 1\n",
       "</span>"
      ]
     },
     "execution_count": 406,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test15←↑⍎¨¨⊃⎕NGET 'day15-test.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 407,
   "id": "ee3eda43",
   "metadata": {},
   "outputs": [],
   "source": [
    "data15←↑⍎¨¨⊃⎕NGET 'day15-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "308e90d4",
   "metadata": {},
   "source": [
    "We'll use [Dijkstra's algorithm](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm).\n",
    "Here is straightforward code for it, not really particularly APLy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 409,
   "id": "04210c53",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "dijkstra←{\n",
    "  grid←⍵\n",
    "  in_bounds←{(∧/⍵≤(⊃⍴grid))∧(∧/⍵>0)}\n",
    "  start←1 1           ⍝ start at upper left\n",
    "  visited←(⍴grid)⍴0   ⍝ init all nodes to unvisited\n",
    "  M←10000000          ⍝ this distance means \"infinity\"\n",
    "  distance←(⍴grid)⍴M  ⍝ init nodes at \"infinity\"\n",
    "  distance[⊂start]←0  ⍝ start at distance 0\n",
    "  step←{\n",
    "    m←distance+M×visited\n",
    "    min←⌊/,m     ⍝ select min distance or M if all visited\n",
    "    min≥M:0      ⍝ stop if all visited\n",
    "    v←⊃⍸(m=min)  ⍝ find first index of min\n",
    "    visited[⊂v]←1 ⍝ mark visited\n",
    "    ⍝ collect in bounds, unvisited orthogonal neighbors\n",
    "    neighbors←↓v(+⍤1)↑(¯1 0)(1 0)(0 ¯1)(0 1)\n",
    "    neighbors←({~in_bounds ⍵:0 ⋄ ~visited[⊂⍵]}¨neighbors)/neighbors\n",
    "    0=≢neighbors:∇ ⍬  ⍝ skip if no unvisited neighbors\n",
    "    ⍝ update min distance to neighbors\n",
    "    _←{distance[⊂⍵]⌊←grid[⊂⍵]+distance[⊂v]}¨neighbors\n",
    "    ∇ ⍬\n",
    "  }\n",
    "  _←step ⍬\n",
    "  distance\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49a26d82",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "Just call our Dijkstra helper to get the shortest path length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 410,
   "id": "bec124b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "day15_1←(⍴⊢)⌷∘dijkstra⊢"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 411,
   "id": "a18fafbf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">40\n",
       "</span>"
      ]
     },
     "execution_count": 411,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day15_1 test15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 412,
   "id": "679426ae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">458\n",
       "</span>"
      ]
     },
     "execution_count": 412,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day15_1 data15"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0247f1d2",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "The graph is secretly bigger and we need to tile it five times in each\n",
    "direction and adjust the values slightly. We can do this easily with an\n",
    "outer product over an index matrix ⍳5 5 and the tile."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 414,
   "id": "3d98458c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───┬───┬───┬───┬───┐\n",
       "│1 1│1 2│1 3│1 4│1 5│\n",
       "├───┼───┼───┼───┼───┤\n",
       "│2 1│2 2│2 3│2 4│2 5│\n",
       "├───┼───┼───┼───┼───┤\n",
       "│3 1│3 2│3 3│3 4│3 5│\n",
       "├───┼───┼───┼───┼───┤\n",
       "│4 1│4 2│4 3│4 4│4 5│\n",
       "├───┼───┼───┼───┼───┤\n",
       "│5 1│5 2│5 3│5 4│5 5│\n",
       "└───┴───┴───┴───┴───┘\n",
       "</span>"
      ]
     },
     "execution_count": 414,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⍳5 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 417,
   "id": "53800100",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">2 2 7 4 8 6 2 8 5 3\n",
       "2 4 9 2 4 8 4 7 8 3\n",
       "3 2 4 7 6 2 2 4 3 9\n",
       "4 7 1 5 1 4 2 6 7 1\n",
       "8 5 7 4 5 2 8 2 2 2\n",
       "2 4 2 1 2 3 9 2 4 8\n",
       "2 4 6 1 1 2 3 5 3 2\n",
       "4 2 3 6 5 3 2 7 4 1\n",
       "2 3 1 4 2 4 9 6 3 2\n",
       "3 4 2 2 1 5 5 6 9 2\n",
       "</span>"
      ]
     },
     "execution_count": 417,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 2{1+9|((+/⍺)-2)+(⍵-1)}test15  ⍝ offset tile values by index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 418,
   "id": "45c9905c",
   "metadata": {},
   "outputs": [],
   "source": [
    "tile←{⊃⍪⌿,/(⍳5 5)∘.{1+9|((+/⍺)-2)+(⍵-1)}⊂⍵}  ⍝ flattened product of indices×adjusted tiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 419,
   "id": "4d0fb083",
   "metadata": {},
   "outputs": [],
   "source": [
    "day15_2←{t←tile ⍵ ⋄ (⍴t)⌷dijkstra t}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 420,
   "id": "2e9c58e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">315\n",
       "</span>"
      ]
     },
     "execution_count": 420,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day15_2 test15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1b0383f",
   "metadata": {},
   "outputs": [],
   "source": [
    "⍝day15_2 data15  ⍝ takes a while..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e202e5a3",
   "metadata": {},
   "source": [
    "The search on the full 500x500 matrix takes a while, but not enough to\n",
    "think harder about this."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34bbab4e",
   "metadata": {},
   "source": [
    "## Day 16\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/16)\n",
    "\n",
    "Today we get to parse a nested binary serialization format from hex numbers.\n",
    "The easiest representation is to use nested arrays so this isn't going to\n",
    "be super APLy or anything."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 436,
   "id": "b2265409",
   "metadata": {},
   "outputs": [],
   "source": [
    "hex_to_binary←{⊃,/(2 2 2 2⊤⊢)¨(¯1+(⎕D,⎕A)⍳⊢)⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 455,
   "id": "86a23d29",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">805311100469800804A3E488ACC0B10055D8009548874F65665AD42F60073E7338E7E5C538D8201\n",
       "                                                                               \n",
       "\n",
       "      14AEA1A19927797976F8F43CD7354D66747B3005B401397C6CBA2FCEEE7AACDECC017938B\n",
       "                                                                               \n",
       "\n",
       "      3F802E000854488F70FC401F8BD09E199005B3600BCBFEEE12FFBB84FC8466B515E92B79B\n",
       "                                                                               \n",
       "\n",
       "      1003C797AEBAF53917E99FF2E953D0D284359CA0CB80193D12B3005B4017968D77EB224B4\n",
       "                                                                               \n",
       "\n",
       "      6BBF591E7BEBD2FA00100622B4ED64773D0CF7816600B68020000874718E715C0010D8AF1\n",
       "                                                                               \n",
       "\n",
       "      E61CC946FB99FC2C20098275EBC0109FA14CAEDC20EB8033389531AAB14C72162492DE33A\n",
       "                                                                               \n",
       "\n",
       "      E0118012C05EEB801C0054F880102007A01192C040E100ED20035DA8018402BE20099A002\n",
       "                                                                               \n",
       "\n",
       "      0CB801AE0049801E800DD10021E4002DC7D30046C0160004323E42C8EA200DC5A87D06250\n",
       "                                                                               \n",
       "\n",
       "      C50015097FB2CFC93A101006F532EB600849634912799EF7BF609270D0802B59876F00424\n",
       "                                                                               \n",
       "\n",
       "      6941091A5040402C9BD4DF654967BFDE4A6432769CED4EC3C4F04C000A895B8E98013246A\n",
       "                                                                               \n",
       "\n",
       "      6016CB3CCC94C9144A03CFAB9002033E7B24A24016DD802933AFAE48EAA3335A632013BC4\n",
       "                                                                               \n",
       "\n",
       "      01D8850863A8803D1C61447A00042E3647B83F313674009E6533E158C3351F94C9902803D\n",
       "                                                                               \n",
       "\n",
       "      35C869865D564690103004E74CB001F39BEFFAAD37DFF558C012D005A5A9E851D25F76DD8\n",
       "                                                                               \n",
       "\n",
       "      8A5F4BC600ACB6E1322B004E5FE1F2FF0E3005EC017969EB7AE4D1A53D07B918C0B1802F0\n",
       "                                                                               \n",
       "\n",
       "      88B2C810326215CCBB6BC140C0149EE87780233E0D298C33B008C52763C9C94BF8DC88650\n",
       "                                                                               \n",
       "\n",
       "      4E1ECD4E75C7E4EA00284180371362C44320043E2EC258F24008747785D10C001039F8064\n",
       "                                                                               \n",
       "\n",
       "      4F201217401500043A2244B8D200085C3F8690BA78F08018394079A7A996D200806647A49\n",
       "                                                                               \n",
       "\n",
       "      E249C675C0802609D66B004658BA7F1562500366279CCBEB2600ACCA6D802C00085C658BD\n",
       "                                                                               \n",
       "\n",
       "      1DC401A8EB136100\n",
       "                      \n",
       "</span>"
      ]
     },
     "execution_count": 455,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←data16←⊃⎕NGET 'day16-input.txt'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cec0a02f",
   "metadata": {},
   "source": [
    "Now we have to write a bunch of packet parsers operating on bit arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 442,
   "id": "64848e77",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "parse_packet←{\n",
    "  ⍝ split off 3 bit version, 3 bit type, and remaining bits\n",
    "  version type bits←1 0 0 1 0 0 1⊂⍵\n",
    "  ⍝ dispatch to parsers for types given in part 1\n",
    "  type≡1 0 0:parse_literal version bits\n",
    "  length_type←1↑bits\n",
    "  ⍝ operator length_type 0: 15-bit subpacket length in bits\n",
    "  length_type=0:parse_operator_length version type(2⊥(15↑(1↓bits)))(16↓bits)\n",
    "  ⍝ operator length_type 1: 11-bit subpacket count\n",
    "  parse_operator_count version type(2⊥(11↑(1↓bits)))(12↓bits)\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08c7b65c",
   "metadata": {},
   "source": [
    "Literals don't nest and use a simple group encoding. We return the total length\n",
    "because they go inside other packets that need to skip over them after parsing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 438,
   "id": "720ee299",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "parse_literal←{\n",
    "  ⍝ returns (#bits ('literal' version value))\n",
    "  version bits←⍵\n",
    "  ⍝ 5-bit groups up to one starting with 0\n",
    "  length←5×(((⍴bits)⍴1 0 0 0 0)/bits)⍳0\n",
    "  value←(length⍴0 1 1 1 1)/length↑bits\n",
    "  ((6+length)('literal'(2⊥version)(2⊥value)))\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "605cfc59",
   "metadata": {},
   "source": [
    "Length operators slurp up to length bits of nested subpackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 439,
   "id": "42492f8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "parse_operator_length←{\n",
    "  ⍝ returns (#bits ('operator' version type subpackets))\n",
    "  version type length bits←⍵\n",
    "  subpackets←{\n",
    "    ⍵=length:⍬\n",
    "    sublength packet←parse_packet ⍵↓bits\n",
    "    (⊂packet),(∇(sublength+⍵))\n",
    "  }\n",
    "  ((6+1+15+length)('operator'(2⊥version)(2⊥type)(subpackets 0)))\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af19dd58",
   "metadata": {},
   "source": [
    "And count operators slurp up to count nested subpackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 440,
   "id": "85202463",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "parse_operator_count←{\n",
    "  ⍝ returns (#bits ('operator' version type subpackets))\n",
    "  version type count bits←⍵\n",
    "  length←0\n",
    "  subpackets←{\n",
    "    0=⍵:⍬\n",
    "    sublength packet←parse_packet length↓bits\n",
    "    length+←sublength\n",
    "    (⊂packet),(∇(⍵-1))\n",
    "  }\n",
    "  ((6+1+11+length)('operator'(2⊥version)(2⊥type)(subpackets count)))\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1324dcc4",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "We're supposed to add up \"version\" fields in each nested packet to prove\n",
    "that we are parsing correctly I guess."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 444,
   "id": "1885ebeb",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "version_sum←{\n",
    "  version←2⌷⍵  ⍝ version is always at index 2\n",
    "  (1⌷⍵)≡⊂'operator':version++/∇¨(⊃⍵[4])\n",
    "  version\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 447,
   "id": "7359dca5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">23\n",
       "</span>"
      ]
     },
     "execution_count": 447,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "version_sum 2⊃parse_packet hex_to_binary'C0015000016115A2E0802F182340'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 448,
   "id": "760142b4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">31\n",
       "</span>"
      ]
     },
     "execution_count": 448,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "version_sum 2⊃parse_packet hex_to_binary'A0016C880162017C3686B18A3D4780'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 449,
   "id": "0314387a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">12\n",
       "</span>"
      ]
     },
     "execution_count": 449,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "version_sum 2⊃parse_packet hex_to_binary'620080001611562C8802118E34'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 450,
   "id": "0e4a44ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">16\n",
       "</span>"
      ]
     },
     "execution_count": 450,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "version_sum 2⊃parse_packet hex_to_binary'8A004A801A8002F478'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 451,
   "id": "6d0a3c3b",
   "metadata": {},
   "outputs": [],
   "source": [
    "day16_1←{version_sum 2⊃parse_packet hex_to_binary ⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 456,
   "id": "3059da4b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">971\n",
       "</span>"
      ]
     },
     "execution_count": 456,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day16_1 data16"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73665870",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Now we get to write an expression evaluator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 458,
   "id": "bee7fae1",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "evaluate←{\n",
    "  ⍝ literals evaluate to fixed value\n",
    "  (1⌷⍵)≡⊂'literal':3⌷⍵\n",
    "  ⍝ everything else is an operator\n",
    "  values←evaluate¨(⊃⍵[4])\n",
    "  type←3⌷⍵\n",
    "  type=0:+/values\n",
    "  type=1:×/values\n",
    "  type=2:⌊/values\n",
    "  type=3:⌈/values\n",
    "  type=5:>/values\n",
    "  type=6:</values\n",
    "  type=7:=/values\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 459,
   "id": "750cf331",
   "metadata": {},
   "outputs": [],
   "source": [
    "day16_2←{evaluate 2⊃parse_packet hex_to_binary ⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 460,
   "id": "e08e1f46",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">3 54 7 9 1 0 0 1\n",
       "</span>"
      ]
     },
     "execution_count": 460,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day16_2¨'C200B40A82' '04005AC33890' '880086C3E88112' 'CE00C43D881120' 'D8005AC2A8F0' 'F600BC2D8F' '9C005AC2F8F0' '9C0141080250320F1802104A08'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84ee312d",
   "metadata": {},
   "source": [
    "The examples seem to work ok. This is pretty convenient and we\n",
    "could probably represent the tree as an APL expression instead, and\n",
    "use ⍎. Not for the first time I'm wondering if they had APL on the\n",
    "brain this year..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 461,
   "id": "42eaeac2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">831996589851\n",
       "</span>"
      ]
     },
     "execution_count": 461,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day16_2 data16"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b60feea0",
   "metadata": {},
   "source": [
    "## Day 17\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/17)\n",
    "\n",
    "Today the input is just 4 numbers so I'm going to type it in manually, being careful to use the unary ¯ instead of -."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 513,
   "id": "51152a77",
   "metadata": {},
   "outputs": [],
   "source": [
    "test17←20 30 ¯10 ¯5  ⍝ xmin..xmax ymin..ymax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 514,
   "id": "1d83c081",
   "metadata": {},
   "outputs": [],
   "source": [
    "data17←240 292 ¯90 ¯57"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbae0687",
   "metadata": {},
   "source": [
    "We are doing something with trajectories, which we will represent as\n",
    "2d arrays with one row per step. The current state is a 4-tuple x y vx vy\n",
    "in the last row that updates like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 522,
   "id": "01b0b9bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "step_projectile←{x y vx vy←,¯1↑⍵ ⋄ ⍵ ⍪ ((x+vx) (y+vy) (vx-×vx) (vy-1))}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c53d9a43",
   "metadata": {},
   "source": [
    "We'll iterate this until we've flown past the target. Since vy decreases\n",
    "monotonically and the target is below the x-axis, we'll just say that\n",
    "happens when y < ymin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 525,
   "id": "9032b5da",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "trajectory←{\n",
    "  vx vy←⍺\n",
    "  xmin xmax ymin ymax←⍵\n",
    "  past_target←{_ y _ _←,¯1↑⍵ ⋄ (y<ymin)}\n",
    "  (step_projectile⍣past_target)1 4⍴0 0 vx vy\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 526,
   "id": "afe20f8d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\"> 0   0 7  2\n",
       " 7   2 6  1\n",
       "13   3 5  0\n",
       "18   3 4 ¯1\n",
       "22   2 3 ¯2\n",
       "25   0 2 ¯3\n",
       "27  ¯3 1 ¯4\n",
       "28  ¯7 0 ¯5\n",
       "28 ¯12 0 ¯6\n",
       "28 ¯18 0 ¯7\n",
       "</span>"
      ]
     },
     "execution_count": 526,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 2 trajectory 20 30 ¯10 ¯5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "399b50dd",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "We'll just search velocities to find the best one. The target is to the\n",
    "right so we want 0 < vx ≤ xmax. Also ymin ≤ vy since any lower would go\n",
    "past immediately, and vy ≤ xmax since we get at most xmax x steps and vy\n",
    "only decreases by 1 each step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 532,
   "id": "6bac2465",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "day17_1←{\n",
    "  xmin xmax ymin ymax←⍵\n",
    "  ⍝ returns 1 if point is in target, else 0\n",
    "  in_target←{\n",
    "    x y _ _←⍵ ⋄ (x≥xmin)∧(x≤xmax)∧(y≥ymin)∧(y≤ymax)\n",
    "  }\n",
    "  ⍝ tries trajectory vx vy, returns max height if hits target else 0\n",
    "  trial←{\n",
    "    vx vy←⍵\n",
    "    points←vx vy trajectory xmin xmax ymin ymax\n",
    "    hit←∨/(in_target⍤1)points\n",
    "    hit:2⌷⌈⌿points\n",
    "    0\n",
    "  }\n",
    "  ⌈/,trial¨⍳xmax xmax  ⍝ not quite enough range but works for part 1\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 530,
   "id": "97e4c8e2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">45\n",
       "</span>"
      ]
     },
     "execution_count": 530,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day17_1 test17"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 531,
   "id": "534ba798",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">4005\n",
       "</span>"
      ]
     },
     "execution_count": 531,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⍝ day17_1 data17  ⍝ embarrassingly slow"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3bdc0ac",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Now we want all the velocities. This is sorta simpler actually..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 534,
   "id": "30f0de89",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "day17_2←{\n",
    "  xmin xmax ymin ymax←⍵\n",
    "  ⍝ returns 1 if point is in target, else 0\n",
    "  in_target←{\n",
    "    x y _ _←⍵ ⋄ (x≥xmin)∧(x≤xmax)∧(y≥ymin)∧(y≤ymax)\n",
    "  }\n",
    "  ⍝ returns 1 if trajectory with initial velocity vx vy hits target else 0\n",
    "  trial←{\n",
    "    vx vy←⍵\n",
    "    points←vx vy trajectory xmin xmax ymin ymax\n",
    "    ∨/(in_target⍤1)points\n",
    "  }\n",
    "  +/,trial¨(⍳xmax(1+xmax+|ymin))-⊂0(|ymin-1)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 535,
   "id": "d29b58c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">112\n",
       "</span>"
      ]
     },
     "execution_count": 535,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day17_2 test17"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 536,
   "id": "6fd1dbef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">2953\n",
       "</span>"
      ]
     },
     "execution_count": 536,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day17_2 data17"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27c6ad91",
   "metadata": {},
   "source": [
    "## Day 18\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/18)\n",
    "\n",
    "We get to do arithmetic with \"snailfish numbers\" aka nested pairs.\n",
    "This involves a bunch of scanning \"left\" and \"right\" so it's going to\n",
    "be simpler just to treat them as strings than to bother parsing.\n",
    "I did try, but gave up when Dyalog crashed with error 139 or something\n",
    "while I was trying to debug a basic tree traversal - you get what you\n",
    "pay for, I guess."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 564,
   "id": "8de31864",
   "metadata": {},
   "outputs": [],
   "source": [
    "test18←⊃⎕NGET 'day18-test.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 555,
   "id": "f8739344",
   "metadata": {},
   "outputs": [],
   "source": [
    "data18←⊃⎕NGET 'day18-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c77f3cb0",
   "metadata": {},
   "source": [
    "Adding a and b is just concatenating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 615,
   "id": "28db80ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "add_snailfish←{'[',⍺,',',⍵,']'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 616,
   "id": "a99ca148",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">[[1,2],[[3,4],5]]\n",
       "</span>"
      ]
     },
     "execution_count": 616,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'[1,2]' add_snailfish '[[3,4],5]'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4991c59f",
   "metadata": {},
   "source": [
    "But then reducing involves a bunch of hoo-ha."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 562,
   "id": "2f49ffdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "explode←{\n",
    "  start←((+\\(⍵='[')-(⍵=']'))=5)⍳1  ⍝ start of first pair to explode\n",
    "  start>≢⍵:⍵                       ⍝ if none, no need to explode\n",
    "  len←(start↓⍵)⍳']'                ⍝ end of first pair\n",
    "  a b←⍎(len-1)↑(start↓⍵)           ⍝ get numbers a b in pair\n",
    "  ⍝ add a to rightmost in left substring\n",
    "  add_to_left←{\n",
    "    (⍕(a+⍎(⍵.Lengths[2]↑⍵.Match))),(⍵.Lengths[2]↓⍵.Match)\n",
    "  }\n",
    "  ⍝ add b to leftmost in right substring\n",
    "  add_to_right←{\n",
    "    (⍵.Offsets[2]↑⍵.Match),⍕(b+⍎(⍵.Offsets[2]↓⍵.Match))\n",
    "  }\n",
    "  ⍝ form new left, right substrings\n",
    "  left←('(\\d+)[^\\d]*$'⎕R add_to_left)⊢(start-1)↑⍵\n",
    "  right←('^[^\\d]*(\\d+)'⎕R add_to_right)⊢(start+len)↓⍵\n",
    "  left,'0',right\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 566,
   "id": "63148326",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 566,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(explode '[[[[[9,8],1],2],3],4]')≡'[[[[0,9],2],3],4]'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 567,
   "id": "96371b3c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 567,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(explode '[7,[6,[5,[4,[3,2]]]]]')≡'[7,[6,[5,[7,0]]]]'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 568,
   "id": "285da821",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 568,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(explode '[[6,[5,[4,[3,2]]]],1]')≡'[[6,[5,[7,0]]],3]'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 569,
   "id": "5c3d39c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 569,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(explode '[[3,[2,[1,[7,3]]]],[6,[5,[4,[3,2]]]]]')≡'[[3,[2,[8,0]]],[9,[5,[4,[3,2]]]]]'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 570,
   "id": "dd8d690d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 570,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(explode '[[3,[2,[8,0]]],[9,[5,[4,[3,2]]]]]')≡'[[3,[2,[8,0]]],[9,[5,[7,0]]]]'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "534800f7",
   "metadata": {},
   "source": [
    "The other hoo-ha operation in reducing is \"split\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 586,
   "id": "5042bda4",
   "metadata": {},
   "outputs": [],
   "source": [
    "split←'(\\d\\d+).*'⎕R{n←⍎⍵.Lengths[2]↑⍵.Match ⋄ '[',(⍕⌊n÷2),',',(⍕⌈n÷2),']',⍵.Lengths[2]↓⍵.Match}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 587,
   "id": "997570a7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">[5,5]\n",
       "</span>"
      ]
     },
     "execution_count": 587,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "split '10'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 573,
   "id": "51ac1328",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">[5,6]\n",
       "</span>"
      ]
     },
     "execution_count": 573,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "split '11'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 575,
   "id": "48107f04",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 575,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(split '[[[[0,7],4],[15,[0,13]]],[1,1]]')≡'[[[[0,7],4],[[7,8],[0,13]]],[1,1]]'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 576,
   "id": "a917b999",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 576,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(split '[[[[0,7],4],[[7,8],[0,13]]],[1,1]]')≡'[[[[0,7],4],[[7,8],[0,[6,7]]]],[1,1]]'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8172f03",
   "metadata": {},
   "source": [
    "To reduce, iterate explode and split."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 588,
   "id": "112f5582",
   "metadata": {},
   "outputs": [],
   "source": [
    "reduce←(split∘(explode⍣≡))⍣≡"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 589,
   "id": "88912ba1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">[[[[0,7],4],[[7,8],[6,0]]],[8,1]]\n",
       "</span>"
      ]
     },
     "execution_count": 589,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduce '[[[[[4,3],4],4],[7,[[8,4],9]]],[1,1]]'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0983e495",
   "metadata": {},
   "source": [
    "Adding is folding (left) then reducing. APL's fold is right-to-left\n",
    "(because of course) so we need a helper for fold left. Note we have\n",
    "to be careful to reduce after each addition because otherwise we might\n",
    "end up with pairs nested more than 4 deep which breaks assumptions\n",
    "in explode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 638,
   "id": "448213df",
   "metadata": {},
   "outputs": [],
   "source": [
    "add_reduce←(reduce add_snailfish){↑⍺⍺⍨/(⌽⍵),⍬}⊢"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 639,
   "id": "81f698fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 639,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(add_reduce '[1,1]' '[2,2]' '[3,3]' '[4,4]')≡'[[[[1,1],[2,2]],[3,3]],[4,4]]'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 640,
   "id": "1fd7e93d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 640,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(add_reduce '[1,1]' '[2,2]' '[3,3]' '[4,4]' '[5,5]')≡'[[[[3,0],[5,3]],[4,4]],[5,5]]'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 642,
   "id": "7f8b8988",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 642,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(add_reduce '[1,1]' '[2,2]' '[3,3]' '[4,4]' '[5,5]' '[6,6]')≡'[[[[5,0],[7,4]],[5,5]],[6,6]]'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 645,
   "id": "1d31f6c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "larger_example←'[[[0,[4,5]],[0,0]],[[[4,5],[2,6]],[9,5]]]' '[7,[[[3,7],[4,3]],[[6,3],[8,8]]]]' '[[2,[[0,8],[3,4]]],[[[6,7],1],[7,[1,6]]]]' '[[[[2,4],7],[6,[0,5]]],[[[6,8],[2,8]],[[2,1],[4,5]]]]' '[7,[5,[[3,8],[1,4]]]]' '[[2,[2,2]],[8,[8,1]]]' '[2,9]' '[1,[[[9,3],9],[[9,0],[0,7]]]]' '[[[5,[7,4]],7],1]' '[[[[4,2],2],6],[8,7]]'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 646,
   "id": "750aad3b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 646,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(add_reduce larger_example)≡'[[[[8,7],[7,7]],[[8,6],[7,7]]],[[[0,7],[6,6]],[8,7]]]'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ce61c6b",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "We're supposed to multiply and add up the tree of pairs. If APL had operator\n",
    "precedence, we could substute +2× for ',' and so on and use ⍎. But it doesn't,\n",
    "so we have to build our own evaluator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 647,
   "id": "d22bc410",
   "metadata": {},
   "outputs": [],
   "source": [
    "translate←{⍺⍺(⍵⍵⌷⍨∘⊂⍳)@(∊∘⍺⍺)⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 650,
   "id": "06669996",
   "metadata": {},
   "outputs": [],
   "source": [
    "parse_snailfish←⍎'[],' translate '() '"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 651,
   "id": "0bf39010",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───┬───┐\n",
       "│9 1│1 9│\n",
       "└───┴───┘\n",
       "</span>"
      ]
     },
     "execution_count": 651,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parse_snailfish '[[9,1],[1,9]]'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 655,
   "id": "8819cc74",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "magnitude←{\n",
    "  0=≡⍵: ⍵\n",
    "  left right←⍵\n",
    "  (3×(magnitude left))+(2×(magnitude right))\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 664,
   "id": "5ae6cb66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 664,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "129=magnitude(parse_snailfish '[[9,1],[1,9]]')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 665,
   "id": "3cc4981b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 665,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "143=magnitude(parse_snailfish '[[1,2],[[3,4],5]]')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 666,
   "id": "76f36451",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 666,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1384=magnitude(parse_snailfish '[[[[0,7],4],[[7,8],[6,0]]],[8,1]]')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 667,
   "id": "037878d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 667,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "445=magnitude(parse_snailfish '[[[[1,1],[2,2]],[3,3]],[4,4]]')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 669,
   "id": "e9f708f6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 669,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "791=magnitude(parse_snailfish '[[[[3,0],[5,3]],[4,4]],[5,5]]')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 670,
   "id": "9b176ef1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 670,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1137=magnitude(parse_snailfish '[[[[5,0],[7,4]],[5,5]],[6,6]]')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 671,
   "id": "7733f1b1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 671,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3488=magnitude(parse_snailfish '[[[[8,7],[7,7]],[[8,6],[7,7]]],[[[0,7],[6,6]],[8,7]]]')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c76804a",
   "metadata": {},
   "source": [
    "Great, that all seems to work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 676,
   "id": "74fc0ae8",
   "metadata": {},
   "outputs": [],
   "source": [
    "day18_1←magnitude(parse_snailfish (add_reduce ⊢))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 677,
   "id": "2854368c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">4140\n",
       "</span>"
      ]
     },
     "execution_count": 677,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day18_1 test18"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 678,
   "id": "b8b1736c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">3216\n",
       "</span>"
      ]
     },
     "execution_count": 678,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day18_1 data18"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdd590c4",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Ok, find the largest magnitude for pairs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 688,
   "id": "338c4b34",
   "metadata": {},
   "outputs": [],
   "source": [
    "day18_2←⌈/,∘(∘.{day18_1 ⍺ ⍵}⍨⊢)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 689,
   "id": "cc90b1d1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">3993\n",
       "</span>"
      ]
     },
     "execution_count": 689,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day18_2 test18"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 690,
   "id": "de30be72",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">4643\n",
       "</span>"
      ]
     },
     "execution_count": 690,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day18_2 data18"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0e823c3",
   "metadata": {},
   "source": [
    "## Day 19\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/19)\n",
    "\n",
    "Today we've got a bunch of cattywampus 3d scanners that separately measure\n",
    "where some beacons are. We are gonna do a bunch of 3d transformations\n",
    "so will want to turn the points into homogeneous coordinates.\n",
    "\n",
    "All the \"each\" dots are super ugly today - I am sure there is a better way.\n",
    "We have to be careful reading input because there is an extra newline\n",
    "after each scanner's data except the last."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 735,
   "id": "0a6100a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "test19←{⍵,1}¨¨⍎¨¨¨','(≠⊆⊢)¨¨{{''≡⊃(¯1↑⍵): ¯1↓⍵ ⋄ ⍵}(1↓⍵)}¨{('s'∊¨⍵)⊂⍵}⊃⎕NGET'day19-test.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 736,
   "id": "3f633481",
   "metadata": {},
   "outputs": [],
   "source": [
    "data19←{⍵,1}¨¨⍎¨¨¨','(≠⊆⊢)¨¨{{''≡⊃(¯1↑⍵): ¯1↓⍵ ⋄ ⍵}(1↓⍵)}¨{('s'∊¨⍵)⊂⍵}⊃⎕NGET'day19-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "762238b4",
   "metadata": {},
   "source": [
    "We will need to line some of the scanners' coordinate frames up.\n",
    "Each of 3 axes might be negated or not and there are 6 permutations\n",
    "of axes. But half of those transformations turn the universe inside\n",
    "out, so det M=1 filters out the 24 we want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 737,
   "id": "0fe6efe3",
   "metadata": {},
   "outputs": [],
   "source": [
    "permutations←{(⍳⍵)(,[⍳2](⊢,⍤1 0~)⍤1)⍣⍵⍉⍪⍬}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 738,
   "id": "ae529faa",
   "metadata": {},
   "outputs": [],
   "source": [
    "det←{-/+/×/[2](2 3⍴0 1 2 0 2 1)⌽↑⍵ ⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 739,
   "id": "93b2f5ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "orientations←{(1=(det⍤2)⍵)⌿⍵}↑↑{×⍵×(1-|⍵)⌽↑(1 0 0)}¨¨,(↓⍉(1-2×(2 2 2⊤⍳8)))∘.×↓(permutations 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 740,
   "id": "77cc54c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "orientations←↑{((↑↑⍵),0)⍪(0 0 0 1)}¨↓↓orientations  ⍝ turn 3x3s into 4x4s"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b525fab6",
   "metadata": {},
   "source": [
    "We'll want the 4x4 identity matrix I4, and a helper to make\n",
    "transformation matrices combining a translation and a rotation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 741,
   "id": "49798556",
   "metadata": {},
   "outputs": [],
   "source": [
    "I4←↑(1 0 0 0)(0 1 0 0)(0 0 1 0)(0 0 0 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 742,
   "id": "fd1ccede",
   "metadata": {},
   "outputs": [],
   "source": [
    "transform←{p rmat←⍵ ⋄ ((¯1↓(↑p))@(1 4)(2 4)(3 4))⊢rmat}  ⍝ note ignore 4th of p"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5fac7a4",
   "metadata": {},
   "source": [
    "To align two scanners, we guess which beacons i j are the same and\n",
    "get points relative to that, also trying all rotations k of the second\n",
    "scanner relative to the first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 743,
   "id": "93801d1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "align←{\n",
    "  scanner1 scanner2←⍵\n",
    "  trial←{\n",
    "    ⍝ count i j k up to corresponding array bounds\n",
    "    none k j i←(2(≢orientations)(≢⊃scanner2)(≢⊃scanner1)⊤⍵)+(0 1 1 1)\n",
    "    none:0  ⍝ no alignment possible\n",
    "    ⍝ u translates scanner1 points relative to point i\n",
    "    u←transform(-i⌷⊃scanner1)I4\n",
    "    ⍝ v translates scanner2 points relative to point j and rotates\n",
    "    ⍝ (note that point j must be rotated first)\n",
    "    pj←⍉k⌷orientations+.×(⍉↑j⌷⊃scanner2)\n",
    "    v←transform(-pj)(k⌷orientations)\n",
    "    scanner1_p←↓↑{⍉u+.×(⍉↑⍵)}¨scanner1\n",
    "    scanner2_p←↓↑{⍉v+.×(⍉↑⍵)}¨scanner2\n",
    "    ⍝ count transformed point matches\n",
    "    num_matches←scanner1_p(+/∊)scanner2_p\n",
    "    num_matches≥12:(⌹u)+.×(v)  ⍝ transform from 2->1 frame\n",
    "    ∇(⍵+1)\n",
    "  }\n",
    "  trial 0\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 730,
   "id": "528fe8c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">¯1 0  0    68\n",
       " 0 1  0 ¯1246\n",
       " 0 0 ¯1   ¯43\n",
       " 0 0  0     1\n",
       "</span>"
      ]
     },
     "execution_count": 730,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "align (1⌷test19) (2⌷test19)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4137ec0",
   "metadata": {},
   "source": [
    "align returns a transformation matrix that maps back to scanner1's frame.\n",
    "For example, the 10th beacon in scanner1's list is the same as the 1st\n",
    "beacon in scanner2's list, so multiplying the result matrix canonicalizes\n",
    "to scanner1's frame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 731,
   "id": "9d1a5e9a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌────────────────┐\n",
       "│¯618 ¯824 ¯621 1│\n",
       "└────────────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 731,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10⌷⊃(1⌷test19)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 732,
   "id": "6ee04184",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">¯618 ¯824 ¯621 1\n",
       "</span>"
      ]
     },
     "execution_count": 732,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⍉((align (1⌷test19) (2⌷test19)))+.×(⍉↑(1⌷⊃(2⌷test19)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5461a6a2",
   "metadata": {},
   "source": [
    "Then we can just search to figure out the relative positions of all the probes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 750,
   "id": "0f8f57e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "align_all←{\n",
    "  scanners←⍵\n",
    "  done←1⍴1              ⍝ indices that are done\n",
    "  todo←1↓⍳≢scanners     ⍝ indices left todo\n",
    "  mats←{I4}¨⍳≢scanners  ⍝ transform to canonical frame\n",
    "  ⍝ match a scanner from todo with one from done\n",
    "  find_pair←{\n",
    "    ⍝ iterate i j over todo and done\n",
    "    none j i←(2(≢done)(≢todo)⊤⍵)+(0 1 1)\n",
    "    none:'error'\n",
    "    ith jth←(i⌷todo)(j⌷done)\n",
    "    ⍝ try aligning scanner i with j\n",
    "    r←align(jth⌷scanners)(ith⌷scanners)\n",
    "    r≡0:∇(⍵+1)  ⍝ no alignment, iterate\n",
    "    ⍝ update transform for scanner i\n",
    "    mats[ith]←⊂(⊃mats[jth])+.×r\n",
    "    ⍝ mark scanner i done\n",
    "    done,←todo[i]\n",
    "    todo⊢←((i-1)↑todo),(i↓todo)\n",
    "    search 0\n",
    "  }\n",
    "  ⍝ search until all scanners are done\n",
    "  search←{\n",
    "    0=≢todo:mats\n",
    "    find_pair 0\n",
    "  }\n",
    "  search 0\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05f325ae",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "How many beacons are there total? We can just find all the transforms,\n",
    "and then collect unique positions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 745,
   "id": "f1accff0",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "day19_1←{\n",
    "  scanners←⍵\n",
    "  mats←align_all scanners\n",
    "  ≢∪⊃,/{\n",
    "    r←⊃mats[⍵]\n",
    "    beacons←⊃scanners[⍵]\n",
    "    ↓↑{⍉r+.×(⍉↑⍵)}¨beacons\n",
    "  }¨⍳≢⍵\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 751,
   "id": "59a7613e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">79\n",
       "</span>"
      ]
     },
     "execution_count": 751,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day19_1 test19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 752,
   "id": "3cf682be",
   "metadata": {},
   "outputs": [],
   "source": [
    "⍝day19_1 data19  ⍝ this is extremely... slow..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6380449d",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Find the max distance between two scanners. We can get this from their\n",
    "transformation matrices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 754,
   "id": "85dd2c3b",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "day19_2←{\n",
    "  scanners←⍵\n",
    "  mats←align_all scanners\n",
    "  origins←{⍵[(1 4) (2 4) (3 4)]}¨mats\n",
    "  ⌈/,∘.{+/|⍺-⍵}⍨origins\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 755,
   "id": "f9e197a7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">3621\n",
       "</span>"
      ]
     },
     "execution_count": 755,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day19_2 test19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 756,
   "id": "47fdee27",
   "metadata": {},
   "outputs": [],
   "source": [
    "⍝day19_2 data19  ⍝ very... very... slow"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "631bc36e",
   "metadata": {},
   "source": [
    "## Day 20\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/20)\n",
    "\n",
    "Ok, this one seems made for APL."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 777,
   "id": "4c3aaefb",
   "metadata": {},
   "outputs": [],
   "source": [
    "test20_lookup←'#'∘=¨⊃⊃⎕NGET 'day20-test.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 758,
   "id": "0afc2a70",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 0 0 1 0\n",
       "1 0 0 0 0\n",
       "1 1 0 0 1\n",
       "0 0 1 0 0\n",
       "0 0 1 1 1\n",
       "</span>"
      ]
     },
     "execution_count": 758,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test20_bitmap←↑'#'∘=¨2↓⊃⎕NGET 'day20-test.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 760,
   "id": "0472aab7",
   "metadata": {},
   "outputs": [],
   "source": [
    "data20_lookup←'#'∘=¨⊃⊃⎕NGET 'day20-input.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 761,
   "id": "e5daf6de",
   "metadata": {},
   "outputs": [],
   "source": [
    "data20_bitmap←↑'#'∘=¨2↓⊃⎕NGET 'day20-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "942bf006",
   "metadata": {},
   "source": [
    "To enhance, we could just use the stencil operator with its default padding.\n",
    "But trickly the input lookup maps index 0 to 1, so the array should be\n",
    "1-padded on odd iterations!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 772,
   "id": "b9f1c08e",
   "metadata": {},
   "outputs": [],
   "source": [
    "enhance_even←{k←⍺ ⋄ ({k[1+2⊥,⍵]}⌺3 3⊢)0(,∘⌽∘⍉⍣20)⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 773,
   "id": "f9b43ce6",
   "metadata": {},
   "outputs": [],
   "source": [
    "enhance_odd←{k←⍺ ⋄ ¯4↓[2]¯4↓4↓4↓[2]({k[1+2⊥,⍵]}⌺3 3⊢)k[1](,∘⌽∘⍉⍣20)⍵}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7803c85",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "Count 1s after enhancing twice (after once would be infinite!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 774,
   "id": "d43cd6c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "day20_1←{+/,(⍺ enhance_odd (⍺ enhance_even ⍵))}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 775,
   "id": "b6946426",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">35\n",
       "</span>"
      ]
     },
     "execution_count": 775,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test20_lookup day20_1 test20_bitmap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 776,
   "id": "1a490b42",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">5275\n",
       "</span>"
      ]
     },
     "execution_count": 776,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data20_lookup day20_1 data20_bitmap"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc7d8585",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Now enhance 50 times instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 782,
   "id": "c07dbea2",
   "metadata": {},
   "outputs": [],
   "source": [
    "day20_2←{k←⍺ ⋄ +/,({(k enhance_odd (k enhance_even ⍵))}⍣25)⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 783,
   "id": "bccb0abe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">3351\n",
       "</span>"
      ]
     },
     "execution_count": 783,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test20_lookup day20_2 test20_bitmap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 785,
   "id": "dacf58ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">16482\n",
       "</span>"
      ]
     },
     "execution_count": 785,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data20_lookup day20_2 data20_bitmap"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb52f88d",
   "metadata": {},
   "source": [
    "## Day 21\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/21)\n",
    "\n",
    "We get to play with dice today. My first instinct was to pass a dice\n",
    "closure to a simulation function, but APL doesn't have first class functions.\n",
    "So instead, I'll think about the sequences of rolls for each player."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 867,
   "id": "0e1cf004",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">6 24 42 60 78 96 114 132 150 168 186 204 222 240 258 276 294 12 30 48 66 84 102\n",
       "\n",
       "       120 138 156 174 192 210 228 246 264 282 200 18 36 54 72 90 108 126 144 1\n",
       "\n",
       "      62 180 198 216 234 252 270 288\n",
       "</span>"
      ]
     },
     "execution_count": 867,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(6{⍵⌿⍨0=⍺|⍳≢⍵}3+/1+100|⊢)((⍳306)-6)  ⍝ player 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8c359c5",
   "metadata": {},
   "source": [
    "This looks like just 6+18n (mod 300) where n is the turn."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 876,
   "id": "eab9ce34",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">6 24 42 60 78 96 114 132 150 168 186 204 222 240 258 276 294 12 30 48 66 84 102\n",
       "\n",
       "       120 138 156 174 192 210 228 246 264 282 300 18 36 54 72 90 108 126 144 1\n",
       "\n",
       "      62 180 198 216 234 252 270 288\n",
       "</span>"
      ]
     },
     "execution_count": 876,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6+(300|(18×(⍳50)-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6073643",
   "metadata": {},
   "source": [
    "To find score totals we could add that up mod 10 and add the start position."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 877,
   "id": "c70f9225",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">10 14 20 26 30 40 44 50 56 60 70 74 80 86 90 100 104 110 116 120 130 134 140 14\n",
       "\n",
       "      6 150 160 164 170 176 180 190 194 200 206 210 220 224 230 236 240 250 254\n",
       "\n",
       "       260 266 270 280 284 290 296 300\n",
       "</span>"
      ]
     },
     "execution_count": 877,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+\\4+10|+\\(6+(100|(18×(⍳50)-1)))  ⍝ 4 is start position"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "baa5c18c",
   "metadata": {},
   "source": [
    "But note that positions are cyclical with period 5 for player 1 and\n",
    "10 for player 2, hmm. This is gonna be a little overcomplicated for\n",
    "part 1, but why not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 909,
   "id": "b57f19ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">10 4 6 6 4 10 4 6 6 4 10 4 6 6 4 10 4 6 6 4 10 4 6 6 4 10 4 6 6 4 10 4 6 6 4 10\n",
       "\n",
       "       4 6 6 4 10 4 6 6 4 10 4 6 6 4\n",
       "</span>"
      ]
     },
     "execution_count": 909,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10(⊢+⊣×0=⊢)10|4++\\(6+(100|(18×(⍳50)-1)))  ⍝ player 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 910,
   "id": "7f53708f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">3 6 7 6 3 8 1 2 1 8 3 6 7 6 3 8 1 2 1 8 3 6 7 6 3 8 1 2 1 8 3 6 7 6 3 8 1 2 1 8\n",
       "\n",
       "       3 6 7 6 3 8 1 2 1 8\n",
       "</span>"
      ]
     },
     "execution_count": 910,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10(⊢+⊣×0=⊢)10|8++\\(15+(100|(18×(⍳50)-1)))  ⍝ player 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8e36aae",
   "metadata": {},
   "source": [
    "I bet all the positions repeat every 10 turns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 936,
   "id": "a26f5c6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "ten_turns←{start offset←⍵ ⋄ 10(⊢+⊣×0=⊢)10|start++\\(offset+(100|(18×(⍳10)-1)))}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 937,
   "id": "603545d1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">10 4 6 6 4 10 4 6 6 4\n",
       "</span>"
      ]
     },
     "execution_count": 937,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ten_turns 4 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 938,
   "id": "66205c1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 4 5 4 1 6 9 10 9 6\n",
       "</span>"
      ]
     },
     "execution_count": 938,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ten_turns 6 15"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa721c25",
   "metadata": {},
   "source": [
    "This suggests a way to compute the score for turn number n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 939,
   "id": "1ff2ddeb",
   "metadata": {},
   "outputs": [],
   "source": [
    "score←{seq n←⍵ ⋄ (+\\(0,seq))[1+(10|n)]+((⌊(n÷10))×(+/seq))}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 948,
   "id": "a63d37c8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1000\n",
       "</span>"
      ]
     },
     "execution_count": 948,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "score (ten_turns 4 6) 166"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 949,
   "id": "8dd36671",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1000\n",
       "</span>"
      ]
     },
     "execution_count": 949,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "¯1↑+\\4+10|+\\(6+(100|(18×(⍳166)-1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "919fc770",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "Find the winning turn.  We can just binary search... but I really\n",
    "don't want to write binary search.\n",
    "\n",
    "TIL that Dyalog has a\n",
    "[standard library](https://aplwiki.com/wiki/Dfns_workspace)!\n",
    "You can copy stuff out of the baked in 'dfns' workspace... that's\n",
    "kinda nice. Note that binary search takes a function as an\n",
    "argument by actually being an \"operator\", which is allowed to\n",
    "operate on functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 953,
   "id": "d69dfe1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "'bsearch'⎕CY'dfns'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 963,
   "id": "446b9b67",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "day21_1←{\n",
    "  start1 start2←⍵\n",
    "  score1←{(score (ten_turns start1 6) ⍵)}\n",
    "  score2←{(score (ten_turns start2 15) ⍵)}\n",
    "  max_turns←1e12\n",
    "  win1←{(score1 ⍵)≥1000} bsearch 1 max_turns\n",
    "  win2←{(score2 ⍵)≥1000} bsearch 1 max_turns\n",
    "  win1<win2: ((6×(win1-1))+3)×(score2 (win1-1))  ⍝ p1 wins\n",
    "  (6×win2)×(score1 win2) ⍝ p2 wins\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 964,
   "id": "bc3f87e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">739785\n",
       "</span>"
      ]
     },
     "execution_count": 964,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day21_1 4 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 965,
   "id": "0dfdd371",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">518418\n",
       "</span>"
      ]
     },
     "execution_count": 965,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day21_1 8 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2d96614",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Ok, now we have a quantum die, and have to count winning games.\n",
    "This seems like a dynamic programming thing. We will tabulate\n",
    "outcomes (#p1wins #p2wins), filling in backwards to avoid crazy\n",
    "recursion.\n",
    "\n",
    "I am going to use for loops, because it is easier to understand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 972,
   "id": "608b3956",
   "metadata": {},
   "outputs": [],
   "source": [
    "dirac_table←2 10 21 10 21⍴(0 0)  ⍝ to_play p1 p1_score+1 p2 p2_score+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 973,
   "id": "c39b0593",
   "metadata": {},
   "outputs": [],
   "source": [
    " ]dinput\n",
    " r←tabulate_dirac_wins;to_play;p1;p1_n;p2;p2_n;p1_score;p2_score;r1;r2;r3;outcome\n",
    " mod10←{10(⊢+⊣×0=⊢)(10|⍵)}\n",
    " :For p1_score :In ⌽(⍳21)-1\n",
    "     :For p2_score :In ⌽(⍳21)-1\n",
    "         :For p1 :In ⍳10\n",
    "             :For p2 :In ⍳10\n",
    "                 :For to_play :In ⍳2\n",
    "                     :For r1 :In ⍳3\n",
    "                         :For r2 :In ⍳3\n",
    "                             :For r3 :In ⍳3\n",
    "                                 :If to_play=1\n",
    "                                     p1_n←mod10(p1+r1+r2+r3)\n",
    "                                     :If (p1_score+p1_n)≥21\n",
    "                                         outcome←⊂1 0\n",
    "                                     :Else\n",
    "                                         outcome←dirac_table[2;p1_n;1+p1_score+p1_n;p2;1+p2_score]\n",
    "                                     :EndIf\n",
    "                                 :Else ⍝ to_play=2\n",
    "                                     p2_n←mod10(p2+r1+r2+r3)\n",
    "                                     :If (p2_score+p2_n)≥21\n",
    "                                         outcome←⊂0 1\n",
    "                                     :Else\n",
    "                                         outcome←dirac_table[1;p1;1+p1_score;p2_n;1+p2_score+p2_n]\n",
    "                                     :EndIf\n",
    "                                 :EndIf\n",
    "                                 dirac_table[to_play;p1;1+p1_score;p2;1+p2_score]+←outcome\n",
    "                             :EndFor\n",
    "                         :EndFor\n",
    "                     :EndFor\n",
    "                 :EndFor\n",
    "             :EndFor\n",
    "         :EndFor\n",
    "     :EndFor\n",
    " :EndFor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 974,
   "id": "af79fdcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "tabulate_dirac_wins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 983,
   "id": "5af37cee",
   "metadata": {},
   "outputs": [],
   "source": [
    "day21_2←{start1 start2←⍵ ⋄ ⌈/⊃dirac_table[1;start1;1;start2;1]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 981,
   "id": "35aeb0d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "⎕PP←16  ⍝ big numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 984,
   "id": "f43bffb4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">444356092776315\n",
       "</span>"
      ]
     },
     "execution_count": 984,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day21_2 4 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 985,
   "id": "8860f8d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">116741133558209\n",
       "</span>"
      ]
     },
     "execution_count": 985,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day21_2 8 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c49449a4",
   "metadata": {},
   "source": [
    "## Day 22\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/22)\n",
    "\n",
    "3d bitmap wrangling today."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fb37240e",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "parse_cuboid←{\n",
    "  ⍝ extract on/off and numbers from 'on x=-20..26,y=-36..17,z=-47..7'\n",
    "  ⍝ return 0|1 xmin xmax ymin ymax zmin zmax\n",
    "  xs←' '(≠⊆⊢)('(on|off) x=(-?\\d+)..(-?\\d+),y=(-?\\d+)..(-?\\d+),z=(-?\\d+)..(-?\\d+)'⎕R'\\1 \\2 \\3 \\4 \\5 \\6 \\7')⊢⍵\n",
    "  ((⊃(1↑xs))≡'on'),(⍎¨1↓xs)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "dd6b651a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─────────────────────┬──────────────────────┬──────────────────────┬──────────\n",
       "│1 ¯20 26 ¯36 17 ¯47 7│1 ¯20 33 ¯21 23 ¯26 28│1 ¯22 28 ¯29 23 ¯38 16│1 ¯46 7 ¯6\n",
       "└─────────────────────┴──────────────────────┴──────────────────────┴──────────\n",
       "\n",
       "      ──────────┬────────────────────┬────────────────────┬────────────────────\n",
       "       46 ¯50 ¯1│1 ¯49 1 ¯3 46 ¯24 28│1 2 47 ¯22 22 ¯23 27│1 ¯27 23 ¯28 26 ¯21 \n",
       "      ──────────┴────────────────────┴────────────────────┴────────────────────\n",
       "\n",
       "      ──┬───────────────────┬─────────────────────┬──────────────────────┬─────\n",
       "      29│1 ¯39 5 ¯6 47 ¯3 44│1 ¯30 21 ¯8 43 ¯13 34│1 ¯22 26 ¯27 20 ¯29 19│0 ¯48\n",
       "      ──┴───────────────────┴─────────────────────┴──────────────────────┴─────\n",
       "\n",
       "      ──────────────────┬────────────────────┬────────────────────────┬────────\n",
       "       ¯32 26 41 ¯47 ¯37│1 ¯12 35 6 50 ¯50 ¯2│0 ¯48 ¯32 ¯32 ¯16 ¯15 ¯5│1 ¯18 26\n",
       "      ──────────────────┴────────────────────┴────────────────────────┴────────\n",
       "\n",
       "      ─────────────┬───────────────────────┬─────────────────────┬─────────────\n",
       "       ¯33 15 ¯7 46│0 ¯40 ¯22 ¯38 ¯28 23 41│1 ¯16 35 ¯41 10 ¯47 6│0 ¯32 ¯23 11 \n",
       "      ─────────────┴───────────────────────┴─────────────────────┴─────────────\n",
       "\n",
       "      ────────┬─────────────────────┬────────────────────┬────────────────────┬\n",
       "      30 ¯14 3│1 ¯49 ¯5 ¯3 45 ¯29 18│0 18 30 ¯20 ¯8 ¯3 13│1 ¯41 9 ¯7 43 ¯33 15│\n",
       "      ────────┴─────────────────────┴────────────────────┴────────────────────┴\n",
       "\n",
       "      ─────────────────────────────────────────┬───────────────────────────────\n",
       "      1 ¯54112 ¯39298 ¯85059 ¯49293 ¯27449 7877│1 967 23432 45373 81175 27513 5\n",
       "      ─────────────────────────────────────────┴───────────────────────────────\n",
       "\n",
       "      ────┐\n",
       "      3682│\n",
       "      ────┘\n",
       "</span>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test22←parse_cuboid¨⊃⎕NGET 'day22-test.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "489ff14d",
   "metadata": {},
   "outputs": [],
   "source": [
    "data22←parse_cuboid¨⊃⎕NGET 'day22-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f727b339",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "Count the \"on\" cubes in the volume ¯50≤x≤50, ¯50≤y≤50, ¯50≤z≤50."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a614aa50",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "day22_1←{\n",
    "  ⍝ we'll make a big 3d bitmap and just count\n",
    "  cubes←101 101 101⍴0\n",
    "  _←{\n",
    "    bit x0 x1 y0 y1 z0 z1←⍵\n",
    "    (x1<¯50)∨(x0>50):0\n",
    "    (y1<¯50)∨(y0>50):0\n",
    "    (z1<¯50)∨(z0>50):0\n",
    "    cuboid←(⊂(50+x0)(50+y0)(50+z0))+(⍳((x1-x0)+1)((y1-y0)+1)((z1-z0)+1))\n",
    "    cubes⊢←bit@cuboid⊢cubes\n",
    "    0\n",
    "  }¨⍵\n",
    "  +/,cubes\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d6020bcc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">590784\n",
       "</span>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day22_1 test22"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "fd545db9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">602574\n",
       "</span>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day22_1 data22"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee317cb3",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Count all the \"on\" cubes.  We get a new test case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "308ed8eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "test22_2←parse_cuboid¨⊃⎕NGET 'day22-test2.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d21a2df9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 ¯120100 ¯40997 ¯124565 ¯50804 ¯121762 ¯30197\n",
       "1   55694 120875   50097 118853   54442 119054\n",
       "</span>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↑(⌊/test22_2),⌈/test22_2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46015b5e",
   "metadata": {},
   "source": [
    "The volume is about 250k^3 which is too big for a bitmap.\n",
    "We could compute new cuboids for each cuboid-cuboid union or\n",
    "intersection, and keep a running list. Or we could do the\n",
    "same for rectangles on 250k slices. But I'd prefer to use a\n",
    "subdivision algorithm instead if at all possible so I don't\n",
    "have to think about all the weird cases."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55aca26b",
   "metadata": {},
   "source": [
    "We'll need to intersect cuboids with aribtrary volumes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "3536c722",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "intersect_cuboids_with_volume←{\n",
    "  ⍝ all ranges are closed [x0,x1] [y0,y1] [z0,z1]\n",
    "  vx0 vx1 vy0 vy1 vz0 vz1 cuboids←⍵\n",
    "  rs←{\n",
    "    bit x0 x1 y0 y1 z0 z1←⍵\n",
    "    (x1<vx0)∨(x0>vx1): 0\n",
    "    (y1<vy0)∨(y0>vy1): 0\n",
    "    (z1<vz0)∨(z0>vz1): 0\n",
    "    ⍝ max start, min end per axis\n",
    "    xs←(⌈/x0 vx0) (⌊/x1 vx1)\n",
    "    ys←(⌈/y0 vy0) (⌊/y1 vy1)\n",
    "    zs←(⌈/z0 vz0) (⌊/z1 vz1)\n",
    "    bit,xs,ys,zs\n",
    "  }¨cuboids\n",
    "  ⍝ filter only overlapping cuboids\n",
    "  (0∘≢¨rs)/rs\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "17858e97",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─────────────┐\n",
       "│0 0 5 0 5 0 5│\n",
       "└─────────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intersect_cuboids_with_volume ¯10 10 ¯10 10 ¯10 10 (⊂0 0 5 0 5 0 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "2b4c31de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─────────────┬──────────────┐\n",
       "│0 0 5 0 5 0 5│1 9 10 0 5 0 5│\n",
       "└─────────────┴──────────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intersect_cuboids_with_volume ¯10 10 ¯10 10 ¯10 10 ((0 0 5 0 5 0 5)(1 11 15 0 5 0 5)(1 9 15 0 5 0 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "394bb232",
   "metadata": {},
   "source": [
    "To count cubes in a volume, consider the cuboids inside. If there are\n",
    "none, there are 0 cubes. If there's one, there are however many cubes\n",
    "that has. If there are two or more cuboids, take the last, and sum the\n",
    "count of cubes outside (recursively) and inside. Since it is the last\n",
    "cuboid from the list, it takes precedence, so we don't need to recurse\n",
    "to count inside - the count is just its bit times its volume.\n",
    "\n",
    "The recursion is error-prone and it took me a while to find some bugs\n",
    "subdividing volumes! Stepping through simple examples was a big help."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "5376a40c",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "day22_2←{\n",
    "  ⍝ number of on cubes in a cuboid\n",
    "  on_cubes←{bit x0 x1 y0 y1 z0 z1←⍵ ⋄ bit×(1+(x1-x0))×(1+(y1-y0))×(1+(z1-z0))}\n",
    "  count←{\n",
    "    x0 x1 y0 y1 z0 z1 cs←⍵\n",
    "    0=≢cs:0\n",
    "    1=≢cs:on_cubes ⊃cs\n",
    "    ⍝ if two or more cuboids, partition on the last\n",
    "    bit cx0 cx1 cy0 cy1 cz0 cz1←⊃(¯1↑cs)\n",
    "    cs←¯1↓cs\n",
    "    ⍝ non-overlapping nested volumes outside the last cuboid\n",
    "    left←x0(cx0-1)y0 y1 z0 z1        ⍝ <cx0\n",
    "    right←(cx1+1)x1 y0 y1 z0 z1      ⍝ >cx1\n",
    "    below←cx0 cx1 y0(cy0-1)z0 z1     ⍝ in [cx0,cx1], <cy0 \n",
    "    above←cx0 cx1(cy1+1)y1 z0 z1     ⍝ in [cx0,cx1], >cy1 \n",
    "    behind←cx0 cx1 cy0 cy1 z0(cz0-1) ⍝ in [cx0,cx1], in [cy0,cy1], <cz0\n",
    "    front←cx0 cx1 cy0 cy1(cz1+1)z1   ⍝ in [cx0,cx1], in [cy0,cy1], >cz1\n",
    "    ⍝ count cubes outside\n",
    "    num_outside←+/{\n",
    "      x0 x1 y0 y1 z0 z1←⍵\n",
    "      (x0>x1)∨(y0>y1)∨(z0>z1): 0 ⍝ empty\n",
    "      count ⍵,⊂(intersect_cuboids_with_volume ⍵,⊂cs)\n",
    "    }¨(left right below above behind front)\n",
    "    ⍝ as this is the last cuboid, it takes precedence over its volume\n",
    "    num_outside+(on_cubes bit cx0 cx1 cy0 cy1 cz0 cz1)\n",
    "  }\n",
    "  ⍝ bound all the cuboids\n",
    "  _ x0 _ y0 _ z0 _←⊃⌊/⍵\n",
    "  _ _ x1 _ y1 _ z1←⊃⌈/⍵\n",
    "  count x0 x1 y0 y1 z0 z1 ⍵\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "3954a804",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">590784\n",
       "</span>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day22_2 (¯2↓test22) ⍝ same as part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "77eccad8",
   "metadata": {},
   "outputs": [],
   "source": [
    "⎕PP←16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "3f4c951a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">2758514936282235\n",
       "</span>"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day22_2 test22_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "4957b2e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1288707160324706\n",
       "</span>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day22_2 data22"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42d8279e",
   "metadata": {},
   "source": [
    "## Day 23\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/23)\n",
    "\n",
    "Another search problem today..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1535e769",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">#############\n",
       "#...........#\n",
       "###B#C#B#D###\n",
       "  #A#D#C#A#  \n",
       "  #########  \n",
       "</span>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test23←↑⊃⎕NGET 'day23-test.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "92769006",
   "metadata": {},
   "outputs": [],
   "source": [
    "data23←↑⊃⎕NGET 'day23-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "831d8a36",
   "metadata": {},
   "source": [
    "We are supposed to find the lowest cost way to move some letters\n",
    "(amphipods, I'll call them pods) around a nethack level. We will\n",
    "need a way to enumerate moves and their costs.\n",
    "\n",
    "⍳ is irritating when you don't want 1..n, let's write a more generic\n",
    "range function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ba79bc7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "range←{a b←⍵ ⋄ a+((×(b-a))×((⍳1+|(b-a))-1))}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ea9b63d6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">3 4\n",
       "</span>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range 3 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e8224e29",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">6 5 4 3 2 1\n",
       "</span>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range 6 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9f87dfa",
   "metadata": {},
   "source": [
    "Here are the ways to move pods following the rules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b2c031f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "enumerate_pod_moves←{\n",
    "  grid←⍵\n",
    "  ⍝ move if hallway clear\n",
    "  move←{\n",
    "    p from to←⍵\n",
    "    ⍝ offset \"from\" so we don't count the square where the pod is\n",
    "    ⍝ (if it's in a room, this ignores the doorway, but since doorways\n",
    "    ⍝ are never occupied this is ok)\n",
    "    dx←×(to[2]-from[2])\n",
    "    ∨/'.'≠grid[{2,⍵}¨range(dx+from[2])(to[2])]:⍬ ⍝ blocked\n",
    "    (p from to)\n",
    "  }\n",
    "  ⍝ move pod from \"from\" into its room, if allowed\n",
    "  move_to_room←{\n",
    "    p from room←⍵\n",
    "    ⍝ ok if room is empty: take the deepest cell\n",
    "    grid[room]≡'..':⊂move(p from (⊃room[2]))\n",
    "    ⍝ ok if room has another p pod\n",
    "    grid[room]≡('.',p):⊂move(p from (⊃room[1]))\n",
    "    ⍬\n",
    "  }\n",
    "  ⍝ non-doorway hallway positions\n",
    "  hallway←(2 2)(2 3)(2 5)(2 7)(2 9)(2 11)(2 12)\n",
    "  ⍝ enumerate moves for each pod\n",
    "  moves←↑,/{\n",
    "    from←⍵\n",
    "    p←grid[⊂from]\n",
    "    ⍝ can only move from hallway to own room\n",
    "    ((⊂from)∊hallway)∧(p='A'):move_to_room p from((3 4)(4 4))\n",
    "    ((⊂from)∊hallway)∧(p='B'):move_to_room p from((3 6)(4 6))\n",
    "    ((⊂from)∊hallway)∧(p='C'):move_to_room p from((3 8)(4 8))\n",
    "    ((⊂from)∊hallway)∧(p='D'):move_to_room p from((3 10)(4 10))\n",
    "    ⍝ else move to hallway\n",
    "    grid[⊂from-1 0]≠'.':⍬ ⍝ blocked\n",
    "    {move p from ⍵}¨hallway\n",
    "  }¨grid(⍸∊)'ABCD'\n",
    "  (({(≢⍵)>0}¨moves)/moves) ⍝ filter out empty moves\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "686e55eb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───────────┬───────────┬───────────┬───────────┬───────────┬────────────┬────────────┬───────────┬───────────┬───────────┬───────────┬───────────┬────────────┬────────────┬───────────┬───────────┬───────────┬───────────┬───────────┬────────────┬────────────┬────────────┬────────────┬────────────┬────────────┬────────────┬─────────────┬─────────────┐\n",
       "│┌─┬───┬───┐│┌─┬───┬───┐│┌─┬───┬───┐│┌─┬───┬───┐│┌─┬───┬───┐│┌─┬───┬────┐│┌─┬───┬────┐│┌─┬───┬───┐│┌─┬───┬───┐│┌─┬───┬───┐│┌─┬───┬───┐│┌─┬───┬───┐│┌─┬───┬────┐│┌─┬───┬────┐│┌─┬───┬───┐│┌─┬───┬───┐│┌─┬───┬───┐│┌─┬───┬───┐│┌─┬───┬───┐│┌─┬───┬────┐│┌─┬───┬────┐│┌─┬────┬───┐│┌─┬────┬───┐│┌─┬────┬───┐│┌─┬────┬───┐│┌─┬────┬───┐│┌─┬────┬────┐│┌─┬────┬────┐│\n",
       "││B│3 4│2 2│││B│3 4│2 3│││B│3 4│2 5│││B│3 4│2 7│││B│3 4│2 9│││B│3 4│2 11│││B│3 4│2 12│││C│3 6│2 2│││C│3 6│2 3│││C│3 6│2 5│││C│3 6│2 7│││C│3 6│2 9│││C│3 6│2 11│││C│3 6│2 12│││B│3 8│2 2│││B│3 8│2 3│││B│3 8│2 5│││B│3 8│2 7│││B│3 8│2 9│││B│3 8│2 11│││B│3 8│2 12│││D│3 10│2 2│││D│3 10│2 3│││D│3 10│2 5│││D│3 10│2 7│││D│3 10│2 9│││D│3 10│2 11│││D│3 10│2 12││\n",
       "│└─┴───┴───┘│└─┴───┴───┘│└─┴───┴───┘│└─┴───┴───┘│└─┴───┴───┘│└─┴───┴────┘│└─┴───┴────┘│└─┴───┴───┘│└─┴───┴───┘│└─┴───┴───┘│└─┴───┴───┘│└─┴───┴───┘│└─┴───┴────┘│└─┴───┴────┘│└─┴───┴───┘│└─┴───┴───┘│└─┴───┴───┘│└─┴───┴───┘│└─┴───┴───┘│└─┴───┴────┘│└─┴───┴────┘│└─┴────┴───┘│└─┴────┴───┘│└─┴────┴───┘│└─┴────┴───┘│└─┴────┴───┘│└─┴────┴────┘│└─┴────┴────┘│\n",
       "└───────────┴───────────┴───────────┴───────────┴───────────┴────────────┴────────────┴───────────┴───────────┴───────────┴───────────┴───────────┴────────────┴────────────┴───────────┴───────────┴───────────┴───────────┴───────────┴────────────┴────────────┴────────────┴────────────┴────────────┴────────────┴────────────┴─────────────┴─────────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "enumerate_pod_moves test23"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a8ed4a6",
   "metadata": {},
   "source": [
    "Let's check going into rooms."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "74a5a5ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───────────┬───────────┬───────────┬───────────┬────────────┬────────────┬────────────┬────────────┬─────────────┬─────────────┬───────────┬───────────┬────────────┬────────────┐\n",
       "│┌─┬───┬───┐│┌─┬───┬───┐│┌─┬───┬───┐│┌─┬───┬───┐│┌─┬───┬────┐│┌─┬───┬────┐│┌─┬────┬───┐│┌─┬────┬───┐│┌─┬────┬────┐│┌─┬────┬────┐│┌─┬───┬───┐│┌─┬───┬───┐│┌─┬───┬────┐│┌─┬───┬────┐│\n",
       "││B│3 4│2 2│││B│3 4│2 3│││C│3 6│2 7│││C│3 6│2 9│││C│3 6│2 11│││C│3 6│2 12│││D│3 10│2 7│││D│3 10│2 9│││D│3 10│2 11│││D│3 10│2 12│││C│4 8│2 7│││C│4 8│2 9│││C│4 8│2 11│││C│4 8│2 12││\n",
       "│└─┴───┴───┘│└─┴───┴───┘│└─┴───┴───┘│└─┴───┴───┘│└─┴───┴────┘│└─┴───┴────┘│└─┴────┴───┘│└─┴────┴───┘│└─┴────┴────┘│└─┴────┴────┘│└─┴───┴───┘│└─┴───┴───┘│└─┴───┴────┘│└─┴───┴────┘│\n",
       "└───────────┴───────────┴───────────┴───────────┴────────────┴────────────┴────────────┴────────────┴─────────────┴─────────────┴───────────┴───────────┴────────────┴────────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "enumerate_pod_moves ↑('#############')('#...B.......#')('###B#C#.#D###')('  #A#D#C#A#  ')('  #########  ')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe8aa42a",
   "metadata": {},
   "source": [
    "Note that we treat C (3 6) exiting its starting room into the\n",
    "hallway (2 7) and going to its destination room (3 8) as two\n",
    "separate moves. Hopefully that won't burn too much search time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d7690f07",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───────────┬───────────┬───────────┬────────────┬─────────────┬─────────────┬───────────┬────────────┬────────────┐\n",
       "│┌─┬───┬───┐│┌─┬───┬───┐│┌─┬───┬───┐│┌─┬────┬───┐│┌─┬────┬────┐│┌─┬────┬────┐│┌─┬───┬───┐│┌─┬───┬────┐│┌─┬───┬────┐│\n",
       "││C│2 7│3 8│││B│3 4│2 2│││B│3 4│2 3│││D│3 10│2 9│││D│3 10│2 11│││D│3 10│2 12│││C│4 8│2 9│││C│4 8│2 11│││C│4 8│2 12││\n",
       "│└─┴───┴───┘│└─┴───┴───┘│└─┴───┴───┘│└─┴────┴───┘│└─┴────┴────┘│└─┴────┴────┘│└─┴───┴───┘│└─┴───┴────┘│└─┴───┴────┘│\n",
       "└───────────┴───────────┴───────────┴────────────┴─────────────┴─────────────┴───────────┴────────────┴────────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "enumerate_pod_moves ↑('#############')('#...B.C.....#')('###B#.#.#D###')('  #A#D#C#A#')('  #########')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d1febf1",
   "metadata": {},
   "source": [
    "Of course, we have to be able to update the nethack grid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f7d3b26e",
   "metadata": {},
   "outputs": [],
   "source": [
    "do_move←{move grid←⍵ ⋄ p from to←move ⋄ ('.'p@from to)⊢grid}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c4c4e591",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">#############\n",
       "#B..........#\n",
       "###.#C#B#D###\n",
       "  #A#D#C#A#  \n",
       "  #########  \n",
       "</span>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "do_move (⊃enumerate_pod_moves test23) test23"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8539c31",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "Find the best cost to sort the pods into the correct rooms.\n",
    "\n",
    "A best-first search was way too slow. Remembering [day 12](#day-12),\n",
    "first I tried never dropping things from the search queue. Then I\n",
    "tried A* with a simple heuristic: each letter must move to the\n",
    "correct x position, so it'll cost at least its movement cost\n",
    "times its x distance from its room. This was still way too slow,\n",
    "so I wrote it up in Python. That took 30 minutes to code and\n",
    "debug and 1 minute to run on test23 with a heapq, but was still\n",
    "too slow on the part 1 input.\n",
    "\n",
    "D moves are so expensive that you have to search the entire space before\n",
    "you make the needful D moves, so we need a better heuristic. Adding\n",
    "+1 or +2 to move out of the starting room, plus +1 to move into\n",
    "the correct room sped the Python search up to 11s for test23 and 48s\n",
    "for data23. Some more optimizations got that down to ~1s and ~4s.\n",
    "\n",
    "I wasn't having fun with this part anymore, so didn't bother to refine\n",
    "the APL search program. Dyalog doesn't seem to have a heap library.\n",
    "The program might still have some bugs, too. Maybe I will come back\n",
    "later and improve it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1af9ad98",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "best_pod_cost←{\n",
    "  grid←⍵\n",
    "  ⍝ cost per move\n",
    "  cost←{\n",
    "      p from to←⍵ ⋄ steps←+/|from-to\n",
    "      p='A': steps\n",
    "      p='B': 10×steps\n",
    "      p='C': 100×steps\n",
    "      p='D': 1000×steps\n",
    "  }\n",
    "  ⍝ when are we done\n",
    "  done←{grid[(3 4)(4 4)(3 6)(4 6)(3 8)(4 8)(3 10)(4 10)]≡'AABBCCDD'}\n",
    "  ⍝ lower bound on cost remaining\n",
    "  estimate_remaining_cost←{\n",
    "    grid←⍵\n",
    "    a_cost←+/{1×|2⊃⍵-4}¨(grid(⍸∊)'A')\n",
    "    b_cost←+/{10×|2⊃⍵-6}¨(grid(⍸∊)'B')\n",
    "    c_cost←+/{100×|2⊃⍵-8}¨(grid(⍸∊)'C')\n",
    "    d_cost←+/{1000×|2⊃⍵-10}¨(grid(⍸∊)'D')\n",
    "    a_cost+b_cost+c_cost+d_cost\n",
    "  }\n",
    "  ⍝ avoid some silly moves\n",
    "  prune←{\n",
    "      move grid←⍵ ⋄ p from to←move\n",
    "      (p='A')∧(from≡(4 4)): 1\n",
    "      (p='A')∧(from≡(3 4))∧(grid[⊂4 4]='A'): 1\n",
    "      (p='B')∧(from≡(4 6)): 1\n",
    "      (p='B')∧(from≡(3 6))∧(grid[⊂4 6]='A'): 1\n",
    "      (p='C')∧(from≡(4 8)): 1\n",
    "      (p='C')∧(from≡(3 8))∧(grid[⊂4 8]='A'): 1\n",
    "      (p='D')∧(from≡(4 10)): 1\n",
    "      (p='D')∧(from≡(3 10))∧(grid[⊂4 10]='A'): 1\n",
    "      0\n",
    "  }\n",
    "  ⍝ best-first search with heuristic\n",
    "  q←(,⊂(0 0 grid))\n",
    "  search←{\n",
    "    0=≢q:0\n",
    "    i←(⊃⍋)q  ⍝ min sort score\n",
    "    cur_sort cur_cost cur_grid←⊃q[i]\n",
    "    done cur_grid:cur_cost ⍝ answer\n",
    "    moves←enumerate_pod_moves cur_grid\n",
    "    moves←({~(prune ⍵ cur_grid)}¨moves)/moves\n",
    "    q[i]←⊂(100000000 cur_cost cur_grid)\n",
    "    0=≢moves:∇ 0\n",
    "    q,←{\n",
    "      new_grid←do_move ⍵ cur_grid\n",
    "      new_cost←cur_cost+(cost ⍵)\n",
    "      new_sort←new_cost+(estimate_remaining_cost new_grid)\n",
    "      (new_sort new_cost new_grid)\n",
    "    }¨moves\n",
    "    ∇ 0\n",
    "  }\n",
    "  search 0\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1812f154",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Now the rooms are bigger. I generalized and then added some\n",
    "simple optimizations to my Python program, e.g. not revisiting\n",
    "visited states. I also improved the heuristic to include a\n",
    "cost for correctly placed letters having to move out of the\n",
    "way to let incorrectly placed letters behind them move out.\n",
    "\n",
    "The search took about 5 hours for part 2. I set it running,\n",
    "then went out and did stuff for Christmas. Probably there was\n",
    "some cleverer way to do this problem by thinking more abstractly\n",
    "about sequences of swaps or something, but since A* finished, I\n",
    "felt done.  _Worst.  Roguelike.  Ever._\n",
    "\n",
    "Here is the Python program, for completeness' sake.\n",
    "\n",
    "```python\n",
    "#!/usr/bin/env python3\n",
    "\n",
    "from datetime import datetime\n",
    "import heapq\n",
    "\n",
    "test = [[c for c in line.strip('\\n')]\n",
    "        for line in open('day23-test.txt').readlines()]\n",
    "data = [[c for c in line.strip('\\n')]\n",
    "        for line in open('day23-input.txt').readlines()]\n",
    "test2 = [[c for c in line.strip('\\n')]\n",
    "         for line in open('day23-test2.txt').readlines()]\n",
    "data2 = [[c for c in line.strip('\\n')]\n",
    "         for line in open('day23-input2.txt').readlines()]\n",
    "\n",
    "room_column = {'A': 3, 'B': 5, 'C': 7, 'D': 9}\n",
    "def dest_in_room(grid, p):\n",
    "  i = room_column[p]\n",
    "  for j in range(len(grid)-2, 1, -1):\n",
    "    if grid[j][i] == '.':\n",
    "      return (j,i)\n",
    "    if grid[j][i] != p:\n",
    "      return\n",
    "\n",
    "def moves(grid):\n",
    "  for j in range(len(grid)):\n",
    "    for i in range(len(grid[j])):\n",
    "      p = grid[j][i]\n",
    "      if p not in 'ABCD': continue\n",
    "      if j == 1:  # move from hallway into room\n",
    "        dest = dest_in_room(grid, p)\n",
    "        if dest and is_hallway_clear(grid, i, dest[1]):\n",
    "          yield p, j, i, dest[0], dest[1]\n",
    "      else:  # move from room into hallway if not blocked\n",
    "        if grid[j-1][i] != '.': continue\n",
    "        for dest in ((1,1),(1,2),(1,4),(1,6),(1,8),(1,10),(1,11)):\n",
    "          if is_hallway_clear(grid, i, dest[1]):\n",
    "            yield p, j, i, dest[0], dest[1]\n",
    "\n",
    "def is_hallway_clear(grid, x0, x1):\n",
    "  assert x0 != x1\n",
    "  dx = 1 if x1 > x0 else -1\n",
    "  x = x0\n",
    "  while True:\n",
    "    x += dx\n",
    "    if grid[1][x] != '.': return False\n",
    "    if x == x1: return True\n",
    "\n",
    "def make_move(move, grid):\n",
    "  p, from_y, from_x, to_y, to_x = move\n",
    "  new_grid = [row[:] for row in grid]\n",
    "  new_grid[from_y][from_x] = '.'\n",
    "  new_grid[to_y][to_x] = p\n",
    "  return new_grid\n",
    "\n",
    "def print_grid(grid):\n",
    "  for j in range(len(grid)):\n",
    "    s = ''\n",
    "    for i in range(len(grid[j])):\n",
    "      s += grid[j][i]\n",
    "    print(s)\n",
    "\n",
    "def done(grid):\n",
    "  for j in range(len(grid)-2, 1, -1):\n",
    "    if grid[j][3] != 'A': return False\n",
    "    if grid[j][5] != 'B': return False\n",
    "    if grid[j][7] != 'C': return False\n",
    "    if grid[j][9] != 'D': return False\n",
    "  return True\n",
    "\n",
    "cost_per_step = {'A': 1, 'B': 10, 'C': 100, 'D': 1000}\n",
    "\n",
    "def cost(move):\n",
    "  p, from_y, from_x, to_y, to_x = move\n",
    "  steps = abs(from_x-to_x) + abs(from_y-to_y)\n",
    "  return cost_per_step[p] * steps\n",
    "\n",
    "def prune(grid, move):\n",
    "  p, from_y, from_x, to_y, to_x = move\n",
    "  i = room_column[p]\n",
    "  return from_x == i and all(grid[j][i] == p for j in range(from_y+1, len(grid)-1))\n",
    "\n",
    "def hashable(grid):\n",
    "  return ''.join(''.join(row) for row in grid)\n",
    "\n",
    "def search(grid):\n",
    "  q = [(0, 0, grid)]\n",
    "  visited = set()\n",
    "  while q:\n",
    "    cur_sort, cur_cost, cur_grid = heapq.heappop(q)\n",
    "    visited.add(hashable(cur_grid))\n",
    "    if done(cur_grid):\n",
    "      return cur_cost\n",
    "    for move in moves(cur_grid):\n",
    "      if not prune(cur_grid, move):\n",
    "        new_grid = make_move(move, cur_grid)\n",
    "        if hashable(new_grid) in visited: continue\n",
    "        new_cost = cur_cost + cost(move)\n",
    "        new_sort = new_cost + estimate_remaining_cost(new_grid)\n",
    "        heapq.heappush(q, (new_sort, new_cost, new_grid))\n",
    "  return -1\n",
    "\n",
    "def blocking(grid, p, j0, i):\n",
    "  return any(grid[j][i] != p for j in range(j0+1, len(grid)-1))\n",
    "\n",
    "def estimate_remaining_cost(grid):\n",
    "  cost = 0\n",
    "  for j in range(len(grid)):\n",
    "    for i in range(len(grid[j])):\n",
    "      p = grid[j][i]\n",
    "      cost += (j+abs(i-3)        if p == 'A' and i != 3 else\n",
    "               j                 if p == 'A' and i == 3 and blocking(grid, p, j, i) else\n",
    "               10*(j+abs(i-5))   if p == 'B' and i != 5 else\n",
    "               10*j              if p == 'B' and i == 5 and blocking(grid, p, j, i) else\n",
    "               100*(j+abs(i-7))  if p == 'C' and i != 7 else\n",
    "               100*j             if p == 'C' and i == 7 and blocking(grid, p, j, i) else\n",
    "               1000*(j+abs(i-9)) if p == 'D' and i != 9 else\n",
    "               1000*j            if p == 'D' and i == 9 and blocking(grid, p, j, i) else\n",
    "               0)\n",
    "  return cost\n",
    "\n",
    "def time(fn):\n",
    "  start = datetime.now()\n",
    "  result = fn()\n",
    "  end = datetime.now()\n",
    "  print(f'{result}  (took {end-start})')\n",
    "\n",
    "time(lambda: search(data2))\n",
    "time(lambda: search(test2))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96ace96e",
   "metadata": {},
   "source": [
    "## Day 24\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/24)\n",
    "\n",
    "Interesting, an ALU today. I like emulation!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4d1597c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "data24←' '(≠⊆⊢)¨⊃⎕NGET'day24-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ed794ee",
   "metadata": {},
   "source": [
    "This one is pretty simple, so I guess we'll just mostly be\n",
    "untangling what the program does. Perhaps we'll want to\n",
    "decompile it into an expression tree or something - not even\n",
    "sure we strictly need to run the program, but why not:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "1ffa5dd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "run_program←{\n",
    "  program inputs←⍵\n",
    "  registers←0 0 0 0 ⍝ w x y z\n",
    "  decode_register_index←{⍵='w':1 ⋄ ⍵='x':2 ⋄ ⍵='y':3 ⋄ ⍵='z':4}\n",
    "  decode_register_or_immediate←{\n",
    "    ∧/⍵∊'wxyz':registers[decode_register_index ⍵] ⋄ ⍎⍵\n",
    "  }\n",
    "  run_instruction←{\n",
    "    ⍝⎕←⍵ registers inputs\n",
    "    ⍝ inp has one argument\n",
    "    (2=≢⍵)∧(⍵[1]≡⊂'inp'):{\n",
    "      registers[decode_register_index ⍵]←1↑inputs\n",
    "      inputs⊢←1↓inputs\n",
    "      0\n",
    "    }⊃(⍵[2])\n",
    "    ⍝ all other instructions have two arguments\n",
    "    opcode arg1 arg2←⍵\n",
    "    a_index←decode_register_index arg1\n",
    "    a←registers[a_index]\n",
    "    b←decode_register_or_immediate arg2\n",
    "    opcode≡'add':{registers[a_index]←a+b ⋄ 0}0\n",
    "    opcode≡'mul':{registers[a_index]←a×b ⋄ 0}0\n",
    "    ⍝ divide and truncate\n",
    "    opcode≡'div':{registers[a_index]←a((××∘⌊|)÷)b ⋄ 0}0\n",
    "    opcode≡'mod':{registers[a_index]←b|a ⋄ 0}0\n",
    "    opcode≡'eql':{registers[a_index]←a=b ⋄ 0}0\n",
    "  }\n",
    "  _←run_instruction¨program\n",
    "  registers\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b777bb06",
   "metadata": {},
   "outputs": [],
   "source": [
    "⎕PP←16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "dc172ef0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">9 1 22 2695331544\n",
       "</span>"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "run_program data24 (1 3 5 7 9 2 4 6 8 9 9 9 9 9)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b00c6a8b",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "We have to find the largest input string such that the program\n",
    "computes z=0.\n",
    "\n",
    "Running on a couple random inputs doesn't give much insight...\n",
    "z is just some 10-digit number. It seems to vary with the size\n",
    "of the input number, and mostly increases as we read more input\n",
    "digits. There are lots of repeated sequences of instructions,\n",
    "so let's look at the program, per digit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "7c473204",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌────────┬────────┬────────┬────────┬────────┬────────┬────────┬────────┬─────────┬────────┬────────┬────────┬────────┬─────────┐\n",
       "│inp w   │inp w   │inp w   │inp w   │inp w   │inp w   │inp w   │inp w   │inp w    │inp w   │inp w   │inp w   │inp w   │inp w    │\n",
       "├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┼────────┼────────┼────────┼─────────┤\n",
       "│mul x 0 │mul x 0 │mul x 0 │mul x 0 │mul x 0 │mul x 0 │mul x 0 │mul x 0 │mul x 0  │mul x 0 │mul x 0 │mul x 0 │mul x 0 │mul x 0  │\n",
       "├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┼────────┼────────┼────────┼─────────┤\n",
       "│add x z │add x z │add x z │add x z │add x z │add x z │add x z │add x z │add x z  │add x z │add x z │add x z │add x z │add x z  │\n",
       "├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┼────────┼────────┼────────┼─────────┤\n",
       "│mod x 26│mod x 26│mod x 26│mod x 26│mod x 26│mod x 26│mod x 26│mod x 26│mod x 26 │mod x 26│mod x 26│mod x 26│mod x 26│mod x 26 │\n",
       "├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┼────────┼────────┼────────┼─────────┤\n",
       "│div z 1 │div z 1 │div z 1 │div z 26│div z 1 │div z 26│div z 1 │div z 26│div z 26 │div z 26│div z 1 │div z 1 │div z 26│div z 26 │\n",
       "├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┼────────┼────────┼────────┼─────────┤\n",
       "│add x 12│add x 11│add x 12│add x -3│add x 10│add x -9│add x 10│add x -7│add x -11│add x -4│add x 14│add x 11│add x -8│add x -10│\n",
       "├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┼────────┼────────┼────────┼─────────┤\n",
       "│eql x w │eql x w │eql x w │eql x w │eql x w │eql x w │eql x w │eql x w │eql x w  │eql x w │eql x w │eql x w │eql x w │eql x w  │\n",
       "├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┼────────┼────────┼────────┼─────────┤\n",
       "│eql x 0 │eql x 0 │eql x 0 │eql x 0 │eql x 0 │eql x 0 │eql x 0 │eql x 0 │eql x 0  │eql x 0 │eql x 0 │eql x 0 │eql x 0 │eql x 0  │\n",
       "├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┼────────┼────────┼────────┼─────────┤\n",
       "│mul y 0 │mul y 0 │mul y 0 │mul y 0 │mul y 0 │mul y 0 │mul y 0 │mul y 0 │mul y 0  │mul y 0 │mul y 0 │mul y 0 │mul y 0 │mul y 0  │\n",
       "├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┼────────┼────────┼────────┼─────────┤\n",
       "│add y 25│add y 25│add y 25│add y 25│add y 25│add y 25│add y 25│add y 25│add y 25 │add y 25│add y 25│add y 25│add y 25│add y 25 │\n",
       "├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┼────────┼────────┼────────┼─────────┤\n",
       "│mul y x │mul y x │mul y x │mul y x │mul y x │mul y x │mul y x │mul y x │mul y x  │mul y x │mul y x │mul y x │mul y x │mul y x  │\n",
       "├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┼────────┼────────┼────────┼─────────┤\n",
       "│add y 1 │add y 1 │add y 1 │add y 1 │add y 1 │add y 1 │add y 1 │add y 1 │add y 1  │add y 1 │add y 1 │add y 1 │add y 1 │add y 1  │\n",
       "├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┼────────┼────────┼────────┼─────────┤\n",
       "│mul z y │mul z y │mul z y │mul z y │mul z y │mul z y │mul z y │mul z y │mul z y  │mul z y │mul z y │mul z y │mul z y │mul z y  │\n",
       "├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┼────────┼────────┼────────┼─────────┤\n",
       "│mul y 0 │mul y 0 │mul y 0 │mul y 0 │mul y 0 │mul y 0 │mul y 0 │mul y 0 │mul y 0  │mul y 0 │mul y 0 │mul y 0 │mul y 0 │mul y 0  │\n",
       "├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┼────────┼────────┼────────┼─────────┤\n",
       "│add y w │add y w │add y w │add y w │add y w │add y w │add y w │add y w │add y w  │add y w │add y w │add y w │add y w │add y w  │\n",
       "├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┼────────┼────────┼────────┼─────────┤\n",
       "│add y 7 │add y 15│add y 2 │add y 15│add y 14│add y 2 │add y 15│add y 1 │add y 15 │add y 15│add y 12│add y 2 │add y 13│add y 13 │\n",
       "├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┼────────┼────────┼────────┼─────────┤\n",
       "│mul y x │mul y x │mul y x │mul y x │mul y x │mul y x │mul y x │mul y x │mul y x  │mul y x │mul y x │mul y x │mul y x │mul y x  │\n",
       "├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┼────────┼────────┼────────┼─────────┤\n",
       "│add z y │add z y │add z y │add z y │add z y │add z y │add z y │add z y │add z y  │add z y │add z y │add z y │add z y │add z y  │\n",
       "└────────┴────────┴────────┴────────┴────────┴────────┴────────┴────────┴─────────┴────────┴────────┴────────┴────────┴─────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{⊃,/' '(1↓∘,,⍤0)⍵}¨⍉↑({('inp' (,'w'))≡⍵}¨data24)⊂data24"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ed1bf98",
   "metadata": {},
   "source": [
    "This computes\n",
    "\n",
    "```python\n",
    "for i in range(len(s)):\n",
    "  x = (z%26) + A[i]\n",
    "  z //= B[i]\n",
    "  if x != s[i]:\n",
    "    z = z*26 + (s[i] + C[i])\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "5dd09d33",
   "metadata": {},
   "outputs": [],
   "source": [
    "collect_arg2←{{⍎⊃⍵}¨3⌷¨⍵⌷(⍉↑({('inp' (,'w'))≡⍵}¨data24)⊂data24)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "a92cdf1f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">12 11 12 ¯3 10 ¯9 10 ¯7 ¯11 ¯4 14 11 ¯8 ¯10\n",
       "</span>"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←A←collect_arg2 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "c67c387c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 1 1 26 1 26 1 26 26 26 1 1 26 26\n",
       "</span>"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←B←collect_arg2 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "1e35905f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">7 15 2 15 14 2 15 1 15 15 12 2 13 13\n",
       "</span>"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←C←collect_arg2 16"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "089ac884",
   "metadata": {},
   "source": [
    "Note that when A≥10 we must have `x != s[i]`, so z must\n",
    "increase on those steps. Also the steps where A<10 correspond\n",
    "with the steps where B=26, and each of these steps must avoid\n",
    "increasing z to have any hope of reaching 0.\n",
    "\n",
    "Let's just start unrolling this manually, using python indexing\n",
    "since that's the pseudocode.\n",
    "\n",
    "```python\n",
    "# iteration 1: A[0]=12 so z must increase\n",
    "z = s[0]+7\n",
    "# iteration 2: A[1]=11 so z must increase\n",
    "z = 26*(s[0]+7) + (s[1]+15)\n",
    "# iteration 3: A[2]=12 so z must increase\n",
    "z = 26*(26*(s[0]+7) + (s[1]+15)) + (s[2]+2)\n",
    "# iteration 4: A[3]=-3, must have x == s[3]\n",
    "z = 26*(s[0]+7) + (s[1]+15) # z //= 26\n",
    "if s[3] != s[2]-1: pass # ...\n",
    "# iteration 5: A[4]=10 so z must increase\n",
    "z = 26*(26*(s[0]+7) + (s[1]+15)) + (s[4]+14)\n",
    "# iteration 6: A[5]=-9, must have x == s[5]\n",
    "z = 26*(s[0]+7) + (s[1]+15) # z //= 26\n",
    "if s[5] != s[4]+5: pass # ...\n",
    "...\n",
    "```\n",
    "\n",
    "Ok, let's use a computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "c6b68b5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "r←constrain_inputs constants;as;bs;cs;z;n;v;k\n",
    "as bs cs←constants\n",
    "z←⍬\n",
    "r←⍬\n",
    ":For n :In ⍳14\n",
    "  :If as[n]>0\n",
    "    z,←⊂(n(cs[n]))\n",
    "  :Else\n",
    "    v k←⊃(¯1↑z)\n",
    "    r,←⊂(n v(k+as[n]))\n",
    "    z⊢←¯1↓z\n",
    "  :EndIf\n",
    ":EndFor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "708391b5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\"> 4  3 ¯1\n",
       " 6  5  5\n",
       " 8  7  8\n",
       " 9  2  4\n",
       "10  1  3\n",
       "13 12 ¯6\n",
       "14 11  2\n",
       "</span>"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↑constrain_inputs A B C"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "070ae163",
   "metadata": {},
   "source": [
    "So we must have digit 4 = (digit 3) - 1, digit 6 = (digit 5) + 5, etc.\n",
    "This ought to be easy to satisfy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "4818cce6",
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "r←find_inputs;d1;d2;d3;d4;d5;d6;d7;d8;d9;d10;d11;d12;d13;d14\n",
    "r←⍬\n",
    ":For d3 :In ⍳9\n",
    "  d4←d3-1\n",
    "  :If (d4<1)∨(d4>9)\n",
    "    :Continue\n",
    "  :EndIf\n",
    "  :For d5 :In ⍳9\n",
    "    d6←d5+5\n",
    "    :If (d6<1)∨(d6>9)\n",
    "      :Continue\n",
    "    :EndIf\n",
    "    :For d7 :In ⍳9\n",
    "      d8←d7+8\n",
    "      :If (d8<1)∨(d8>9)\n",
    "        :Continue\n",
    "      :EndIf\n",
    "      :For d2 :In ⍳9\n",
    "        d9←d2+4\n",
    "        :If (d9<1)∨(d9>9)\n",
    "          :Continue\n",
    "        :EndIf\n",
    "        :For d1 :In ⍳9\n",
    "          d10←d1+3\n",
    "          :If (d10<1)∨(d10>9)\n",
    "            :Continue\n",
    "          :EndIf\n",
    "          :For d12 :In ⍳9\n",
    "            d13←d12-6\n",
    "            :If (d13<1)∨(d13>9)\n",
    "              :Continue\n",
    "            :EndIf\n",
    "            :For d11 :In ⍳9\n",
    "              d14←d11+2\n",
    "              :If (d14<1)∨(d14>9)\n",
    "                :Continue\n",
    "              :EndIf\n",
    "              r,←10⊥d1 d2 d3 d4 d5 d6 d7 d8 d9 d10 d11 d12 d13 d14\n",
    "            :EndFor\n",
    "          :EndFor\n",
    "        :EndFor\n",
    "      :EndFor\n",
    "    :EndFor\n",
    "  :EndFor\n",
    ":EndFor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "316c4d70",
   "metadata": {},
   "outputs": [],
   "source": [
    "day24_1←⌈/find_inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "6f27c489",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">65984919997939\n",
       "</span>"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day24_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "a3aa487f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">9 0 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "run_program data24 (10 10 10 10 10 10 10 10 10 10 10 10 10 10⊤(day24_1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcca03b4",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "Now we want the min."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "f56cc445",
   "metadata": {},
   "outputs": [],
   "source": [
    "day24_2←⌊/find_inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "50d0a84d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">11211619541713\n",
       "</span>"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day24_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "6141b3e2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">3 0 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "run_program data24 (10 10 10 10 10 10 10 10 10 10 10 10 10 10⊤(day24_2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c57dba92",
   "metadata": {},
   "source": [
    "## Day 25\n",
    "\n",
    "[Puzzle link](https://adventofcode.com/2021/day/25)\n",
    "\n",
    "Sea cucumbers. Sounds like C cucumbers. Good old C, sigh."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "74ea2a86",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">v...&gt;&gt;.vv&gt;\n",
       ".vv&gt;&gt;.vv..\n",
       "&gt;&gt;.&gt;v&gt;...v\n",
       "&gt;&gt;v&gt;&gt;.&gt;.v.\n",
       "v&gt;v.vv.v..\n",
       "&gt;.&gt;&gt;..v...\n",
       ".vv..&gt;.&gt;v.\n",
       "v.v..&gt;&gt;v.v\n",
       "....v..v.&gt;\n",
       "</span>"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←test25←↑⊃⎕NGET 'day25-test.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "4c141cb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "data25←↑⊃⎕NGET 'day25-input.txt' 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32352765",
   "metadata": {},
   "source": [
    "We need to check if cells to the \"east\" and \"south\" on a toroidal grid\n",
    "are empty. A cell has '>' in the next generation if it west has '>' in\n",
    "the current generation and it is empty, or if it has '>' in the current\n",
    "generation and east is nonempty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "58c79e3f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">v...&gt;.&gt;vv&gt;\n",
       ".vv&gt;.&gt;vv..\n",
       "&gt;.&gt;&gt;v.&gt;..v\n",
       "&gt;&gt;v&gt;.&gt;.&gt;v.\n",
       "v&gt;v.vv.v..\n",
       ".&gt;&gt;.&gt;.v...\n",
       ".vv...&gt;&gt;v.\n",
       "v.v..&gt;&gt;v.v\n",
       "&gt;...v..v..\n",
       "</span>"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'.>v'[1+((2×('v'=⊢))+(((¯1⌽('>'=⊢))∧('.'=⊢))∨((('>'=⊢))∧(1⌽('.'≠⊢)))))test25]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "e79e6695",
   "metadata": {},
   "outputs": [],
   "source": [
    "swim_east←{'.>v'[1+((2×('v'=⊢))+(((¯1⌽('>'=⊢))∧('.'=⊢))∨((('>'=⊢))∧(1⌽('.'≠⊢)))))⍵]}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38b2934c",
   "metadata": {},
   "source": [
    "Then the cucumbers swim south."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "cca4f807",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">....&gt;.&gt;v.&gt;\n",
       "v.v&gt;.&gt;v.v.\n",
       "&gt;v&gt;&gt;..&gt;v..\n",
       "&gt;&gt;v&gt;v&gt;.&gt;.v\n",
       ".&gt;v.v...v.\n",
       "v&gt;&gt;.&gt;vvv..\n",
       "..v...&gt;&gt;..\n",
       "vv...&gt;&gt;vv.\n",
       "&gt;.v.v..v.v\n",
       "</span>"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'.v>'[1+((2×('>'=⊢))+(((¯1⊖('v'=⊢))∧('.'=⊢))∨((('v'=⊢))∧(1⊖('.'≠⊢)))))(swim_east test25)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "f79819b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "swim_south←{'.v>'[1+((2×('>'=⊢))+(((¯1⊖('v'=⊢))∧('.'=⊢))∨((('v'=⊢))∧(1⊖('.'≠⊢)))))⍵]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "0b4c213e",
   "metadata": {},
   "outputs": [],
   "source": [
    "swim←swim_south∘swim_east"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "1620f5c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">..&gt;&gt;v&gt;vv..\n",
       "..v.&gt;&gt;vv..\n",
       "..&gt;&gt;v&gt;&gt;vv.\n",
       "..&gt;&gt;&gt;&gt;&gt;vv.\n",
       "v......&gt;vv\n",
       "v&gt;v....&gt;&gt;v\n",
       "vvv.....&gt;&gt;\n",
       "&gt;vv......&gt;\n",
       ".&gt;v.vv.v..\n",
       "</span>"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(swim⍣58) test25"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "767f5baf",
   "metadata": {},
   "source": [
    "### Part 1\n",
    "\n",
    "How long til the cucumbers stop moving?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "6443e9a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "day25_1←{n←0 ⋄ _←({n+←1 ⋄ swim ⍵}⍣≡)⍵ ⋄ n}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "a05e5716",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">58\n",
       "</span>"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day25_1 test25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "57323291",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">560\n",
       "</span>"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day25_1 data25"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b3851f7",
   "metadata": {},
   "source": [
    "### Part 2\n",
    "\n",
    "That's it, there's no more today!\n",
    "\n",
    "## Conclusion\n",
    "\n",
    "APL was a weird, sometimes frustrating and occasionally beautiful\n",
    "language. It fit perfectly with this year's deep sea adventure theme -\n",
    "I felt like I was studying an alien branch of life with totally\n",
    "different evolutionary history and constraints to the languages I'm\n",
    "used to. And when I got stuck, I was truly on my own: maybe there\n",
    "are expert user communities or something somewhere to help beginners,\n",
    "but I didn't find them.\n",
    "\n",
    "Mostly, I used Dyalog APL as a functional or procedural language\n",
    "with some array-language spice. And when used that way, I'd rather\n",
    "just have a mainstream language with some array-spice, instead.\n",
    "With more experience, maybe I'd be able to see my way to more\n",
    "array-esque solutions. For instance, the other day I found this\n",
    "page in Dyalog's library documentation about\n",
    "[parallel graph bfs](https://dfns.dyalog.com/n_bfs.htm), which is\n",
    "a neat idea.\n",
    "\n",
    "I'm probably not going to spend $200 for that special keyboard.\n",
    "But I might go on to study some more modern array languages, and\n",
    "maybe I can apply some of what I learned in my normal day-to-day!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Dyalog APL",
   "language": "apl",
   "name": "dyalog-kernel"
  },
  "language_info": {
   "file_extension": ".apl",
   "mimetype": "text/apl",
   "name": "APL"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}