Advent of Code 2015 Dyalog APL.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Advent of Code 2015, Dyalog APL edition\n",
    "\n",
    "To see a correct render of this notebook, check it out on [nbviewer](https://nbviewer.jupyter.org/github/xpqz/AoCDyalog/blob/master/Advent%20of%20Code%202015%20Dyalog%20APL.ipynb).\n",
    "\n",
    "Annotated solutions in Dyalog APL.\n",
    "\n",
    "Note that part of the charm of AoC is that every user (or at least groups of users) gets their own unique data set. Some of the solutions below exploit quirks in my particular data set, and so may conceivably not work for the general case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 569,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">Was ON\n",
       "</span>"
      ]
     },
     "execution_count": 569,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕IO←1\n",
    "]box off"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 1: Not Quite Lisp\n",
    "https://adventofcode.com/2015/day/1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 570,
   "metadata": {},
   "outputs": [],
   "source": [
    "DAY1←⊃⊃⎕NGET'data/2015/01.txt'1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 571,
   "metadata": {},
   "outputs": [],
   "source": [
    "Day1p1←{+/+⌿-@2⌷'()'∘.=⍵}     ⍝ Binary mask with positions for '(' in row 1 and ')' in row 2, \n",
    "                              ⍝ and then row 2 negated. Sum down, then across."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 572,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">138\n",
       "</span>"
      ]
     },
     "execution_count": 572,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Day1p1 DAY1 ⍝ 138"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 573,
   "metadata": {},
   "outputs": [],
   "source": [
    "Day1p2←{1⊃⍸{⍵<0}¨+\\+⌿-@2⌷'()'∘.=⍵} ⍝ As before, but scan-sum across and create mask of negatives and pick first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 574,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1771\n",
       "</span>"
      ]
     },
     "execution_count": 574,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Day1p2 DAY1 ⍝ 1771"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 2: I Was Told There Would Be No Math\n",
    "https://adventofcode.com/2015/day/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 575,
   "metadata": {},
   "outputs": [],
   "source": [
    "DAY2←2⊃¨'x'⎕VFI¨⊃⎕NGET 'data/2015/02.txt' 1  ⍝ Many lines. Pick out three ints from each, separated by 'x'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 576,
   "metadata": {},
   "outputs": [],
   "source": [
    "Day2p1←{(l w h)←⍵ ⋄ s[⊃⍋s]++/2×s←(l×w) (w×h) (h×l)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 577,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1606483\n",
       "</span>"
      ]
     },
     "execution_count": 577,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+/Day2p1¨DAY2 ⍝ 1606483"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 578,
   "metadata": {},
   "outputs": [],
   "source": [
    "Day2p2←{(ll ww hh)←2×⍵⋄c[⊃⍋c←(hh+ww) (ww+ll) (ll+hh)]+×/⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 579,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">3842356\n",
       "</span>"
      ]
     },
     "execution_count": 579,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+/Day2p2¨DAY2 ⍝ 3842356"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 3: Perfectly Spherical Houses in a Vacuum\n",
    "\n",
    "https://adventofcode.com/2015/day/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 823,
   "metadata": {},
   "outputs": [],
   "source": [
    "DAY3←⊃⊃⎕NGET'data/2015/03.txt'1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 824,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "Day3p1←{\n",
    "    points←-@1 3⌷'^v<>'∘.=⍵                   ⍝ Matrix with 4 rows -y, y, -x, x\n",
    "    ⍉(+\\+⌿points[3 4;]),[0.5]+\\+⌿points[1 2;] ⍝ Sum first along axis 1, then sum-scan along axis 2\n",
    "}                                             ⍝ separately for x and y. Laminate x and y parts, transpose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 825,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">2081\n",
       "</span>"
      ]
     },
     "execution_count": 825,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+≢∪ Day3p1 DAY3 ⍝ 2081"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 826,
   "metadata": {},
   "outputs": [],
   "source": [
    "Day3p2←{(1⊃p)⍪2⊃p←Day3p1¨{⍵⊢∘⊂⌸⍨2|⍳≢⍵}⍵}      ⍝ Unzip ⍵ so we can treat santa and robo's paths separately"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 827,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">2341\n",
       "</span>"
      ]
     },
     "execution_count": 827,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "≢∪ Day3p2 DAY3 ⍝ 2341"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 4: The Ideal Stocking Stuffer\n",
    "https://adventofcode.com/2015/day/4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 585,
   "metadata": {},
   "outputs": [],
   "source": [
    "Md5←{⎕SH 'md5 -q -s \"',⍵,'\"'}  ⍝ No Dyalog built-in MD5 function, sadly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 586,
   "metadata": {},
   "outputs": [],
   "source": [
    "Day4p1←{⍺←0⋄'00000'≡5↑Md5 ⍵,⍕⍺:⍺⋄(⍺+1)∇⍵}  ⍝ NOTE: WORKS, BUT INTRACTABLE WITHOUT NATIVE MD5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 5: Doesn't He Have Intern-Elves For This?\n",
    "https://adventofcode.com/2015/day/5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 587,
   "metadata": {},
   "outputs": [],
   "source": [
    "DAY5←⊃⎕NGET'data/2015/05.txt'1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 588,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "Day5p1←{\n",
    "    3>+/+⌿'aeiou'∘.=⍵:0                  ⍝ Three or more vowels\n",
    "    0≠+/'ab' 'cd' 'pq' 'xy'∊↓{⍵}⌺2⊢⍵:0   ⍝ Illegal pairs\n",
    "    1≤+/=⌿⍵,[0.5](≢⍵)↑1↓⍵                ⍝ Repeated letters\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 589,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">238\n",
       "</span>"
      ]
     },
     "execution_count": 589,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+/Day5p1¨DAY5 ⍝ 238"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 590,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "Day5p2←{\n",
    "    0=≢'(..).*\\1'⎕S'\\1'⊢⍵:0              ⍝ Regexery feels like a defeat\n",
    "    0≠+/(⊣/=⊢/){⍵}⌺3⊢⍵                   ⍝ Overlapping triplets, compare first and last columns\n",
    " }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 591,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">69\n",
       "</span>"
      ]
     },
     "execution_count": 591,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+/Day5p2¨DAY5 ⍝ 69"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 6: Probably a Fire Hazard\n",
    "https://adventofcode.com/2015/day/6\n",
    "\n",
    "This time we'll go old-skool with a tradfn."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 592,
   "metadata": {},
   "outputs": [],
   "source": [
    "⎕IO←0             ⍝ The problem's coordinates are 0-based.\n",
    "'iotag'⎕CY'dfns'  ⍝ iotag -- generalised iota -- alows us to create ranges from a to b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 593,
   "metadata": {},
   "outputs": [],
   "source": [
    "DAY6←⊃⎕NGET 'data/2015/06.txt' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 594,
   "metadata": {},
   "outputs": [],
   "source": [
    "RegexGroups←{⍺⎕S{⍵.(1↓Lengths↑¨Offsets↓¨⊂Block)} ⊢ ⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 595,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "res←Day6p1 data;state;parsed;row;spec;points\n",
    "state←1000 1000⍴0\n",
    "parsed←'(on|off|toggle)\\s(\\d+),(\\d+)[^\\d]+(\\d+),(\\d+)' RegexGroups data\n",
    ":For row :In parsed\n",
    "    spec←⍎¨1↓row\n",
    "    points←(spec[0] iotag spec[2]) ∘., (spec[1] iotag spec[3])\n",
    "    :If (0⊃row)≡'on'\n",
    "        state[points]←1\n",
    "    :ElseIf (0⊃row)≡'off'\n",
    "        state[points]←0\n",
    "    :Else\n",
    "        state[points]←~state[points]\n",
    "    :EndIf\n",
    ":EndFor\n",
    "res←+/+⌿state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 596,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">569999\n",
       "</span>"
      ]
     },
     "execution_count": 596,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Day6p1 DAY6 ⍝ 569999"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Part 2 is more of the same, just with different updates: turn on means add 1, turn off means subtract 1, capped at 0, and toggle means add 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 597,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "res←Day6p2 data;state;parsed;row;op;spec;points\n",
    "state←1000 1000⍴0\n",
    "parsed←'(on|off|toggle)\\s(\\d+),(\\d+)[^\\d]+(\\d+),(\\d+)' RegexGroups data\n",
    ":For row :In parsed\n",
    "    spec←⍎¨1↓row\n",
    "    points←(spec[0] iotag spec[2]) ∘., (spec[1] iotag spec[3])\n",
    "    :If (0⊃row)≡'on'\n",
    "        state[points]+←1\n",
    "    :Elseif (0⊃row)≡'off'\n",
    "        state[points]-←1\n",
    "        state[points]⌈←0\n",
    "    :Else\n",
    "        state[points]+←2\n",
    "    :EndIf\n",
    ":EndFor\n",
    "res←+/+⌿state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 598,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">17836115\n",
       "</span>"
      ]
     },
     "execution_count": 598,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Day6p2 DAY6 ⍝ 17836115"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 7: Some Assembly Required\n",
    "https://adventofcode.com/2015/day/7\n",
    "\n",
    "A very interesting question. We have a set of \"gates\", specified like so:\n",
    "\n",
    "```\n",
    "af AND ah -> ai\n",
    "NOT lk -> ll\n",
    "hz RSHIFT 1 -> is\n",
    "NOT go -> gp\n",
    "du OR dt -> dv\n",
    "```\n",
    "\n",
    "So, for example, the gate \"ai\" has the value of the bitwise AND of the values of gates \"af\" and \"ah\". In other words, the gates are _functions_ with inputs and outputs, and the input data is already a full program. We can exploit this in our solution. Take\n",
    "\n",
    "    af AND ah -> ai\n",
    "  \n",
    "and turn this into an APL function\n",
    "\n",
    "    ai←{(af ⍬) AND (ah ⍬)}\n",
    "    \n",
    "assuming that we have the AND function defined. If we convert the input specifications to such APL functions, all we need to do is to run the \"a\" function to get our result. Elegant, but with a small problem: it doesn't work. \n",
    "\n",
    "The reason for this is that the functions can be expensive to compute, as may require many, many calls. However, as they never _change_, we can cache the values after the first invocation, and with this in place the solution is found very quickly. Instead of the above expression, we make\n",
    "\n",
    "    ai←({⍵⊣⍵.c←¯1}⎕NS'') Cache {(af ⍬) AND (ah ⍬)}\n",
    "\n",
    "with the Cache operator defined as \n",
    "\n",
    "    Cache←{¯1=⍺⍺.c:⍺⍺.c⊣⍺⍺.c←⍵⍵ ⍵⋄⍺⍺.c}\n",
    "    \n",
    "which takes a namespace holding the cached int value.\n",
    "\n",
    "Health warning: there is no macro facility in APL, so instead we're abusing the hydrant (⍎) function to evaluate APL code represented as strings. In lisp lingo, this is 100% unhygenic and rather unsafe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 599,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">clear ws\n",
       "</span>"
      ]
     },
     "execution_count": 599,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ")clear\n",
    "⎕IO←1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 600,
   "metadata": {},
   "outputs": [],
   "source": [
    "DAY7←⊃⎕NGET'data/2015/07.txt'1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 601,
   "metadata": {},
   "outputs": [],
   "source": [
    "⍝ Some helper functions\n",
    "Bin←{(16⍴2)⊤⍵}\n",
    "Dec←{2⊥⍵}\n",
    "RegexGroups←{⍺⎕S{⍵.(1↓Lengths↑¨Offsets↓¨⊂Block)}⊢⍵}\n",
    "Cache←{¯1=⍺⍺.c:⍺⍺.c⊣⍺⍺.c←⍵⍵ ⍵⋄⍺⍺.c}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 602,
   "metadata": {},
   "outputs": [],
   "source": [
    "⍝ Gate functions as defined in the problem statement\n",
    "AND←{Dec (Bin ⍺)∧(Bin ⍵)}\n",
    "OR←{Dec (Bin ⍺)∨(Bin ⍵)}\n",
    "NOT←{Dec ~(Bin ⍵)}\n",
    "RSHIFT←{ba←Bin ⍺⋄Dec (-≢ba)↑(-⍵)↓ba}\n",
    "LSHIFT←{ba←Bin ⍺⋄Dec (≢ba)↑⍵↓ba}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 603,
   "metadata": {},
   "outputs": [],
   "source": [
    "Arg←{1=1⊃⎕VFI ⍵:⍵⋄∊'(',⍵,' ⍬)'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 604,
   "metadata": {},
   "outputs": [],
   "source": [
    "Parse←{'(\\w*)\\s*(AND|NOT|OR|RSHIFT|LSHIFT|)\\s*(\\w*)\\s->\\s(\\w+)' RegexGroups ⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 605,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "Compile←{ ⍝ Turn the parsed input to strings representing APL functions.\n",
    "    (⊃⍵[1])≡'NOT':∊⍵[4],'←({⍵⊣⍵.c←¯1}⎕NS'''') Cache {NOT ',(Arg ⊃⍵[3]),'}'\n",
    "    0=≢⊃⍵[2]:∊⍵[4],'←({⍵⊣⍵.c←¯1}⎕NS'''') Cache {',(Arg ⊃⍵[1]),'}'\n",
    "    ∊⍵[4],'←({⍵⊣⍵.c←¯1}⎕NS'''') Cache {',(Arg ⊃⍵[1]),' ',⍵[2],' ',(Arg ⊃⍵[3]),'}'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 606,
   "metadata": {},
   "outputs": [],
   "source": [
    "⍎¨Compile¨Parse DAY7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 607,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">956\n",
       "</span>"
      ]
     },
     "execution_count": 607,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a ⍬                   ⍝ Part1: what's the value of \"a\"? => 956"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Part2: Reset, and then override \"b\" to the final value of \"a\" in Part 1. What's the value of \"a\" now?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 608,
   "metadata": {},
   "outputs": [],
   "source": [
    "⍎¨Compile¨Parse DAY7  ⍝ Reset by recompiling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 609,
   "metadata": {},
   "outputs": [],
   "source": [
    "b←{956}               ⍝ Override \"b\" -- no need for the Cache."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 610,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">40149\n",
       "</span>"
      ]
     },
     "execution_count": 610,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a ⍬                   ⍝ Part2: what's the value of \"a\"? =>40149"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 611,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">clear ws\n",
       "</span>"
      ]
     },
     "execution_count": 611,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ")clear"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 8: Matchsticks\n",
    "https://adventofcode.com/2015/day/8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 612,
   "metadata": {},
   "outputs": [],
   "source": [
    "⎕IO←1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 613,
   "metadata": {},
   "outputs": [],
   "source": [
    "DAY8TEXT←⊃⎕NGET 'data/2015/08.txt' 1\n",
    "DAY8BYTES←⊃{⍺⎕UCS¨⍨⊂'-\\w+$'⎕R''⊢⍵}/2↑⎕NGET 'data/2015/08.txt' 1  ⍝ Raw bytes, split on line endings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 614,
   "metadata": {},
   "outputs": [],
   "source": [
    "Day8p1←{(≢⍵)-¯2+≢'\\\\\\\\'⎕R'\\\\'⊢s←'(\\\\x[a-f0-9]{2}|\\\\[\\''\"])'⎕R'⎕'⊢⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 615,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1350\n",
       "</span>"
      ]
     },
     "execution_count": 615,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+/Day8p1¨DAY8TEXT ⍝ 1350"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 616,
   "metadata": {},
   "outputs": [],
   "source": [
    "Day8p2←{(≢⍵)-⍨(2+2×+/bq)++/~bq←3≠34 92⍳⍵} ⍝ +2 for surrounding brackets, +2 for every \" and \\"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 617,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">2085\n",
       "</span>"
      ]
     },
     "execution_count": 617,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+/Day8p2¨DAY8BYTES ⍝ 2085"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 9: All in a Single Night\n",
    "https://adventofcode.com/2015/day/9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 828,
   "metadata": {},
   "outputs": [],
   "source": [
    "⎕IO←1\n",
    "'pmat'⎕CY'dfns'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 829,
   "metadata": {},
   "outputs": [],
   "source": [
    "DAY9←' '(≠⊆⊢)¨'( to | = )'⎕R' '⊃⎕NGET'data/2015/09.txt'1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 830,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "Day9←{\n",
    "     weights←w,w←⍎¨⊢/↑⍵                 ⍝ Two copies of the weights, as A->B == B->A \n",
    "     edges←(⊢⍪⌽)28 2⍴(∪⍳⊢),(↑⍵)[;1 2]   ⍝ Swap strings for numeric index, and add reverse direction\n",
    "     adj←weights@(↓edges)⊢0⍴⍨2⍴8        ⍝ Build adjacency matrix\n",
    "     (⌊/,⌈/)+/adj[↓{∊⍵}⌺1 2⊢pmat 8]     ⍝ Generate length 8 permuations, grab the path length, then min-max.\n",
    " }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 831,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">251 898\n",
       "</span>"
      ]
     },
     "execution_count": 831,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Day9 DAY9 ⍝ p1: 251 p2: 898"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 10: Elves Look, Elves Say\n",
    "https://adventofcode.com/2015/day/10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 809,
   "metadata": {},
   "outputs": [],
   "source": [
    "Day10←{∊(⍕∘≢,1∘↑)¨⍵⊂⍨1,2≠/⍵} ⍝ For each group of equal elements, generate count+element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 810,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">329356\n",
       "</span>"
      ]
     },
     "execution_count": 810,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">4666278\n",
       "</span>"
      ]
     },
     "execution_count": 810,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "≢Day10⍣40⊢'3113322113'  ⍝ 329356\n",
    "≢Day10⍣50⊢'3113322113'  ⍝ 4666278"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 11: Corporate Policy\n",
    "https://adventofcode.com/2015/day/11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 791,
   "metadata": {},
   "outputs": [],
   "source": [
    "⎕IO←0              ⍝ NOTE: zero-based indexing!\n",
    "AB←↓⍉↑(⊂,⊂)⎕A      ⍝ Repeated pairs: aa bb cc ...\n",
    "ABC←¯1↓1↓↓{⍵}⌺3⊢⎕A ⍝ Length-3 straights: abc bcd cde ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 792,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "Valid←{\n",
    "    ∨/'OIL'∊⍵:0             ⍝ Rule 2\n",
    "    0=+/ABC∊¯1↓1↓↓{⍵}⌺3⊢⍵:0 ⍝ Rule 1\n",
    "    (+/AB∊{⊂⍵}⌺2⊢⍵)≥2       ⍝ Rule 3\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to generate the next password from a string of uppercase letters. This corresponds to adding 1 in base 26 (if `⎕IO←0`), which is conveniently expressable in APL using the encode and decode primitives. Here is an illustration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 802,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">3276873\n",
       "</span>"
      ]
     },
     "execution_count": 802,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">7 4 11 11 15\n",
       "</span>"
      ]
     },
     "execution_count": 802,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">HELLP\n",
       "</span>"
      ]
     },
     "execution_count": 802,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←b26←1+26⊥⎕A⍸'HELLO' ⍝ Convert string to base 26, and add 1\n",
    "⎕←d←(5⍴26)⊤b26        ⍝ Convert back to decimal\n",
    "⎕A[d]                 ⍝ Turn back into character vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 793,
   "metadata": {},
   "outputs": [],
   "source": [
    "Day11←{({⎕A[(8⍴26)⊤1+26⊥⎕A⍸⍵]}⍣{Valid ⍺})⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 794,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">HEPXXYZZ\n",
       "</span>"
      ]
     },
     "execution_count": 794,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←part1←Day11 'HEPXCRRQ'  ⍝ HEPXXYZZ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 795,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">HEQAABCC\n",
       "</span>"
      ]
     },
     "execution_count": 795,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Day11 part1  ⍝ HEQAABCC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 12: JSAbacusFramework.io\n",
    "https://adventofcode.com/2015/day/12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 781,
   "metadata": {},
   "outputs": [],
   "source": [
    "⎕IO←1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 632,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "ValidItems←{\n",
    "    values←{0=≢⍵.(⎕NL ¯2):⍬⋄⍵.(⍎¨⎕NL ¯2)} ⍵ \n",
    "    (⊂'red')∊values:,0\n",
    "    0=≢⍵.(⎕NL ¯9):values\n",
    "    values,∊∇¨⍵.(⍎¨⎕NL ¯9)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 633,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "Day12p2←{\n",
    "    {(1=2|⎕DR)⍵}⍵:⍵                        ⍝ Are we a number?\n",
    "    (⍕≡⊢)⍵:0                               ⍝ Are we a string?\n",
    "    {(326=⎕DR⍵)∧(0=≡)⍵} ⍵:+/∇ValidItems ⍵  ⍝ Are we an object?\n",
    "    +/∊∇¨⍵                                 ⍝ We're a list\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 634,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">156366\n",
       "</span>"
      ]
     },
     "execution_count": 634,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">96852\n",
       "</span>"
      ]
     },
     "execution_count": 634,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{+/(3=⊢/⍵)/⍵[;3]} (⎕JSON⍠'M')⊃⊃⎕NGET'data/2015/12.txt'1 ⍝ Part 1: just sum all values...156366\n",
    "Day12p2 ⎕JSON⊃⊃⎕NGET'data/2015/12.txt'1                 ⍝ Part 2: 96852"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 13: Knights of the Dinner Table\n",
    "https://adventofcode.com/2015/day/13\n",
    "\n",
    "This is very similar to day 9, and we can broadly use the same technique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 635,
   "metadata": {},
   "outputs": [],
   "source": [
    "⎕IO←1\n",
    "RegexGroups←{⍺⎕S{⍵.(1↓Lengths↑¨Offsets↓¨⊂Block)} ⊢ ⍵}\n",
    "DAY13← ↑'(.+) would (gain|lose) (\\d+).+to ([^.]+)' RegexGroups ⊃⎕NGET'data/2015/13.txt'1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 636,
   "metadata": {},
   "outputs": [],
   "source": [
    "EDGES←⍉(⊣/DAY13),[0.5]⊢/DAY13\n",
    "WEIGHTS←-@(((⊂'lose')≡¨DAY13[;2])/⍳≢DAY13[;2]) ⊢ ⍎¨DAY13[;3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 637,
   "metadata": {},
   "outputs": [],
   "source": [
    "e←(⍴EDGES)⍴(∪⍳⊢),EDGES    ⍝ Convert strings to indexes\n",
    "adj←WEIGHTS@(↓e)⊢0⍴⍨2⍴8   ⍝ Happiness matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 638,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">  0   2  26 ¯82 ¯75  42  38  39\n",
       " 40   0 ¯61 ¯15  63  41  30  87\n",
       "¯35 ¯99   0 ¯51  95  90 ¯16  94\n",
       " 36 ¯18 ¯65   0 ¯18 ¯22   2  42\n",
       "¯65  24 100  51   0  21  55 ¯44\n",
       "¯48  91   8 ¯66  97   0  ¯9 ¯92\n",
       "¯44 ¯25  17  92 ¯92  18   0  97\n",
       " 92 ¯96 ¯51 ¯81  31 ¯73 ¯89   0\n",
       "</span>"
      ]
     },
     "execution_count": 638,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adj                       ⍝ Note: asymmetric!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike Day 9, this graph is directional, so the weight from A to B is not the same as the weight from B to A. So we need to generate all permutations of length 8, but then ensure that we also have the reverse directions -- and also ensure that the end is tied back to the beginning.\n",
    "\n",
    "The expression `p,⊣/p←pmat 8` copies the first column to the end to ensure the circle is connected, and `m,1↓[2]⌽m` means that we add in all the reverse connections."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 639,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">733\n",
       "</span>"
      ]
     },
     "execution_count": 639,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⌈/+/adj[↓{∊⍵}⌺1 2⊢m,1↓[2]⌽m←p,⊣/p←pmat 8] ⍝ Part 1: 733"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For part 2 we simply don't connect the circle -- this has the same effect as inserting a weight-0 node."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 640,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">725\n",
       "</span>"
      ]
     },
     "execution_count": 640,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⌈/+/adj[↓{∊⍵}⌺1 2⊢m,1↓[2]⌽m←pmat 8] ⍝ Part 2: 725"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 14: Reindeer Olympics\n",
    "https://adventofcode.com/2015/day/14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 747,
   "metadata": {},
   "outputs": [],
   "source": [
    "⎕IO←1\n",
    "DAY14←⍎¨'\\d+'⎕S'&'⊃⎕NGET'data/2015/14.txt'1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 748,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA←(≢DAY14)3⍴DAY14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 749,
   "metadata": {},
   "outputs": [],
   "source": [
    "⍝ Speed, Travel-time, Rest-time, State, Counter, Distance travelled, Score\n",
    "LB←(((DATA,1),(DATA[;2])),0),0  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 750,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "Day14←{\n",
    "    lb←⍵\n",
    "    lb[;5]-←1                            ⍝ Decrease the counter\n",
    "    lb[;6]+←lb[;1]×1=lb[;4]              ⍝ Move any movers; resters unchanged\n",
    "    lb[;7]+←(⌈/a)=a←lb[;6]               ⍝ Add 1 to the leaders col for part 2.\n",
    "    ↑{0≠⍵[5]:⍵⋄⍵[3-s[4]]@5⊢s←~@4⊢⍵}¨↓lb  ⍝ Perform state transitions where counter is 0\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 751,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">2655\n",
       "</span>"
      ]
     },
     "execution_count": 751,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1059\n",
       "</span>"
      ]
     },
     "execution_count": 751,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "RACE←Day14⍣2503⊢LB                       ⍝ Run for 2503 iterations\n",
    "⌈/RACE[;6]                               ⍝ Part 1 is max distance: 2655\n",
    "⌈/RACE[;7]                               ⍝ Part 2 is max score: 1059"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 15: Science for Hungry People\n",
    "https://adventofcode.com/2015/day/15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 646,
   "metadata": {},
   "outputs": [],
   "source": [
    "⎕IO←1\n",
    "DAY15←(5÷⍨≢d)5⍴d←⍎¨'-?\\d+'⎕S'&'⊃⎕NGET'data/2015/15.txt'1 ⍝ The numbers, wrestled into matrix of 5-element rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 647,
   "metadata": {},
   "outputs": [],
   "source": [
    "CAL←⊢/DAY15      ⍝ Keep calorie data in a vector\n",
    "INGR←¯1↓[2]DAY15 ⍝ Just the ingredients"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 648,
   "metadata": {},
   "outputs": [],
   "source": [
    "Cmb←{(n t)←⍵⋄A←⊃∘.+/(n-1)⍴⊂⍳t⋄⊃,/{⍵,¨⍸(t-⍵)=A}¨⍳t} ⍝ Cmb N M -- All N-length vectors summing to M, N[i]∊⍳M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 649,
   "metadata": {},
   "outputs": [],
   "source": [
    "Day15p1←{ingr←⍵⋄⌈/{×/0∘⌈¨⍵+.×ingr}¨Cmb 4 100} ⍝ Multiply with cost matrix, multiply again, removing negatives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 650,
   "metadata": {},
   "outputs": [],
   "source": [
    "Day15p2←{ingr←⍵⋄cal←⍺⋄⌈/{500=+/cal×⍵:×/0∘⌈¨⍵+.×ingr⋄0}¨Cmb 4 100} ⍝ As above, but exactly 500 cals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 651,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">222870\n",
       "</span>"
      ]
     },
     "execution_count": 651,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">117936\n",
       "</span>"
      ]
     },
     "execution_count": 651,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Day15p1 INGR     ⍝ 222870\n",
    "CAL Day15p2 INGR ⍝ 117936"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 16: Aunt Sue\n",
    "https://adventofcode.com/2015/day/16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 652,
   "metadata": {},
   "outputs": [],
   "source": [
    "⎕IO←1\n",
    "DAY16←⊃⎕NGET'data/2015/16.txt'1\n",
    "TARGET←0 2 7 3 5 1 3 2 3 0\n",
    "ITEMS←'aki' 'car' 'cat' 'chi' 'gol' 'per' 'pom' 'sam' 'tre' 'viz'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 653,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "ToRow←{\n",
    "    m←↑{(⊂3↑1↓1⊃⍵),⊂⍎1↓2⊃⍵}¨':'(≠⊆⊢)¨⍵ ⍝ Split on ':', pick first 3 letters and convert the numbers\n",
    "    r←10⍴0\n",
    "    r[ITEMS⍳⊣/m]←⊢/m                   ⍝ Fill in the known quantities\n",
    "    r\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 654,
   "metadata": {},
   "outputs": [],
   "source": [
    "Parse←{ToRow¨','(≠⊆⊢)¨'Sue \\d+:'⎕R''⊢⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 655,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "Day16p1←{\n",
    "    where←⍸0≠⍵\n",
    "    ⍺[where]≡⍵[where]\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 656,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "Day16p2←{\n",
    "    target←⍺\n",
    "    sue←⍵\n",
    "\n",
    "    ∧/{\n",
    "        (⍵=3)∨⍵=9:sue[⍵]>target[⍵]\n",
    "        (⍵=5)∨⍵=7:sue[⍵]<target[⍵]\n",
    "        sue[⍵]=target[⍵]\n",
    "    }¨⍸0≠⍵\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 657,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">40\n",
       "</span>"
      ]
     },
     "execution_count": 657,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">225 241\n",
       "</span>"
      ]
     },
     "execution_count": 657,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⍸TARGET∘Day16p1¨Parse DAY16 ⍝ Part 1: 40\n",
    "⍸TARGET∘Day16p2¨Parse DAY16 ⍝ Part 2: 241 TODO: should not also return 225..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 17: No Such Thing as Too Much\n",
    "https://adventofcode.com/2015/day/17\n",
    "\n",
    "Count the number of subsets of buckets that can hold exactly 150 units. This can be cast as a count-up from 1 to a \"bucket-count\"-bit binary number of all 1s. A 1 in a given place means that the corresponding bucket is picked. For example, if we have the following five buckets:\n",
    "\n",
    "    50 44 11 49 42\n",
    "    \n",
    "we need to count from 1 to 31 (11111). If we take for example the seventh (00111) selection we get\n",
    "\n",
    "    50 44 11 49 42\n",
    "     0  0  1  1  1  => 11 + 49 + 42 = 102\n",
    "     \n",
    "We can translate this approach directly to APL."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 658,
   "metadata": {},
   "outputs": [],
   "source": [
    "DAY17←50 44 11 49 42 46 18 32 26 40 21 7 18 43 10 47 36 24 22 40 ⍝ Container volumes\n",
    "Bin←{(20⍴2)⊤⍵}\n",
    "Dec←{2⊥⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 659,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">654\n",
       "</span>"
      ]
     },
     "execution_count": 659,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+/{150=+/DAY17/⍨Bin ⍵}¨⍳Dec 20⍴1 ⍝ Part 1: 654"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For part 2 we need to find the fewest number of buckets that can hold 150 units, and then count the number of distinct such combinations. We know there are 654 solutions in total -- let's capture them, rather than just counting them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 660,
   "metadata": {},
   "outputs": [],
   "source": [
    "VALID←(0≠v)/v←{150=+/DAY17/⍨Bin ⍵:⍵⋄0}¨⍳Dec 20⍴1 ⍝ Return the sequence number if sum is 150, otherwise 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next step is to find the fewest number of buckets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 661,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">4\n",
       "</span>"
      ]
     },
     "execution_count": 661,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕←MIN←⌊/≢¨BUCKETS←{DAY17/⍨Bin ⍵}¨VALID"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and then count the solutions using the minimum number of buckets, which is our answer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 662,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">57\n",
       "</span>"
      ]
     },
     "execution_count": 662,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+/MIN=≢¨BUCKETS ⍝ 57"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 18: Like a GIF For Your Yard\n",
    "https://adventofcode.com/2015/day/18\n",
    "\n",
    "This is an implementation of [Conway's Game of Life](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life). It's a bit of an [APL party trick](https://aplwiki.com/wiki/Conway%27s_Game_of_Life). An excellent walk-through of the technique applied here is provided in a [Dyalog webinar](https://dyalog.tv/Webinar/?v=3FjYly2G_QI)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 663,
   "metadata": {},
   "outputs": [],
   "source": [
    "DAY18←↑'#'=¨⊃⎕NGET'data/2015/18.txt'1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 664,
   "metadata": {},
   "outputs": [],
   "source": [
    "GoL←{≢⍸⍵}⌺3 3∊¨3+0,¨,¨   ⍝ Wait, what kind of witchcraft is this...?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 665,
   "metadata": {},
   "outputs": [],
   "source": [
    "Day18p1←{+/∊GoL⍣100⊢⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 666,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1061\n",
       "</span>"
      ]
     },
     "execution_count": 666,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Day18p1 DAY18 ⍝ 1061"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For part 2, the 4 corner cells are immortal. We can simply ensure those are reset at the end of each iteration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 667,
   "metadata": {},
   "outputs": [],
   "source": [
    "GoL2←{1@(,1 100∘.,1 100)⊢GoL ⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 668,
   "metadata": {},
   "outputs": [],
   "source": [
    "Day18p2←{+/∊GoL2⍣100⊢⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 669,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1006\n",
       "</span>"
      ]
     },
     "execution_count": 669,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Day18p2 DAY18 ⍝ 1006"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 19: Medicine for Rudolph\n",
    "https://adventofcode.com/2015/day/19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 670,
   "metadata": {},
   "outputs": [],
   "source": [
    "DAY19←⊃⎕NGET'data/2015/19.txt'1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 671,
   "metadata": {},
   "outputs": [],
   "source": [
    "TARGET←⊃¯1↑DAY19\n",
    "RULES←↓(↑' '(≠⊆⊢)¨¯2↓DAY19)[;1 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 672,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "ApplyRule←{                                 ⍝ Apply a transformation rule, returning all resulting strings\n",
    "    (key val)←⍵\n",
    "    ⍺∘{\n",
    "        (idx len)←⍵\n",
    "        (idx↑⍺),val,⍺↓⍨idx+len              ⍝ Separate the string on the match, and re-join on replacement\n",
    "    }¨key ⎕S{⍵.((1↑Offsets),1↑Lengths)}⊢⍺   ⍝ Each match location\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 673,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">509\n",
       "</span>"
      ]
     },
     "execution_count": 673,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "≢∪{⊃,/⊆¨⍵}⍣≡TARGET∘ApplyRule¨RULES          ⍝ 509 - count uniques in the flattened vector of produced strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For part 2, we seek the smallest number of transformations to reach the target molecule starting from a single \"electron\": \"e\". To solve this we work backwards from the target molecule applying the rules in reverse until we either get to \"e\", or we reach a point where there is no change. \n",
    "\n",
    "If there is no change, we shuffle the rules order to break out of the local minimum reached in the search space. This will only result in the shortest path if there is only a single path from \"e\" to target, which fortunately is the case, and the convergence is super-quick.\n",
    "\n",
    "Obviously not the most array-based solution, and most natural as a tradfn."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 674,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "res←molecule Day19p2 rules;current;count;prev;val;key\n",
    "current←molecule\n",
    "count←0\n",
    ":While current≢,'e'\n",
    "    prev←current\n",
    "    :For val key :In rules                 ⍝ Note: we apply rules 'backwards'\n",
    "        :If ~key(1∊⍷)current               ⍝ Check if rule matches\n",
    "            :Continue\n",
    "        :EndIf\n",
    "        current←(key ⎕R val⍠'ML'1)current  ⍝ Apply single step -- as _unwinding_ transformations\n",
    "        count+←1\n",
    "        :If prev≡current                   ⍝ No change after applying all rules: local minimum\n",
    "            current←molecule               \n",
    "            count←0\n",
    "            rules←(⊢⌷⍨∘⊂?⍨∘≢)rules         ⍝ Shuffle the rules ordering to break out of local minimum\n",
    "        :EndIf\n",
    "    :EndFor\n",
    ":EndWhile\n",
    "res←count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 675,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">195\n",
       "</span>"
      ]
     },
     "execution_count": 675,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TARGET Day19p2 RULES ⍝ 195"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 20: Infinite Elves and Infinite Houses\n",
    "https://adventofcode.com/2015/day/20\n",
    "\n",
    "The obvious observation is that the number of elf-visits at a given house (part 1) is the sum of the divisors of the house number. There is no handy built-in for this -- the [APL Cart](https://aplcart.info/?q=sum%20of%20divisors#) suggestion of `(+/∘∪⊢∨⍳)` is too inefficient here. We can roll our own using the handy `pco` prime sieve from the [dfns](http://dfns.dyalog.com/n_pco.htm) workspace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 819,
   "metadata": {},
   "outputs": [],
   "source": [
    "⎕IO←1\n",
    "'pco'⎕CY'dfns'       ⍝ Pull in 'pco' -- a fast prime sieve\n",
    "DAY20←29000000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 820,
   "metadata": {},
   "outputs": [],
   "source": [
    "DivSum←{×/{(¯1+⍺*⍵+1)÷⍺-1}⌿2 pco ⍵}               ⍝ Sum of positive divisors, aka σ(n)\n",
    "Divisors←{⍵=1:,1⋄∊∘.×/{⍺∘.*0,⍳⍵}⌿2 pco ⍵}   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 822,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">665280\n",
       "</span>"
      ]
     },
     "execution_count": 822,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">705600\n",
       "</span>"
      ]
     },
     "execution_count": 822,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+⍣{(DivSum ⍺)≥DAY20÷10}1                         ⍝ Part 1: 665280 -- note: takes around 15s or so to run\n",
    "1+⍣{({11×+/(⍵{⍺≤⍵×50}¨d)/d←Divisors ⍵} ⍺)≥DAY20}1 ⍝ Part 2: 705600 -- note: takes around 30s or so to run"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 21: RPG Simulator 20XX\n",
    "https://adventofcode.com/2015/day/21\n",
    "\n",
    "Fight-rules:\n",
    "\n",
    "1. Must hold exactly one weapon.\n",
    "2. May hold zero or one armour items.\n",
    "3. May hold zero, one or two rings. If two, must be different.\n",
    "4. Part 1: minimise cost whilst winning.    \n",
    "5. Part 2: maximise cost whilst losing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 683,
   "metadata": {},
   "outputs": [],
   "source": [
    "DAY21←103 9 2 ⍝ The boss-spec: Hitpoints Damage Armor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're given the characteristics of weaponry and armor etc. Turn this into a matrix, adding an extra row of three zeros for armor, signifying that it's optional, and two such rows for the same reason in the rings section. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 684,
   "metadata": {},
   "outputs": [],
   "source": [
    "ITEMS←8 4 0 10 5 0 25 6 0 40 7 0 74 8 0 0 0 0 13 0 1 31 0 2 53 0 3 75 0 4 102 0 5 0 0 0 0 0 0 25 1 0 50 2 0 100 3 0 20 0 1 40 0 2 80 0 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 685,
   "metadata": {},
   "outputs": [],
   "source": [
    "(COSTS DAMAGE ARMOR)←↓⍉(3÷⍨≢ITEMS) 3⍴ITEMS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now construct a set of vectors representing the possible choices of 1 weapon, 0 or 1 armour, and 0, 1 or 2 rings (which must be unique)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 686,
   "metadata": {},
   "outputs": [],
   "source": [
    "⍝        <-weapon>   <---armor--->   <--------ring 1------->   <--------ring 2------->\n",
    "CHOICES←,1 2 3 4 5∘.,6 7 8 9 10 11∘.,12 13 14 15 16 17 18 19∘.,12 13 14 15 16 17 18 19 \n",
    "VALID←~{(⍵[3]>14)∧(⍵[3]=⍵[4])}¨CHOICES\n",
    "OPTIONS←VALID/CHOICES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 687,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "Winner←{  ⍝ boss Winner selection\n",
    "    ⍺ {\n",
    "        bhp←⍺[1]-1⌈⍵[2]-⍺[3] ⋄ bhp≤0:1\n",
    "        php←⍵[1]-1⌈⍺[2]-⍵[3] ⋄ php≤0:0\n",
    "        (bhp@1⊢⍺)∇php@1⊢⍵\n",
    "    } 100,(+/DAMAGE[⍵]),+/ARMOR[⍵]\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 688,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">121\n",
       "</span>"
      ]
     },
     "execution_count": 688,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">201\n",
       "</span>"
      ]
     },
     "execution_count": 688,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHARGE←{+/COSTS[⍵]}¨OPTIONS              ⍝ Total costs per kit-out in the store \n",
    "⌊/CHARGE[⍸DAY21∘Winner¨OPTIONS]          ⍝ Part 1: 121 -- least spend for a win\n",
    "⌈/CHARGE[⍸~DAY21∘Winner¨OPTIONS]         ⍝ Part 2: 201 -- most spend for a loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 22: Wizard Simulator 20XX\n",
    "https://adventofcode.com/2015/day/22\n",
    "\n",
    "As in the previous question, we're given a table of data, this time describing \"spells\" and \"effects\". We massage these into a nice matrix with the following columns:\n",
    "\n",
    "    mana-change player-hp boss-hp total-cost shield poison recharge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 689,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\"> ¯53 0 ¯4  53 0 0 0\n",
       " ¯73 2 ¯2  73 0 0 0\n",
       "¯113 0  0 113 6 0 0\n",
       "¯173 0  0 173 0 6 0\n",
       "¯229 0  0 229 0 0 5\n",
       "</span>"
      ]
     },
     "execution_count": 689,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⍝ State vector fields: mana-change player-hp boss-hp total-spend shield poison recharge\n",
    "⍝\n",
    "⍝         <-magic missile-> <-----drain-----> <-----shield-----> <-----poison-----> <----recharge---->\n",
    "⎕←MAGIC←5 7⍴¯53 0 ¯4 53 0 0 0 ¯73 2 ¯2 73 0 0 0 ¯113 0 0 113 6 0 0 ¯173 0 0 173 0 6 0 ¯229 0 0 229 0 0 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This time, at each turn we must choose a spell to cast from the above five. This turns the search space into a graph, and the solution one of costed path finding.\n",
    "\n",
    "At each point we have a state, consisting of the player and the boss with their respective \"stats\", plus the player's stash of \"mana\" and any lingering spell effects. A state transition is the casting of a spell, the application of any multi-turn spells already cast, plus the response from the boss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 722,
   "metadata": {},
   "outputs": [],
   "source": [
    "START←500 50 71 0 0 0 0                 ⍝ State vector: mana player-hp boss-hp total-spend shield poison recharge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 723,
   "metadata": {},
   "outputs": [],
   "source": [
    "⍝ Effects\n",
    "Shield←{⍵[5]>0:¯1∘+@5⊢⍵⋄⍵}              ⍝ No need to do anything apart from decrease counter\n",
    "Poison←{⍵[6]>0:¯3∘+@3⊢¯1∘+@6⊢⍵⋄⍵}       ⍝ Boss: hp-←3, if active\n",
    "Recharge←{⍵[7]>0:101∘+@1⊢¯1∘+@7⊢⍵⋄⍵}    ⍝ Mana+←101, if active\n",
    "ApplyEffects←{Finished ⍵:⍵⋄Shield Poison Recharge ⍵}\n",
    "\n",
    "BossTurn←{Finished ⍵:⍵⋄dp←10-7×⍵[5]>0⋄{⍵-dp}@2⊢⍵}\n",
    "PlayerTurn←{⍵∘Cast¨↓MAGIC}\n",
    "Finished←{(⍵[2]≤0)∨⍵[3]≤0}\n",
    "StateTransition←{Finished ⍵:⍬ ⋄ ApplyEffects∘BossTurn¨PlayerTurn ApplyEffects ⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 738,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "Cast←{               ⍝ Cast a spell: state Cast spell\n",
    "    ⍺[1]<-⍵[1]:⍺     ⍝ Too expensive!\n",
    "    ⍵[3]<0:⍺+⍵       ⍝ Non-time limited spell; just cast it\n",
    "    idx←⍸0≠¯3↑⍵\n",
    "    0≠idx⌷¯3↑⍺:⍺     ⍝ Time-limited spell already in effect!\n",
    "    ⍺+⍵              ⍝ Ok, we can cast spell.\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now crudely brute out the whole graph and ask questions later. This could be done much faster with a full Dijkstra or A* implementation instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 725,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "BFS←{                ⍝ Naive breadth-first search, to the bottom. Accumulate visited states as ⍺\n",
    "    ⍺←⍬⋄0=≢⍵:⍺                  \n",
    "    current←⊃1↑⍵ ⋄ queue←1↓⍵\n",
    "    neighbours←StateTransition current\n",
    "    (⍺,⊂current)∇queue∪neighbours~⍺                          \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 726,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "Day22p1←{\n",
    "    data←BFS ⍵\n",
    "    bhp←(↑data)[;3]       ⍝ Boss hitpoints\n",
    "    ⌊/(↑(0>bhp)/data)[;4] ⍝ Pick winning rows, and find smallest total cost\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 727,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1824\n",
       "</span>"
      ]
     },
     "execution_count": 727,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Day22p1 ⊂START ⍝ 1824 -- note, takes a minute or two to run."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 23: Opening the Turing Lock\n",
    "https://adventofcode.com/2015/day/23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 699,
   "metadata": {},
   "outputs": [],
   "source": [
    "DAY23←⊃⎕NGET'data/2015/23.txt'1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 700,
   "metadata": {},
   "outputs": [],
   "source": [
    "RegexGroups←{⍺⎕S{⍵.(1↓Lengths↑¨Offsets↓¨⊂Block)} ⊢ ⍵}\n",
    "Parse←{0<≢'^[+-]?\\d+$'⎕S'&'⊢⍵:⍎⍵⋄⍵≡,'a':1⋄⍵≡,'b':2⋄⍵}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 701,
   "metadata": {},
   "outputs": [],
   "source": [
    "data←{⊃,/⊆¨⍵}⍣≡'([a-z]{3}) ([+ab0-9-]+),?\\s*([+0-9]*)'∘RegexGroups¨DAY23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 702,
   "metadata": {},
   "outputs": [],
   "source": [
    "MEM←(3÷⍨≢data) 3⍴Parse¨data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 703,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "Day23←{\n",
    "    ip←3⌷⍺ \n",
    "    ip>≢⍵:⍺\n",
    "    instr←ip⌷⍵⋄op←⊃instr                                     ⍝ Fetch instruction at ip, opcode is first element\n",
    "    op≡'hlf':(⍺ {r←⊃⍵⋄1∘+@3⊢(2÷⍨r⌷⍺)@r⊢⍺} 1↓instr)∇⍵         ⍝ Halve reg content, add 1 to ip\n",
    "    op≡'jio':(⍺ {(r d)←⍵⋄1=r⌷⍺:d∘+@3⊢⍺⋄1∘+@3⊢⍺} 1↓instr)∇⍵   ⍝ If reg content is 1, add delta to ip, else add 1\n",
    "    op≡'inc':(⍺ {r←⊃⍵⋄1∘+@3⊢(1+⍨r⌷⍺)@r⊢⍺} 1↓instr)∇⍵         ⍝ Add 1 to reg content, add 1 to ip\n",
    "    op≡'tpl':(⍺ {r←⊃⍵⋄1∘+@3⊢(3×⍨r⌷⍺)@r⊢⍺} 1↓instr)∇⍵         ⍝ 3 × reg content, add 1 to ip\n",
    "    op≡'jmp':(⍺ {d←⊃⍵⋄d∘+@3⊢⍺} 1↓instr)∇⍵                    ⍝ Add delta to ip\n",
    "    op≡'jie':(⍺ {(r d)←⍵⋄0=2|r⌷⍺:d∘+@3⊢⍺⋄1∘+@3⊢⍺} 1↓instr)∇⍵ ⍝ If reg content is even, add delta to ip, else add 1\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 704,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">255\n",
       "</span>"
      ]
     },
     "execution_count": 704,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2⌷0 0 1 Day23 MEM ⍝ 255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 705,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">334\n",
       "</span>"
      ]
     },
     "execution_count": 705,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2⌷1 0 1 Day23 MEM ⍝ 334"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 24: It Hangs in the Balance\n",
    "https://adventofcode.com/2015/day/24\n",
    "\n",
    "Data is a list of very prime-looking numbers. Task is to create three groups, summing to the same number, with the extra constraint that the first group should minimise the number of items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 706,
   "metadata": {},
   "outputs": [],
   "source": [
    "'cmat' 'big'⎕CY'dfns'\n",
    "DAY24←1 3 5 11 13 17 19 23 29 31 37 41 43 47 53 59 67 71 73 79 83 89 97 101 103 107 109 113"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 707,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">508\n",
       "</span>"
      ]
     },
     "execution_count": 707,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3÷⍨+/DAY24"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By applying part guesswork and part brute force, we will start at the minimum number of items required, try all combinations, and if none is found, add another item such that the sum is 508 (data sum divided by 3). In other words, we only search for the first group, and \"hope\" that the rest works out. The lower bound of the number of items is 5, as 103 + 107 + 109 + 113 < 508, but adding the fifth largest item takes us above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 728,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "TrySelection←{\n",
    "    numbers←⍺\n",
    "    (elements val)←⍵\n",
    "    Best←{⍺≡⍬:⍵⋄(×/⍺)<×/⍵:⍺⋄⍵}             ⍝ Compare products of elements\n",
    "    ⍬{\n",
    "        0=≢⍵:⍺\n",
    "        weights←numbers[1↑⍵]               ⍝ Selected elements\n",
    "        val=+/weights:(⍺ Best weights)∇1↓⍵ ⍝ Correct sum? If so, any better than previous best?\n",
    "        ⍺∇1↓⍵                              ⍝ Keep going\n",
    "    }↑elements cmat ≢numbers               ⍝ All possible selection of 'elements' numbers\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 729,
   "metadata": {},
   "outputs": [],
   "source": [
    "Day24←{n←⍵⋄val←⍺÷⍨+/⍵⋄⍵ {v←n TrySelection ⍵ val⋄v≢⍬:v⋄∇⍵+1} 5} ⍝ Starting from 5 elements, increase until solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 730,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">10439961859\n",
       "</span>"
      ]
     },
     "execution_count": 730,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⊃×big/3 Day24 DAY24 ⍝ Part 1: 10439961859 -- need to use big-number × from dfns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 731,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">72050269\n",
       "</span>"
      ]
     },
     "execution_count": 731,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⊃×big/4 Day24 DAY24 ⍝ Part 2: 72050269"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Day 25: Let It Snow\n",
    "https://adventofcode.com/2015/day/25\n",
    "\n",
    "Christmas day! We celebrate by brute-forcing our way, zig-zagging exactly as described in the most naively possible way. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 732,
   "metadata": {},
   "outputs": [],
   "source": [
    "DAY25←2947 3029"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 736,
   "metadata": {},
   "outputs": [],
   "source": [
    "]dinput\n",
    "Day25←{\n",
    "    ⍺←2 1\n",
    "    n←33554393|252533×⍵\n",
    "    ⍺≡2947 3029:n\n",
    "    1=1⌷⍺:n∇⍨1,⍨1+2⌷⍺\n",
    "    n∇⍨¯1 1+⍺\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 737,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">19980801\n",
       "</span>"
      ]
     },
     "execution_count": 737,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Day25 20151125 ⍝ 19980801"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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": 2
}