all_code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Advent of Code 2017\n",
    "http://adventofcode.com/2017"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 1\n",
    "Puzzle input: `day01.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1119\n"
     ]
    }
   ],
   "source": [
    "with open('day01.txt') as f:\n",
    "    digit_string = f.readline().strip()\n",
    "\n",
    "matchers = [\n",
    "    i for i in range(len(digit_string)) \n",
    "    if digit_string[i] == (digit_string + digit_string[0])[i+1]\n",
    "]\n",
    "\n",
    "print(sum(\n",
    "    int(digit_string[i]) for i in matchers\n",
    "))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1420\n"
     ]
    }
   ],
   "source": [
    "n = len(digit_string)    \n",
    "matchers = [\n",
    "    i for i in range(n) \n",
    "    if digit_string[i] == (digit_string * 2)[i + n // 2]\n",
    "]\n",
    "\n",
    "print(sum(\n",
    "    int(digit_string[i]) for i in matchers\n",
    "))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 2\n",
    "Puzzle input: `day02.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "44216\n"
     ]
    }
   ],
   "source": [
    "with open('day02.txt') as f:\n",
    "    rows = f.readlines()\n",
    "\n",
    "rows = [[int(n) for n in row.strip().split()] for row in rows]\n",
    "    \n",
    "diffs = [max(r) - min(r) for r in rows]\n",
    "        \n",
    "print(sum(diffs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "320\n"
     ]
    }
   ],
   "source": [
    "from itertools import permutations\n",
    "\n",
    "def find_div(row):\n",
    "    for pair in permutations(row, 2):\n",
    "        if pair[1] % pair[0] == 0:\n",
    "            return pair[1] // pair[0]\n",
    "\n",
    "divs = [find_div(r) for r in rows]\n",
    "        \n",
    "print(sum(divs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 3\n",
    "Puzzle input: `347991`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 3, 2, 31, 480]\n"
     ]
    }
   ],
   "source": [
    "number = 347991\n",
    "\n",
    "def spiral(n):\n",
    "    current_num = 1\n",
    "    current_dist = 0\n",
    "    side_dist = 0\n",
    "    corner_dist = 0\n",
    "\n",
    "    while True:\n",
    "        corner_dist += 2\n",
    "        side_dist += 1\n",
    "        dists = list(range(corner_dist - 1, side_dist, -1))\n",
    "        dists += list(range(side_dist, corner_dist + 1))\n",
    "        for _ in range(4):\n",
    "            for d in dists:\n",
    "                if current_num == n:\n",
    "                    return current_dist\n",
    "                current_dist = d\n",
    "                current_num += 1\n",
    "\n",
    "print([\n",
    "    spiral(x) for x in [1, 12, 23, 1024, number]\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "349975"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid = [[0 for _ in range(31)] for _ in range(31)]\n",
    "\n",
    "def resize(grid):\n",
    "    rows = len(grid)\n",
    "    cols = len(grid[0])\n",
    "    grid.insert(0, [0 for _ in range(cols)])\n",
    "    grid.append([0 for _ in range(cols)])\n",
    "    for row in grid:\n",
    "        row.insert(0, 0)\n",
    "        row.append(0)\n",
    "        \n",
    "i = len(grid)//2\n",
    "j = len(grid)//2\n",
    "di = 0\n",
    "dj = 1\n",
    "\n",
    "grid[i][j] = 1\n",
    "\n",
    "moves = 0\n",
    "\n",
    "while grid[i][j] <= number:\n",
    "    if i == 1 or j == 1 or i == len(grid) - 2 or j == len(grid) - 2:\n",
    "        resize(grid)\n",
    "        i += 1\n",
    "        j += 1\n",
    "    if di == 0:\n",
    "        moves += 1\n",
    "    for move in range(moves):\n",
    "        i += di\n",
    "        j += dj\n",
    "        grid[i][j] = (\n",
    "            grid[i+1][j] + grid[i][j+1] + grid[i-1][j] + grid[i][j-1] + \n",
    "            grid[i-1][j-1] + grid[i+1][j+1] + grid[i+1][j-1] + grid[i-1][j+1]\n",
    "        )\n",
    "        if grid[i][j] > number:\n",
    "            break\n",
    "    di, dj = -dj, di   \n",
    "\n",
    "grid[i][j]    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 4\n",
    "Puzzle input: `day04.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "383\n"
     ]
    }
   ],
   "source": [
    "with open('day04.txt') as f:\n",
    "    rows = f.readlines()\n",
    "\n",
    "rows = [[word for word in row.strip('\\n\\r').split()] for row in rows]\n",
    "    \n",
    "valid = [len(row) == len(set(row)) for row in rows]\n",
    "        \n",
    "print(sum(valid))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "265\n"
     ]
    }
   ],
   "source": [
    "rows = [[''.join(sorted(word)) for word in row] for row in rows]\n",
    "    \n",
    "valid = [len(row) == len(set(row)) for row in rows]\n",
    "        \n",
    "print(sum(valid))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 5\n",
    "Puzzle input: `day05.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "387096\n"
     ]
    }
   ],
   "source": [
    "with open('day05.txt') as f:\n",
    "    instr = [int(n.strip()) for n in f.readlines()]\n",
    "\n",
    "pos = 0\n",
    "steps = 0\n",
    "while pos >= 0 and pos < len(instr):\n",
    "    newpos = pos + instr[pos]\n",
    "    instr[pos] += 1\n",
    "    pos = newpos\n",
    "    steps += 1\n",
    "\n",
    "print(steps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28040648\n"
     ]
    }
   ],
   "source": [
    "with open('day05.txt') as f:\n",
    "    instr = [int(n.strip()) for n in f.readlines()]\n",
    "\n",
    "pos = 0\n",
    "steps = 0\n",
    "while pos >= 0 and pos < len(instr):\n",
    "    newpos = pos + instr[pos]\n",
    "    instr[pos] += (-1 if instr[pos] >= 3 else 1)\n",
    "    pos = newpos\n",
    "    steps += 1\n",
    "\n",
    "print(steps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 6\n",
    "Puzzle input: `day06.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11137\n"
     ]
    }
   ],
   "source": [
    "def redistribute(b):\n",
    "    i = b.index(max(b))\n",
    "    j = i\n",
    "    while b[i] > 0:\n",
    "        j = (j + 1) % len(b)\n",
    "        b[j] += 1\n",
    "        b[i] -= 1\n",
    "\n",
    "with open('day06.txt') as f:\n",
    "    blocks = [int(n) for n in f.readline().split()]\n",
    "\n",
    "past_blocks = []\n",
    "\n",
    "while blocks not in past_blocks:\n",
    "    past_blocks.append(blocks.copy())\n",
    "    redistribute(blocks)\n",
    "\n",
    "print(len(past_blocks))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1037\n"
     ]
    }
   ],
   "source": [
    "print(len(past_blocks) - past_blocks.index(blocks))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 7\n",
    "Puzzle input: `day07.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hlqnsbe\n"
     ]
    }
   ],
   "source": [
    "with open('day07.txt') as f:\n",
    "    lines = [\n",
    "        l.strip().replace(' ','').replace(')','') \n",
    "        for l in f.readlines()\n",
    "    ]\n",
    "\n",
    "weights = [0] * len(lines) \n",
    "\n",
    "for i in range(len(lines)):\n",
    "    lines[i] = lines[i].split('->')\n",
    "    lines[i][0], weights[i] = lines[i][0].split('(')\n",
    "    weights[i] = int(weights[i])\n",
    "    if len(lines[i]) > 1:\n",
    "        children = lines[i][1].split(',')\n",
    "        lines[i] = [lines[i][0]] + children\n",
    "\n",
    "links = []\n",
    "for line in lines:\n",
    "    for child in line[1:]:\n",
    "        links.append((\n",
    "            child, line[0], \n",
    "            weights[[l[0] for l in lines].index(child)]\n",
    "        ))\n",
    "\n",
    "bottom = list(set(l[1] for l in links) - set(l[0] for l in links))[0]\n",
    "print(bottom)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "UNBALANCED AT 'aurik'\n",
      "---------------------\n",
      "'jriph' (1998) has aggregated weight 2102\n",
      "'bykobk' (1224) has aggregated weight 2097\n",
      "'uylvg' (403) has aggregated weight 2097\n",
      "'yxhntq' (9) has aggregated weight 2097\n",
      "'ywdvft' (333) has aggregated weight 2097\n",
      "\n",
      "\n",
      "UNBALANCED AT 'rilyl'\n",
      "---------------------\n",
      "'aurik' (2443) has aggregated weight 12933\n",
      "'fcmspin' (11992) has aggregated weight 12928\n",
      "'hpqvzn' (5383) has aggregated weight 12928\n",
      "'hymjivf' (28) has aggregated weight 12928\n",
      "'qgrkb' (9541) has aggregated weight 12928\n",
      "\n",
      "\n",
      "UNBALANCED AT 'hlqnsbe'\n",
      "-----------------------\n",
      "'rilyl' (28969) has aggregated weight 93614\n",
      "'vhyiaf' (96) has aggregated weight 93609\n",
      "'pdvmaam' (67089) has aggregated weight 93609\n",
      "'jkbuq' (29619) has aggregated weight 93609\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def aggweight(link):\n",
    "    children = [\n",
    "        l for l in links \n",
    "        if l[1] == link[0]\n",
    "    ]\n",
    "    childweights = [aggweight(c) for c in children]\n",
    "    if len(set(childweights)) > 1:\n",
    "        warning = \"UNBALANCED AT '%s'\" % link[0]\n",
    "        print(warning)\n",
    "        print(\"-\" * len(warning))\n",
    "        for z in zip(children, childweights):\n",
    "            print(\n",
    "                \"'%s' (%d) has aggregated weight %d\" \n",
    "                % (z[0][0], z[0][2], z[1])\n",
    "            )\n",
    "        print('\\n')\n",
    "    return link[2] + sum(childweights)\n",
    "\n",
    "bottomweight = aggweight((bottom, '', 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 8\n",
    "Puzzle input: `day08.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6343\n"
     ]
    }
   ],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "with open('day08.txt') as f:\n",
    "    lines = [l.strip().split(' ') for l in f.readlines()]\n",
    "\n",
    "dic = defaultdict(int)\n",
    "bestmax = 0\n",
    "\n",
    "for l in lines:\n",
    "    exec(\n",
    "        \"%s dic['%s'] %s %s:\\n\\tdic['%s'] %s %s\" \n",
    "        % (\n",
    "            l[3], l[4], l[5], l[6], l[0],\n",
    "            '+=' if l[1] == 'inc' else '-=',\n",
    "            l[2]\n",
    "        )\n",
    "    )\n",
    "    if dic[l[0]] > bestmax:\n",
    "        bestmax = dic[l[0]]\n",
    "    \n",
    "print(max(dic.values()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7184\n"
     ]
    }
   ],
   "source": [
    "print(bestmax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 9\n",
    "Puzzle input: `day09.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11898\n"
     ]
    }
   ],
   "source": [
    "with open('day09.txt') as f:\n",
    "    inp = f.read().strip()\n",
    "    \n",
    "i = 0\n",
    "while i < len(inp):\n",
    "    if inp[i] == '!':\n",
    "        inp = inp[:i] + inp[i+2:]\n",
    "    else:\n",
    "        i += 1\n",
    "        \n",
    "garbage = 0        \n",
    "while '<' in inp:\n",
    "    inp = inp.split('<', maxsplit = 1)\n",
    "    g, inp[1] = inp[1].split('>', maxsplit = 1)\n",
    "    garbage += len(g)\n",
    "    inp = ''.join(inp)\n",
    "\n",
    "totscore = 0\n",
    "def score(s, x):\n",
    "    global totscore \n",
    "    if '{' in s and '}' in s:\n",
    "        s = s.split('{', maxsplit = 1)[1]\n",
    "        j = 1\n",
    "        while  s[:j].count('{') >= s[:j].count('}'):\n",
    "            j += 1\n",
    "        totscore += x + 1\n",
    "        score(s[:j-1], x + 1)\n",
    "        score(s[j:], x)\n",
    "\n",
    "score(inp, 0)\n",
    "print(totscore)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5601\n"
     ]
    }
   ],
   "source": [
    "print(garbage)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 10\n",
    "Puzzle input: `day10.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13760\n"
     ]
    }
   ],
   "source": [
    "with open('day10.txt') as f:\n",
    "    lengths = [int(x) for x in f.read().strip().split(',')]\n",
    "\n",
    "numbers = list(range(256))\n",
    "pos, skip = 0, 0\n",
    "\n",
    "for length in lengths:\n",
    "    if length > 256:\n",
    "        continue\n",
    "    new = numbers[pos:] + numbers[:pos]\n",
    "    new[:length] = new[:length][::-1]\n",
    "    numbers = new[256-pos:] + new[:256-pos]\n",
    "    pos = (pos + length + skip) % 256\n",
    "    skip += 1\n",
    "\n",
    "print(numbers[0] * numbers[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2da93395f1a6bb3472203252e3b17fe5\n"
     ]
    }
   ],
   "source": [
    "from operator import xor\n",
    "from functools import reduce\n",
    "\n",
    "with open('day10.txt') as f:\n",
    "    lengths = [ord(c) for c in f.read().strip()] + [17, 31, 73, 47, 23]\n",
    "\n",
    "numbers = list(range(256))\n",
    "pos, skip = 0, 0\n",
    "\n",
    "for rnd in range(64):\n",
    "    for length in lengths:\n",
    "        if length > 256:\n",
    "            continue\n",
    "        new = numbers[pos:] + numbers[:pos]\n",
    "        new[:length] = new[:length][::-1]\n",
    "        numbers = new[256-pos:] + new[:256-pos]\n",
    "        pos = (pos + length + skip) % 256\n",
    "        skip += 1\n",
    "\n",
    "numbers = [numbers[i:i+16] for i in range(0,241,16)]\n",
    "        \n",
    "print(''.join(\n",
    "        ('0' + hex(reduce(xor, n)))[-2:] \n",
    "        for n in numbers\n",
    "))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 11\n",
    "Puzzle input: `day11.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "759.0\n"
     ]
    }
   ],
   "source": [
    "from numpy.linalg import solve\n",
    "\n",
    "with open('day11.txt') as f:\n",
    "    steps = f.read().strip().split(',')\n",
    "    \n",
    "x, y = 0, 0\n",
    "furthest = 0\n",
    "cos30 = 3**.5 * .5\n",
    "\n",
    "def stepdist(x, y):\n",
    "    return min(\n",
    "        sum(sum(abs(x) for x in pt))\n",
    "        for pt in [\n",
    "            solve(A, [[x],[y]])\n",
    "            for A in [\n",
    "                [[0, cos30], \n",
    "                 [1,    .5]], \n",
    "                [[0, cos30], \n",
    "                 [1,   -.5]], \n",
    "                [[cos30, cos30], \n",
    "                 [   .5,   -.5]]\n",
    "            ]\n",
    "        ]\n",
    "    )\n",
    "\n",
    "for s in steps:\n",
    "    if len(s) == 1:\n",
    "        y += 1 if s == 'n' else -1\n",
    "    else:\n",
    "        x += cos30 * (1 if s[1] == 'e' else -1)\n",
    "        y +=    .5 * (1 if s[0] == 'n' else -1) \n",
    "    dist = stepdist(x, y)\n",
    "    if dist > furthest:\n",
    "        furthest = dist\n",
    "        \n",
    "print(stepdist(x,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1501.0\n"
     ]
    }
   ],
   "source": [
    "print(furthest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 12\n",
    "Puzzle input: `day12.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "113\n"
     ]
    }
   ],
   "source": [
    "with open('day12.txt') as f:\n",
    "    lines = [l.split('<->') for l in f.readlines()]\n",
    "\n",
    "cons = []\n",
    "\n",
    "for i in range(len(lines)):\n",
    "    m = int(lines[i][0].strip())\n",
    "    for n in lines[i][1].strip().split(','):\n",
    "        cons.append((m, int(n.strip())))\n",
    "\n",
    "group = {0}\n",
    "added = 1\n",
    "while added > 0:\n",
    "    news = {p[1] for p in cons if p[0] in group}\n",
    "    added = -len(group)\n",
    "    group = group | news\n",
    "    added += len(group)\n",
    "    \n",
    "print(len(group))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "202\n"
     ]
    }
   ],
   "source": [
    "groups = []\n",
    "remain = {c[0] for c in cons}\n",
    "\n",
    "while len(remain) > 0:\n",
    "    groups.append({remain.pop()})\n",
    "    added = 1\n",
    "    while added > 0:\n",
    "        news = {p[1] for p in cons if p[0] in groups[-1]}\n",
    "        added = -len(groups[-1])\n",
    "        groups[-1] = groups[-1] | news\n",
    "        added += len(groups[-1])\n",
    "        remain = remain - news\n",
    "\n",
    "print(len(groups))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 13\n",
    "Puzzle input: `day13.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2160\n"
     ]
    }
   ],
   "source": [
    "with open('day13.txt') as f:\n",
    "    lines = [l.split(':') for l in f.readlines()]\n",
    "\n",
    "depths = [int(l[0]) for l in lines]\n",
    "ranges = [int(l[1]) for l in lines]\n",
    "rangez = [2*r - 2 for r in ranges]\n",
    "pos = [d % r for d, r in zip(depths, rangez)]\n",
    "penalty = sum(\n",
    "    d * r\n",
    "    for d, r, p in zip(depths, ranges, pos) \n",
    "    if p == 0\n",
    ")\n",
    "print(penalty)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3907470\n"
     ]
    }
   ],
   "source": [
    "start = 0\n",
    "while 0 in [(d + start) % r for d, r in zip(depths, rangez)]:\n",
    "    start += 1\n",
    "print(start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 14\n",
    "Puzzle input: `ffayrhll`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8190\n"
     ]
    }
   ],
   "source": [
    "input = 'ffayrhll'\n",
    "\n",
    "from operator import xor\n",
    "from functools import reduce\n",
    "\n",
    "def binary(x):\n",
    "    b = '{0:0b}'.format(int(x,16))\n",
    "    return '0'*(4-len(b)) + b\n",
    "\n",
    "def knothash(s):\n",
    "    lengths = [ord(c) for c in s] + [17, 31, 73, 47, 23]\n",
    "    numbers = list(range(256))\n",
    "    pos, skip = 0, 0\n",
    "    for rnd in range(64):\n",
    "        for length in lengths:\n",
    "            new = numbers[pos:] + numbers[:pos]\n",
    "            new[:length] = new[:length][::-1]\n",
    "            numbers = new[256-pos:] + new[:256-pos]\n",
    "            pos = (pos + length + skip) % 256\n",
    "            skip += 1\n",
    "    numbers = [numbers[i:i+16] for i in range(0,241,16)]\n",
    "    h = ''\n",
    "    for n in numbers:\n",
    "        c = hex(reduce(xor, n))\n",
    "        c = c[c.index('x') + 1:]\n",
    "        h = h + '0'*(2-len(c)) + c\n",
    "    return h\n",
    "\n",
    "count = 0\n",
    "disk = []\n",
    "for row in range(128):\n",
    "    kh = knothash(input + '-' + str(row))\n",
    "    bs = ''.join(binary(c) for c in kh)\n",
    "    disk.append([int(b) for b in bs])\n",
    "    count += bs.count('1')\n",
    "\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1134\n"
     ]
    }
   ],
   "source": [
    "regions = [[-1] * 128 for _ in range(128)]\n",
    "\n",
    "maxr = -1\n",
    "for iteration in range(100):\n",
    "    for i in range(128):\n",
    "        for j in range(128):\n",
    "            if disk[i][j] == 1:\n",
    "                adj = []\n",
    "                if i > 0: adj.append(regions[i-1][j])\n",
    "                if j > 0: adj.append(regions[i][j-1])\n",
    "                if i < 127: adj.append(regions[i+1][j])\n",
    "                if j < 127: adj.append(regions[i][j+1])\n",
    "                m = [a for a in adj if a >= 0]\n",
    "                if len(m) > 0:\n",
    "                    m = min(m)\n",
    "                    if m < regions[i][j] or regions[i][j] < 0:\n",
    "                        regions[i][j] = m\n",
    "                elif regions[i][j] < 0:\n",
    "                    maxr += 1\n",
    "                    regions[i][j] = maxr\n",
    "\n",
    "regions = set(i for r in regions for i in r)\n",
    "print(len(regions) - 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 15\n",
    "Puzzle input: \n",
    "\n",
    "`Generator A starts with 618\n",
    " Generator B starts with 814`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "577\n"
     ]
    }
   ],
   "source": [
    "A, B = 618, 814\n",
    "\n",
    "def binary(x):\n",
    "    return '{0:0b}'.format(int(x % 2**16))\n",
    "\n",
    "count = 0\n",
    "for _ in range(40000000):\n",
    "    A = (A * 16807) % 2147483647\n",
    "    B = (B * 48271) % 2147483647\n",
    "    if binary(A) == binary(B):\n",
    "        count += 1\n",
    "\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "316\n"
     ]
    }
   ],
   "source": [
    "A, B = 618, 814\n",
    "\n",
    "count = 0\n",
    "for _ in range(5000000):    \n",
    "    A = (A * 16807) % 2147483647\n",
    "    while (A % 4) != 0: # There's probably a faster way... \n",
    "        A = (A * 16807) % 2147483647\n",
    "    B = (B * 48271) % 2147483647\n",
    "    while (B % 8) != 0: # ...since 2147483647 is prime.\n",
    "        B = (B * 48271) % 2147483647\n",
    "    if binary(A) == binary(B):\n",
    "        count += 1\n",
    "        \n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 16\n",
    "Puzzle input: `day16.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ehdpincaogkblmfj\n"
     ]
    }
   ],
   "source": [
    "with open('day16.txt') as f:\n",
    "    moves = f.readline().strip().split(',')\n",
    "\n",
    "dancers = 'abcdefghijklmnop'\n",
    "\n",
    "def move(d, m):\n",
    "    if m[0] == 's':\n",
    "        r = len(d) - int(m[1:])\n",
    "        return d[r:] + d[:r]\n",
    "    if m[0] == 'x':\n",
    "        r = [int(a) for a in m[1:].split('/')]\n",
    "        d = list(d)\n",
    "        d[r[0]], d[r[1]] = d[r[1]], d[r[0]]\n",
    "        return ''.join(d)\n",
    "    if m[0] == 'p':\n",
    "        r = [d.index(a) for a in m[1:].split('/')]\n",
    "        d = list(d)\n",
    "        d[r[0]], d[r[1]] = d[r[1]], d[r[0]]\n",
    "        return ''.join(d)  \n",
    "    \n",
    "for m in moves:\n",
    "    dancers = move(dancers, m)\n",
    "            \n",
    "print(dancers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cycle length 48\n",
      "Solution: bpcekomfgjdlinha\n"
     ]
    }
   ],
   "source": [
    "dancers = 'abcdefghijklmnop'\n",
    "newdancers = dancers\n",
    "cnt = 0\n",
    "\n",
    "while cnt == 0 or newdancers != dancers:\n",
    "    cnt += 1\n",
    "    for m in moves:\n",
    "        newdancers = move(newdancers, m)\n",
    "\n",
    "print('Cycle length', cnt)\n",
    "\n",
    "for _ in range(1000000000 % cnt):\n",
    "    for m in moves:\n",
    "        dancers = move(dancers, m)\n",
    "        \n",
    "print('Solution:', dancers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 17\n",
    "Puzzle input: `329`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "725\n"
     ]
    }
   ],
   "source": [
    "input = 329\n",
    "i = 0\n",
    "lock = [0]\n",
    "for n in range(1, 2018):\n",
    "    i = (i + input + 1) % n\n",
    "    lock.insert(i, n)\n",
    "\n",
    "print(lock[lock.index(2017) + 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27361412\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "bef = 0\n",
    "curr = 1\n",
    "for n in range(2, 50000001):\n",
    "    i = (i + input + 1) % n\n",
    "    if i < bef + 1:\n",
    "        bef += 1\n",
    "    elif i == bef + 1:\n",
    "        curr = n\n",
    "        \n",
    "print(curr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 18\n",
    "Puzzle input: `day18.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3423\n"
     ]
    }
   ],
   "source": [
    "with open('day18.txt') as f:\n",
    "    lines = [l.strip().split() for l in f.readlines()]\n",
    "\n",
    "var = defaultdict(int)\n",
    "\n",
    "def val(x):\n",
    "    try:\n",
    "        return int(x)\n",
    "    except:\n",
    "        return var[x]\n",
    "\n",
    "i = 0\n",
    "while i < len(lines):\n",
    "    l = lines[i]\n",
    "    if l[0] == 'set':\n",
    "        var[l[1]] = val(l[2])\n",
    "    if l[0] == 'add':\n",
    "        var[l[1]] += val(l[2])\n",
    "    if l[0] == 'mul':\n",
    "        var[l[1]] *= val(l[2])\n",
    "    if l[0] == 'mod':\n",
    "        var[l[1]] %= val(l[2])\n",
    "    if l[0] == 'snd':\n",
    "        var['lastplayed'] = val(l[1])\n",
    "    if l[0] == 'rcv' and val(l[1]) > 0:\n",
    "        print(var['lastplayed'])\n",
    "        break\n",
    "    if l[0] == 'jgz' and val(l[1]) > 0:\n",
    "        i += val(l[2])\n",
    "    else:\n",
    "        i += 1\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7493\n"
     ]
    }
   ],
   "source": [
    "class program:\n",
    "    def __init__(self, id):\n",
    "        self.var = defaultdict(int)\n",
    "        self.var['p'] = id\n",
    "        self.i = 0\n",
    "        self.received = []\n",
    "        \n",
    "    def val(self, x):\n",
    "        try: return int(x)\n",
    "        except: return self.var[x]\n",
    "\n",
    "    def run(self, inp = []):\n",
    "        self.received += inp\n",
    "        to_send = []\n",
    "        while self.i < len(lines):\n",
    "            l = lines[self.i]\n",
    "            if l[0] == 'set': self.var[l[1]] = self.val(l[2])\n",
    "            if l[0] == 'add': self.var[l[1]] += self.val(l[2])\n",
    "            if l[0] == 'mul': self.var[l[1]] *= self.val(l[2])\n",
    "            if l[0] == 'mod': self.var[l[1]] %= self.val(l[2])\n",
    "            if l[0] == 'snd': to_send.append(self.val(l[1]))\n",
    "            if l[0] == 'rcv':\n",
    "                try: self.var[l[1]] = self.received.pop(0)\n",
    "                except: break\n",
    "            if l[0] == 'jgz' and self.val(l[1]) > 0: self.i += self.val(l[2])\n",
    "            else: self.i += 1\n",
    "        return to_send\n",
    "        \n",
    "prog0 = program(0)\n",
    "prog1 = program(1)\n",
    "\n",
    "cnt = 0\n",
    "trade = prog0.run()\n",
    "while len(trade) > 0:\n",
    "    trade = prog1.run(trade)\n",
    "    cnt += len(trade)\n",
    "    trade = prog0.run(trade)\n",
    "    \n",
    "print(cnt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 19\n",
    "Puzzle input: `day19.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EOCZQMURF\n"
     ]
    }
   ],
   "source": [
    "with open('day19.txt') as f:\n",
    "    diagram = [l.strip('\\n') for l in f.readlines()]\n",
    "\n",
    "i, j = 0, diagram[0].index('|')\n",
    "ds = [(1,0)]\n",
    "letters = []\n",
    "\n",
    "cnt = 1\n",
    "while len(ds) > 0:\n",
    "    di, dj = ds[0]\n",
    "    i, j = i + di, j + dj\n",
    "    if diagram[i][j] in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':\n",
    "        letters.append(diagram[i][j])\n",
    "    ds = [(di, dj), (dj, -di), (-dj, di)]\n",
    "    if diagram[i][j] == '+': ds.pop(0)\n",
    "    ds = [\n",
    "        d for d in ds \n",
    "        if  0 <= i+d[0] < len(diagram)\n",
    "        and 0 <= j+d[1] < len(diagram[i+d[0]])\n",
    "    ]\n",
    "    ds = [d for d in ds if diagram[i+d[0]][j+d[1]] != ' ']\n",
    "    cnt += 1\n",
    "    \n",
    "print(''.join(letters))        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16312\n"
     ]
    }
   ],
   "source": [
    "print(cnt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 20\n",
    "Puzzle input: `day20.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "125\n"
     ]
    }
   ],
   "source": [
    "with open('day20.txt') as f:\n",
    "    lines = [l.strip() for l in f.readlines()]\n",
    "\n",
    "pos, vel, acc = [], [], []\n",
    "for l in lines:\n",
    "    exec(l.replace('<','[').replace('>,','];').replace('>',']'))\n",
    "    pos.append(p)\n",
    "    vel.append(v)\n",
    "    acc.append(a)\n",
    "\n",
    "for _ in range(1000):\n",
    "    for i in range(len(pos)):\n",
    "        vel[i] = [v+a for (v,a) in zip(vel[i],acc[i])] \n",
    "        pos[i] = [p+v for (p,v) in zip(pos[i],vel[i])] \n",
    "\n",
    "dists = [sum(abs(x) for x in p) for p in pos]\n",
    "\n",
    "print(dists.index(min(dists)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "461\n"
     ]
    }
   ],
   "source": [
    "pos, vel, acc = [], [], []\n",
    "for l in lines:\n",
    "    exec(l.replace('<','[').replace('>,','];').replace('>',']'))\n",
    "    pos.append(p)\n",
    "    vel.append(v)\n",
    "    acc.append(a)\n",
    "\n",
    "for _ in range(1000):\n",
    "    collide = set([])\n",
    "    for i in range(len(pos)):\n",
    "        vel[i] = [v+a for (v,a) in zip(vel[i],acc[i])] \n",
    "        pos[i] = [p+v for (p,v) in zip(pos[i],vel[i])] \n",
    "        if pos[i] in pos[:i]:\n",
    "            collide.add(i)\n",
    "            collide.add(pos[:i].index(pos[i]))\n",
    "    for i in sorted(list(collide))[::-1]:\n",
    "        pos.pop(i)\n",
    "        vel.pop(i)\n",
    "        acc.pop(i)\n",
    "\n",
    "print(len(pos))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 21\n",
    "Puzzle input: `day21.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "164\n"
     ]
    }
   ],
   "source": [
    "with open('day21.txt') as f:\n",
    "    lines = [l.strip() for l in f.readlines()]\n",
    "\n",
    "pattern = '.#./..#/###'\n",
    "\n",
    "rules = dict()\n",
    "for l in lines:\n",
    "    (key, val) = l.split(' => ')\n",
    "    rules[key] = val\n",
    "    \n",
    "def rotate(p):\n",
    "    temp = p.split('/')\n",
    "    temp2 = []\n",
    "    for i in range(len(temp[0])):\n",
    "        temp2.append([t[i] for t in temp[::-1]])\n",
    "    return '/'.join(''.join(t) for t in temp2)\n",
    "\n",
    "def fliplr(p):\n",
    "    temp = []\n",
    "    for t in p.split('/'):\n",
    "        temp.append(t[::-1])\n",
    "    return '/'.join(''.join(t) for t in temp)\n",
    "    \n",
    "def flipud(p):\n",
    "    temp = p.split('/')[::-1]\n",
    "    return '/'.join(''.join(t) for t in temp)\n",
    "\n",
    "def join(g):\n",
    "    if len(g) == 1:\n",
    "        return g[0]\n",
    "    temp = [p.split('/') for p in g]\n",
    "    m = len(temp[0])\n",
    "    n = 1\n",
    "    while n**2 != len(g): n += 1\n",
    "    out = []\n",
    "    for row in range(m*n):\n",
    "        out.append(''.join([\n",
    "            t[row % m] \n",
    "            for t in temp[(row // m) * n: (row // m) * n + n]\n",
    "        ]))\n",
    "    return '/'.join(out)\n",
    "\n",
    "def brek(p):\n",
    "    temp = p.split('/')\n",
    "    n = len(temp)\n",
    "    g = []\n",
    "    if n % 2 == 0:\n",
    "        for i in range(0,n,2):\n",
    "            for j in range(0,n,2):\n",
    "                g.append(\n",
    "                    temp[i][j:j+2] + '/' + \n",
    "                    temp[i+1][j:j+2]\n",
    "                )\n",
    "    else:\n",
    "        for i in range(0,n,3):\n",
    "            for j in range(0,n,3):\n",
    "                g.append(\n",
    "                    temp[i][j:j+3] + '/' + \n",
    "                    temp[i+1][j:j+3] + '/' + \n",
    "                    temp[i+2][j:j+3]\n",
    "                )\n",
    "    return g\n",
    "\n",
    "def enhance(p):\n",
    "    grid = brek(p)\n",
    "    newgrid = []\n",
    "    for g in grid:\n",
    "        for key in [g, flipud(g), fliplr(g), rotate(g), rotate(fliplr(g))]:\n",
    "            if key in rules:\n",
    "                newgrid.append(rules[key])\n",
    "                break\n",
    "        else: print('OH NO!!!')\n",
    "    return join(newgrid)\n",
    "\n",
    "for _ in range(5): \n",
    "    pattern = enhance(pattern)\n",
    "    \n",
    "print(pattern.count('#'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2355110\n"
     ]
    }
   ],
   "source": [
    "for _ in range(13): \n",
    "    pattern = enhance(pattern)\n",
    "    \n",
    "print(pattern.count('#'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 22\n",
    "Puzzle input: `day22.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5447\n"
     ]
    }
   ],
   "source": [
    "with open('day22.txt') as f:\n",
    "    lines = [list(l.strip()) for l in f.readlines()]\n",
    "\n",
    "grid = defaultdict(lambda: '.')\n",
    "for (i, l) in enumerate(lines):\n",
    "    for (j, c) in enumerate(l):\n",
    "        grid[(i,j)] = c\n",
    "\n",
    "i, j = len(lines)//2, len(lines)//2\n",
    "di, dj = -1, 0\n",
    "cnt = 0\n",
    "\n",
    "for iter in range(10000):\n",
    "    if grid[(i,j)] == '#': \n",
    "        dj, di = -di, dj\n",
    "        grid[(i,j)] = '.'\n",
    "    else: \n",
    "        dj, di = di, -dj\n",
    "        grid[(i,j)] = '#'\n",
    "        cnt += 1\n",
    "    i += di\n",
    "    j += dj\n",
    "    \n",
    "print(cnt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2511705\n"
     ]
    }
   ],
   "source": [
    "with open('day22.txt') as f:\n",
    "    lines = [list(l.strip()) for l in f.readlines()]\n",
    "\n",
    "grid = defaultdict(lambda: '.')\n",
    "for (i, l) in enumerate(lines):\n",
    "    for (j, c) in enumerate(l):\n",
    "        grid[(i,j)] = c\n",
    "\n",
    "i, j = len(lines)//2, len(lines)//2\n",
    "di, dj = -1, 0\n",
    "cnt = 0\n",
    "\n",
    "for iter in range(10000000):\n",
    "    if grid[(i,j)] == '#': \n",
    "        dj, di = -di, dj\n",
    "        grid[(i,j)] = 'F'\n",
    "    elif grid[(i,j)] == '.': \n",
    "        dj, di = di, -dj\n",
    "        grid[(i,j)] = 'W'\n",
    "    elif grid[(i,j)] == 'W': \n",
    "        grid[(i,j)] = '#'\n",
    "        cnt += 1\n",
    "    elif grid[(i,j)] == 'F': \n",
    "        dj, di = -dj, -di\n",
    "        grid[(i,j)] = '.'\n",
    "    i += di\n",
    "    j += dj\n",
    "    \n",
    "print(cnt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 23\n",
    "Puzzle input: `day23.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6724\n"
     ]
    }
   ],
   "source": [
    "with open('day23.txt') as f: \n",
    "    lines = [l.strip().split() for l in f.readlines()]\n",
    "    \n",
    "var = defaultdict(int)\n",
    "\n",
    "def val(x):\n",
    "    try: return int(x)\n",
    "    except: return var[x]\n",
    "\n",
    "i, cnt = 0, 0\n",
    "while i < len(lines):\n",
    "    l = lines[i]\n",
    "    if l[0] == 'set': var[l[1]] = val(l[2])\n",
    "    if l[0] == 'sub': var[l[1]] -= val(l[2])\n",
    "    if l[0] == 'mul':\n",
    "        var[l[1]] *= val(l[2])\n",
    "        cnt += 1\n",
    "    if l[0] == 'jnz' and val(l[1]) != 0: i += val(l[2])\n",
    "    else: i += 1\n",
    "        \n",
    "print(cnt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "903\n"
     ]
    }
   ],
   "source": [
    "h = 0\n",
    "for b in range(108400, 125401, 17): \n",
    "    f = 1\n",
    "    for d in range(2, int(b**.5)): \n",
    "        e = b // d\n",
    "        if b == d * e: \n",
    "            f = 0\n",
    "            break\n",
    "    if f == 0: h += 1\n",
    "        \n",
    "print(h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 24\n",
    "Puzzle input: `day24.txt`\n",
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1940\n"
     ]
    }
   ],
   "source": [
    "with open('day24.txt') as f: \n",
    "    comps = [[int(x) for x in l.strip().split('/')] for l in f.readlines()]\n",
    "    \n",
    "def strength(b): return sum(sum(c) for c in b)\n",
    "def nexts(b, c): \n",
    "    return [\n",
    "        x if x[0] == b[-1][1] else x[::-1] \n",
    "        for x in c if b[-1][1] in x\n",
    "    ]\n",
    "    \n",
    "avl = [x.copy() for x in comps]\n",
    "brg = [[0,0]]\n",
    "nxt = [nexts(brg, avl)]\n",
    "best = 0\n",
    "\n",
    "while len(brg) > 0 and len(nxt[-1]) > 0:\n",
    "    n = nxt[-1].pop()\n",
    "    brg.append(n)\n",
    "    try: avl.pop(avl.index(n))\n",
    "    except: avl.pop(avl.index(n[::-1]))\n",
    "    nxt.append(nexts(brg, avl))\n",
    "    if strength(brg) > best: best = strength(brg)\n",
    "    while (len(nxt[-1]) == 0 or len(avl) == 0):\n",
    "        nxt.pop()\n",
    "        avl.append(brg.pop())\n",
    "        if len(brg) == 1:\n",
    "            break\n",
    "            \n",
    "print(best)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1928\n"
     ]
    }
   ],
   "source": [
    "avl = [x.copy() for x in comps]\n",
    "brg = [[0,0]]\n",
    "nxt = [nexts(brg, avl)]\n",
    "best = 0\n",
    "bestlen = 0\n",
    "\n",
    "while len(brg) > 0 and len(nxt[-1]) > 0:\n",
    "    n = nxt[-1].pop()\n",
    "    brg.append(n)\n",
    "    try: avl.pop(avl.index(n))\n",
    "    except: avl.pop(avl.index(n[::-1]))\n",
    "    nxt.append(nexts(brg, avl))\n",
    "    if strength(brg) > best and len(brg) - 1 >= bestlen: \n",
    "        best, bestlen = strength(brg), len(brg) - 1\n",
    "    while (len(nxt[-1]) == 0 or len(avl) == 0):\n",
    "        nxt.pop()\n",
    "        avl.append(brg.pop())\n",
    "        if len(brg) == 1:\n",
    "            break\n",
    "            \n",
    "print(best)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 25\n",
    "Puzzle input: `day25.txt`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "################\n",
      "### THE CODE ###\n",
      "################\n",
      "\n",
      "for _ in range(steps):\n",
      "   \n",
      "   if state == 'A':\n",
      "      if tape[pos] == 0:\n",
      "         tape[pos] = 1\n",
      "         pos += 1\n",
      "         state = 'B'; continue\n",
      "      if tape[pos] == 1:\n",
      "         tape[pos] = 0\n",
      "         pos += -1\n",
      "         state = 'B'; continue\n",
      "   \n",
      "   if state == 'B':\n",
      "      if tape[pos] == 0:\n",
      "         tape[pos] = 1\n",
      "         pos += -1\n",
      "         state = 'C'; continue\n",
      "      if tape[pos] == 1:\n",
      "         tape[pos] = 0\n",
      "         pos += 1\n",
      "         state = 'E'; continue\n",
      "   \n",
      "   if state == 'C':\n",
      "      if tape[pos] == 0:\n",
      "         tape[pos] = 1\n",
      "         pos += 1\n",
      "         state = 'E'; continue\n",
      "      if tape[pos] == 1:\n",
      "         tape[pos] = 0\n",
      "         pos += -1\n",
      "         state = 'D'; continue\n",
      "   \n",
      "   if state == 'D':\n",
      "      if tape[pos] == 0:\n",
      "         tape[pos] = 1\n",
      "         pos += -1\n",
      "         state = 'A'; continue\n",
      "      if tape[pos] == 1:\n",
      "         tape[pos] = 1\n",
      "         pos += -1\n",
      "         state = 'A'; continue\n",
      "   \n",
      "   if state == 'E':\n",
      "      if tape[pos] == 0:\n",
      "         tape[pos] = 0\n",
      "         pos += 1\n",
      "         state = 'A'; continue\n",
      "      if tape[pos] == 1:\n",
      "         tape[pos] = 0\n",
      "         pos += 1\n",
      "         state = 'F'; continue\n",
      "   \n",
      "   if state == 'F':\n",
      "      if tape[pos] == 0:\n",
      "         tape[pos] = 1\n",
      "         pos += 1\n",
      "         state = 'E'; continue\n",
      "      if tape[pos] == 1:\n",
      "         tape[pos] = 1\n",
      "         pos += 1\n",
      "         state = 'A'; continue\n",
      "\n",
      "\n",
      "####################\n",
      "### THE CHECKSUM ###\n",
      "####################\n",
      "\n",
      "3554\n"
     ]
    }
   ],
   "source": [
    "with open('day25.txt') as f: \n",
    "    lines = [l.strip() for l in f.readlines()]\n",
    "\n",
    "tape = defaultdict(int)\n",
    "pos = 0\n",
    "state = lines[0].split(' ')[-1].strip('.')\n",
    "steps = int(lines[1].strip('.').split(' ')[-2])\n",
    "\n",
    "lines = lines[2:]\n",
    "for i,l in enumerate(lines):\n",
    "    if len(l) == 0: continue\n",
    "    if l.startswith('In state'):\n",
    "        lines[i] = \"if state == '%s':\" % (l.strip(':').split(' ')[-1])\n",
    "    else:\n",
    "        l = '   ' + l.replace('- ', '   ').strip('.')\n",
    "        l = l.replace('If the current value is', 'if tape[pos] ==')\n",
    "        l = l.replace('Write the value', 'tape[pos] =')\n",
    "        l = l.replace('Move one slot to the ', 'pos += ')\n",
    "        l = l.replace('right', '1').replace('left', '-1')\n",
    "        if 'Continue with state' in l:\n",
    "            l = l.replace(\"Continue with state \", \"state = '\") + \"'; continue\"\n",
    "        lines[i] = l\n",
    "\n",
    "lines = ['   ' + l for l in lines]\n",
    "lines.insert(0, 'for _ in range(steps):')\n",
    "\n",
    "print('################\\n### THE CODE ###\\n################\\n')\n",
    "print('\\n'.join(lines))\n",
    "exec('\\n'.join(lines))\n",
    "print('\\n\\n####################\\n### THE CHECKSUM ###\\n####################\\n')\n",
    "print(sum(tape.values()))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}