Advent of Code 2017 - Python.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import copy\n",
    "from collections import deque "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1203\n",
      "1146\n"
     ]
    }
   ],
   "source": [
    "#Q1.a\n",
    "def soln_1a(inp):\n",
    "    inp = str(inp)\n",
    "    return(sum([int(item) for (i,item) in enumerate(inp) if item == inp[(i+1)%len(inp)]]))\n",
    "\n",
    "f = open('inputs/1a.txt')\n",
    "inp = int(f.read())\n",
    "\n",
    "print(soln_1a(inp))\n",
    "\n",
    "#Q1.b\n",
    "def soln_1b(inp):\n",
    "    inp = str(inp)\n",
    "    step = int(len(inp)/2)\n",
    "    return(sum([int(item) for (i,item) in enumerate(inp) if item == inp[(i+step)%len(inp)]]))\n",
    "\n",
    "print(soln_1b(inp))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "36174\n",
      "244\n"
     ]
    }
   ],
   "source": [
    "#Q2.a\n",
    "f = open('inputs/2.txt')\n",
    "diff =[]\n",
    "for line in f:\n",
    "    mylist = line.split()\n",
    "    mylist = [int(item) for item in mylist]\n",
    "    diff.append(max(mylist) - min(mylist))\n",
    "    \n",
    "print(sum(diff))\n",
    "\n",
    "#Q2.b\n",
    "\n",
    "def evenlyDivide(mylist):\n",
    "    mylist.sort()\n",
    "    for i, item in enumerate(mylist):\n",
    "        for j in range(i+1,len(mylist)):\n",
    "            if mylist[j] % item == 0:\n",
    "                return(int(mylist[j]/item))\n",
    "\n",
    "f = open('inputs/2.txt')\n",
    "res_div =[]\n",
    "for line in f:\n",
    "    mylist = line.split()\n",
    "    mylist = [int(item) for item in mylist]\n",
    "    res_div.append(evenlyDivide(mylist))\n",
    "\n",
    "print(sum(res_div))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "419\n",
      "295229\n"
     ]
    }
   ],
   "source": [
    "#Q3.a\n",
    "\n",
    "def find_coordinate(inp):\n",
    "    if inp == 1:\n",
    "        return([0,0])\n",
    "    n = 0 \n",
    "    while inp > (2*n +1)**2:\n",
    "        n += 1\n",
    "\n",
    "    r = (2*n +1)**2 - inp\n",
    "\n",
    "    if r//(2*n) == 0:\n",
    "        return([n-r%(2*n),-n])\n",
    "    elif r//(2*n) == 1:\n",
    "        return([-n,-n+r%(2*n)])\n",
    "    elif r//(2*n) == 2:\n",
    "        return([-n+r%(2*n),n])\n",
    "    else:\n",
    "        return([n,n-r%(2*n)])\n",
    "    \n",
    "\n",
    "f = open('inputs/3.txt')\n",
    "inp = int(f.read())    \n",
    "coord = find_coordinate(inp)\n",
    "\n",
    "print(sum([abs(item) for item in coord]))\n",
    "\n",
    "#Q3.b\n",
    "def neighbors(tpl):\n",
    "    tpl_neighbors = [(tpl[0]-1, tpl[1]-1), (tpl[0], tpl[1]-1), (tpl[0]+1, tpl[1]-1), \n",
    "                     (tpl[0]-1, tpl[1]+1), (tpl[0], tpl[1]+1), (tpl[0]+1, tpl[1]+1), \n",
    "                     (tpl[0]-1, tpl[1]), (tpl[0]+1, tpl[1])]\n",
    "    return(tpl_neighbors)\n",
    "    \n",
    "def find_tpl_value(matrix, tpl):\n",
    "    tpl_value = 0\n",
    "    for item in neighbors(tpl):\n",
    "        if item in matrix:\n",
    "            tpl_value += matrix[item]\n",
    "    return(tpl_value)\n",
    "\n",
    "matrix = {}\n",
    "matrix[(0,0)]=1\n",
    "tpl_value = 1\n",
    "i = 2\n",
    "\n",
    "f = open('inputs/3.txt')\n",
    "inp = int(f.read())  \n",
    "\n",
    "while tpl_value < inp:\n",
    "    tpl = tuple(find_coordinate(i))\n",
    "    tpl_value = find_tpl_value(matrix, tpl)\n",
    "    matrix[tpl] = tpl_value\n",
    "    i += 1\n",
    "    \n",
    "print(tpl_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "325\n",
      "119\n"
     ]
    }
   ],
   "source": [
    "#Q4.a\n",
    "f = open('inputs/4.txt')\n",
    "\n",
    "no_valid = 0\n",
    "for line in f:\n",
    "    a = line.strip().split(\" \")\n",
    "    if len(a) == len(set(a)):\n",
    "        no_valid += 1\n",
    "print(no_valid)\n",
    "\n",
    "#Q4.b\n",
    "f = open('inputs/4.txt')\n",
    "\n",
    "no_valid = 0\n",
    "for line in f:\n",
    "    a = line.strip().split(\" \")\n",
    "    b = [tuple(sorted(list(item))) for item in a]\n",
    "    if len(b) == len(set(b)):\n",
    "        no_valid += 1\n",
    "print(no_valid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "343467\n",
      "24774780\n"
     ]
    }
   ],
   "source": [
    "#Q5.a\n",
    "f = open('inputs/5.txt')\n",
    "inp = f.read()\n",
    "inp = inp.split('\\n')\n",
    "inp = [int(item) for item in inp]\n",
    "\n",
    "cursor = 0\n",
    "steps = 0\n",
    "end = len(inp)\n",
    "\n",
    "while cursor < end:\n",
    "    steps += 1\n",
    "    inp[cursor] += 1\n",
    "    cursor += inp[cursor] -1\n",
    "    \n",
    "print(steps)\n",
    "\n",
    "#Q5.b\n",
    "f = open('inputs/5.txt')\n",
    "inp = f.read()\n",
    "inp = inp.split('\\n')\n",
    "inp = [int(item) for item in inp]\n",
    "\n",
    "cursor = 0\n",
    "steps = 0\n",
    "end = len(inp)\n",
    "\n",
    "while cursor < end:\n",
    "    steps += 1\n",
    "    dummy = inp[cursor]\n",
    "    if inp[cursor] > 2:\n",
    "        inp[cursor] -= 1\n",
    "    else:\n",
    "        inp[cursor] += 1\n",
    "    cursor += dummy\n",
    "    \n",
    "print(steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6681\n",
      "2392\n"
     ]
    }
   ],
   "source": [
    "#Q6.a\n",
    "\n",
    "def find_steps(inp):\n",
    "\n",
    "    inp_dict = {} \n",
    "    steps = 0\n",
    "    length = len(inp)\n",
    "\n",
    "    while (tuple(inp) not in inp_dict) or (steps == 0):\n",
    "        inp_dict[tuple(inp)] = steps\n",
    "        steps += 1\n",
    "        value_max = max(inp)\n",
    "        ind_max = np.argmax(inp)\n",
    "        inp[ind_max] = 0\n",
    "\n",
    "        inp = [item + value_max//length for item in inp]\n",
    "\n",
    "        i = ind_max\n",
    "        j = value_max%length\n",
    "        while j > 0:\n",
    "            inp[(i+1)%length] += 1\n",
    "            i += 1\n",
    "            j -=1\n",
    "    return(steps, inp_dict[tuple(inp)])\n",
    "\n",
    "\n",
    "f = open('inputs/6.txt')\n",
    "inp = f.read()\n",
    "inp = inp.split('\\t')\n",
    "inp = [int(item) for item in inp]\n",
    "\n",
    "print(find_steps(inp)[0])\n",
    "\n",
    "#Q6.b\n",
    "f = open('inputs/6.txt')\n",
    "inp = f.read()\n",
    "inp = inp.split('\\t')\n",
    "inp = [int(item) for item in inp]\n",
    "\n",
    "(a,b) = find_steps(inp)\n",
    "print(a-b)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 381,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mwzaxaj\n",
      "ljaktj\n",
      "['seeqikh', 'mqrfbqc', 'ihnus']\n",
      "[15153, 15153, 15160]\n",
      "[10944, 9769, 40]\n",
      "ihnus\n",
      "['vrgxe', 'shnqfh', 'auzded', 'hkhsc', 'jwddn', 'mcxki', 'lhwyt']\n",
      "[2166, 2159, 2159, 2159, 2159, 2159, 2159]\n",
      "[1226, 1649, 499, 171, 134, 29, 287]\n",
      "mwzaxaj\n",
      "['csybv', 'febjzqn', 'bltmlm', 'dfyyjta', 'ljaktj', 'vmyda', 'vbcfe']\n",
      "[67398, 67398, 67398, 67398, 67405, 67398, 67398]\n",
      "[33546, 46461, 93, 33822, 21939, 63912, 49938]\n"
     ]
    }
   ],
   "source": [
    "#Q7.a\n",
    "f = open('inputs/7.txt')\n",
    "\n",
    "prog_dict = {}\n",
    "weight_dict = {}\n",
    "\n",
    "for line in f:\n",
    "    a = line.strip().split(\" -> \")\n",
    "    weight_dict[a[0].split(' ')[0]] = int(a[0].split(' ')[1][1:-1])\n",
    "    \n",
    "\n",
    "f = open('inputs/7.txt')\n",
    "for line in f:\n",
    "    a = line.strip().split(\" -> \")\n",
    "    if len(a)>1:\n",
    "        for prog in a[1].split(', '):\n",
    "            prog_dict[(prog, weight_dict[prog])] = (a[0].split(' ')[0], weight_dict[a[0].split(' ')[0]])\n",
    "\n",
    "\n",
    "prog = line.strip().split(\" -> \")[0].split(' ')[0]            \n",
    "while (prog, weight_dict[prog]) in prog_dict:\n",
    "    prog = prog_dict[(prog,weight_dict[prog])][0]\n",
    "print(prog)\n",
    "\n",
    "#Q7.b\n",
    "weight_dict_final = copy.deepcopy(weight_dict)\n",
    "\n",
    "for item in weight_dict:\n",
    "    original_item = item\n",
    "    while (item, weight_dict[item]) in prog_dict:\n",
    "        parent = prog_dict[(item, weight_dict[item])]\n",
    "        weight_dict_final[parent[0]] += weight_dict[original_item]\n",
    "        item = parent[0]\n",
    "\n",
    "        \n",
    "for prog in weight_dict_final:\n",
    "    child_weights = [ weight_dict_final[item[0]] for item in prog_dict if prog_dict[item][0] == prog]\n",
    "    \n",
    "    if len(set(child_weights))>1:\n",
    "        print(prog)\n",
    "        print([ item[0] for item in prog_dict if prog_dict[item][0] == prog])\n",
    "        print(child_weights)\n",
    "        print([ weight_dict[item[0]] for item in prog_dict if prog_dict[item][0] == prog])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4066\n",
      "4829\n"
     ]
    }
   ],
   "source": [
    "#Q8.a\n",
    "regs = {}\n",
    "max_value = []\n",
    "\n",
    "gt = lambda (x,y): x > y\n",
    "lt = lambda (x,y): x < y\n",
    "ge = lambda (x,y): x >= y\n",
    "le = lambda (x,y): x <= y\n",
    "eq = lambda (x,y): x == y\n",
    "ne = lambda (x,y): x != y\n",
    "ops= {'>':gt, '<':lt, '>=':ge, '<=': le, '==':eq, '!=': ne }\n",
    "\n",
    "inc = lambda (x,y): x + y\n",
    "dec = lambda (x,y): x - y\n",
    "acts = {'inc':inc, 'dec': dec }\n",
    "\n",
    "\n",
    "f = open('inputs/8.txt')\n",
    "for line in f:    \n",
    "    line = line.strip().split(' ')\n",
    "\n",
    "    if line[0] not in regs:\n",
    "        regs[line[0]] = 0\n",
    "    if line[4] not in regs:\n",
    "        regs[line[4]] = 0\n",
    "    if ops[line[5]]([regs[line[4]], int(line[6])]):\n",
    "        regs[line[0]] = acts[line[1]]([regs[line[0]], int(line[2])])\n",
    "        \n",
    "    max_value.append(max([regs[item] for item in regs]))\n",
    "        \n",
    "print(max_value[-1])\n",
    "\n",
    "#Q8.b\n",
    "\n",
    "print(max(max_value))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23588\n",
      "10045\n"
     ]
    }
   ],
   "source": [
    "#Q9.a\n",
    "f = open('inputs/9.txt')\n",
    "inp = f.read()\n",
    "inp_list = list(inp)\n",
    "\n",
    "garbage_counter = 0\n",
    "\n",
    "i = 0\n",
    "while i < len(inp_list):\n",
    "    if inp_list[i] == '!':\n",
    "        del(inp_list[i])\n",
    "        del(inp_list[i])\n",
    "    else:\n",
    "        i += 1\n",
    "\n",
    "i = 0\n",
    "while i < len(inp_list):\n",
    "    if inp_list[i] == '<':\n",
    "        garbage_cntr_local = -1\n",
    "        while inp_list[i] != '>':\n",
    "            garbage_cntr_local += 1\n",
    "            del(inp_list[i])\n",
    "        garbage_counter += garbage_cntr_local\n",
    "        del(inp_list[i])\n",
    "    else:\n",
    "        i += 1\n",
    "\n",
    "par_point = 1\n",
    "i = 0\n",
    "total = 0\n",
    "while i < len(inp_list):\n",
    "    if inp_list[i] == '{':\n",
    "        total += par_point\n",
    "        par_point += 1\n",
    "    elif inp_list[i] == '}':\n",
    "        par_point -= 1\n",
    "    i += 1\n",
    "    \n",
    "print(total)\n",
    "\n",
    "#Q9.b\n",
    "print(garbage_counter)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19591\n",
      "62e2204d2ca4f4924f6e7a80f1288786\n"
     ]
    }
   ],
   "source": [
    "#Q10.a\n",
    "\n",
    "f = open('inputs/10.txt')\n",
    "inp = f.read()\n",
    "inp = inp.split(',')\n",
    "inp = [int(item) for item in inp]\n",
    "\n",
    "\n",
    "\n",
    "def knot_hash_round(mylist, index, skip_size, inp):\n",
    "    length = len(mylist)\n",
    "    for item in inp:\n",
    "        sub_list = []\n",
    "\n",
    "        for i in range(item):\n",
    "            sub_list.append(mylist[(index + i)%length])\n",
    "\n",
    "        sub_list.reverse()\n",
    "\n",
    "        i = 0\n",
    "        for i in range(item):\n",
    "            mylist[(index + i)%len(mylist)] =  sub_list[i]\n",
    "\n",
    "        index = (item + index + skip_size)%length\n",
    "        skip_size += 1\n",
    "        \n",
    "    return([mylist, index, skip_size])\n",
    "\n",
    "\n",
    "\n",
    "skip_size = 0\n",
    "index = 0\n",
    "mylist = [item for item in range(0,256)]\n",
    "\n",
    "one_round_knot = knot_hash_round(mylist ,index, skip_size, inp)\n",
    "print(one_round_knot[0][0] * one_round_knot[0][1])  \n",
    "\n",
    "\n",
    "#Q10.b\n",
    "def xor_list(mylist):\n",
    "    res = 0\n",
    "    for item in mylist:\n",
    "        res = res ^ item\n",
    "    return(res)\n",
    "\n",
    "def myhex(intg):\n",
    "    res = hex(intg)\n",
    "    res = list(res)\n",
    "    i = 0\n",
    "    while res[i] != 'x':\n",
    "        del(res[i])\n",
    "    del(res[i])\n",
    "    \n",
    "    if len(res) > 1:\n",
    "        return(''.join(res))\n",
    "    else:\n",
    "        return('0'+''.join(res))\n",
    "    \n",
    "def knothash(inp):\n",
    "    \n",
    "    inp_ascii = [ord(s) for s in inp]\n",
    "    salt = [17, 31, 73, 47, 23]\n",
    "    inp_new = inp_ascii + salt\n",
    "    \n",
    "    skip_size = 0\n",
    "    index = 0\n",
    "    mylist = [item for item in range(0,256)]\n",
    "\n",
    "    for i in range(64):\n",
    "\n",
    "        knot_hash = knot_hash_round(mylist ,index, skip_size, inp_new)\n",
    "\n",
    "        my_list = knot_hash[0]\n",
    "        index = knot_hash[1]\n",
    "        skip_size = knot_hash[2]\n",
    "\n",
    "    knot_16 = []\n",
    "    for i in range(16):\n",
    "        sub_knot = mylist[i*16:(i+1)*16]\n",
    "        knot_16.append(xor_list(sub_knot))\n",
    "\n",
    "    return(''.join([myhex(item) for item in knot_16]))\n",
    "\n",
    "\n",
    "f = open('inputs/10.txt')\n",
    "inp = f.read()\n",
    "\n",
    "\n",
    "\n",
    "print(knothash(inp))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "784\n",
      "1558\n"
     ]
    }
   ],
   "source": [
    "#Q11.a\n",
    "def dist_hex(org):\n",
    "    org_next1 = [0, 0, 0]     \n",
    "    org_next2 = [0, 0, 0]\n",
    "    sum_prev= sum(map(abs, org))+1\n",
    "\n",
    "    while sum(map(abs, org)) < sum_prev:\n",
    "\n",
    "        sum_prev= sum(map(abs, org))\n",
    "\n",
    "        org_next1[0] = org[0] + 1\n",
    "        org_next1[1] = org[1] - 1\n",
    "        org_next1[2] = org[2] - 1\n",
    "\n",
    "        org_next2[0] = org[0] - 1\n",
    "        org_next2[1] = org[1] + 1\n",
    "        org_next2[2] = org[2] + 1\n",
    "\n",
    "        if sum(map(abs, org_next1)) > sum(map(abs, org_next2)) :\n",
    "            org = org_next2\n",
    "        elif sum(map(abs, org_next1))< sum(map(abs, org_next2)):\n",
    "            org = org_next1\n",
    "\n",
    "    return(sum_prev)\n",
    "\n",
    "f = open('inputs/11.txt')\n",
    "inp = f.read()\n",
    "inp = inp.split(',')\n",
    "\n",
    "org = [0, 0, 0]\n",
    "for i in inp:\n",
    "    if i == 'n':\n",
    "        org[0] += 1\n",
    "    elif i == 's':\n",
    "        org[0] += -1\n",
    "    elif i == 'ne':\n",
    "        org[1] += 1\n",
    "    elif i == 'sw':\n",
    "        org[1] += -1\n",
    "    elif i == 'nw':\n",
    "        org[2] += 1\n",
    "    elif i == 'se':\n",
    "        org[2] += -1\n",
    "    dist.append(dist_hex(org))\n",
    "\n",
    "print(dist_hex(org))   \n",
    "\n",
    "#Q11.b\n",
    "print(max(dist))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "152\n",
      "186\n"
     ]
    }
   ],
   "source": [
    "#Q12.a\n",
    "f = open('inputs/12.txt')\n",
    "inp = f.read()\n",
    "inp_cmds = [[item[0], item[1].split(', ')] for item in [item.split(' <-> ') for item in inp.split('\\n')]]\n",
    "inp_dict = {}\n",
    "\n",
    "for item in inp_cmds:\n",
    "    inp_dict[item[0]] = item[1]\n",
    "\n",
    "\n",
    "def traverse(inp_dict, item, pid):\n",
    "\n",
    "    \n",
    "    if item in completed:\n",
    "        return([])\n",
    "    elif item == pid:\n",
    "        return(inp_dict[item]+[item])\n",
    "    elif pid in inp_dict[item]:\n",
    "        return([item]) \n",
    "    else:\n",
    "        completed.append(item)\n",
    "        list_return = []\n",
    "        for item2 in inp_dict[item]:\n",
    "            list_return += traverse(inp_dict, item2, pid)\n",
    "        if list_return != []:\n",
    "            return([item]+list_return)\n",
    "        else:\n",
    "            return(list_return)\n",
    "\n",
    "pid = '0'\n",
    "pid_list = []\n",
    "\n",
    "for item in inp_dict:\n",
    "    completed = []\n",
    "    pid_list += traverse(inp_dict, item, pid)\n",
    "\n",
    "print(len(set(pid_list)))\n",
    "\n",
    "#Q12.b\n",
    "groups =[]\n",
    "for pid in inp_dict.keys():\n",
    "    if pid not in [y for x in groups for y in x]:\n",
    "\n",
    "        pid_list = []\n",
    "        for item in inp_dict:\n",
    "            completed = []\n",
    "            pid_list += traverse(inp_dict, item, pid)\n",
    "        groups.append(pid_list)\n",
    "print(len(groups))\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2160\n",
      "3907470\n"
     ]
    }
   ],
   "source": [
    "#Q13.a\n",
    "def find_severity(inp, delay):\n",
    "    caught = []\n",
    "    for item in inp_dict:\n",
    "        if (item + delay) % (2*(inp_dict[item] - 1)) == 0:\n",
    "            caught.append([item, inp_dict[item]])\n",
    "\n",
    "    return(sum([item[0]*item[1] for item in caught]))\n",
    "\n",
    "f = open('inputs/13.txt')\n",
    "inp = f.read()\n",
    "inp = inp.split('\\n')\n",
    "inp_dict = {}\n",
    "for item in inp:\n",
    "    inp_dict[int(item.split(': ')[0])] = int(item.split(': ')[1])\n",
    "\n",
    "print(find_severity(inp_dict, 0))\n",
    "\n",
    "#Q13.b\n",
    "def find_non_caught(inp_dict, delay):\n",
    "\n",
    "    for item in inp_dict:\n",
    "        if (item + delay) % (2*(inp_dict[item] - 1)) == 0:\n",
    "            return(False)\n",
    "\n",
    "    return(True)\n",
    "\n",
    "\n",
    "\n",
    "delay = 0\n",
    "while find_non_caught(inp_dict, delay) is False:\n",
    "    delay += 1\n",
    "print(delay)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8074\n",
      "1212\n"
     ]
    }
   ],
   "source": [
    "#Q14.a\n",
    "f = open('inputs/14.txt')\n",
    "inp = f.read()\n",
    "#inp ='flqrgnkx'\n",
    "\n",
    "grid = []\n",
    "total = 0\n",
    "for i in range(128):\n",
    "    key = inp+'-'+str(i)\n",
    "    \n",
    "    grid.append(list(bin(int(knothash(key), 16))[2:].zfill(128)))\n",
    "     \n",
    "grid = [[int(y) for y in x] for x in grid]\n",
    "\n",
    "print(sum([sum(x) for x in grid]))\n",
    "\n",
    "#Q14.b\n",
    "def discover(i,j):\n",
    "    if discovery_map[i][j] == 1:\n",
    "        return()\n",
    "    else:\n",
    "        discovery_map[i][j] = 1\n",
    "        if grid[i][j] == 0:\n",
    "            return()\n",
    "        else:\n",
    "            if i != 0:\n",
    "                discover(i-1,j)\n",
    "            if i != 127:\n",
    "                discover(i+1,j)\n",
    "            if j != 0:\n",
    "                discover(i,j-1)\n",
    "            if j != 127:\n",
    "                discover(i,j+1)\n",
    "            \n",
    "discovery_map =  [[0 for col in range(128)] for row in range(128)]\n",
    "\n",
    "group = 0\n",
    "for i in range(128):\n",
    "    for j in range(128):\n",
    "\n",
    "        if discovery_map[i][j] == 0:\n",
    "            if grid[i][j] == 0:\n",
    "                discovery_map[i][j] = 1\n",
    "            else:\n",
    "                discover(i,j)\n",
    "                group += 1\n",
    "print(group)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "638\n",
      "343\n"
     ]
    }
   ],
   "source": [
    "#Q15.a\n",
    "f = open('inputs/15.txt')\n",
    "inp = f.read().split('\\n')\n",
    "inp = [int(item.split(' ')[-1]) for item in inp]\n",
    "\n",
    "genA = lambda inp: (inp*16807)%2147483647\n",
    "genB = lambda inp: (inp*48271)%2147483647\n",
    "\n",
    "outA = inp[0]\n",
    "outB = inp[1]\n",
    "\n",
    "counter = 0\n",
    "for i in range(40000000):\n",
    "    outA = genA(outA)\n",
    "    outB = genB(outB)\n",
    "    if bin(outA)[2:].zfill(16)[-16:] == bin(outB)[2:].zfill(16)[-16:]:\n",
    "        counter += 1\n",
    "print(counter)\n",
    "#Q15.b\n",
    "f = open('inputs/15.txt')\n",
    "inp = f.read().split('\\n')\n",
    "inp = [int(item.split(' ')[-1]) for item in inp]\n",
    "\n",
    "outA = inp[0]\n",
    "outB = inp[1]\n",
    "\n",
    "counter = 0\n",
    "for i in range(5000000): \n",
    "    outA = genA(outA)\n",
    "    while outA%4 != 0:\n",
    "        outA = genA(outA)\n",
    "        \n",
    "    outB = genB(outB)\n",
    "    while outB%8 != 0:\n",
    "        outB = genB(outB)\n",
    "   \n",
    "    if bin(outA)[2:].zfill(16)[-16:] == bin(outB)[2:].zfill(16)[-16:]:\n",
    "        counter += 1\n",
    "print(counter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fgmobeaijhdpkcln\n",
      "lgmkacfjbopednhi\n"
     ]
    }
   ],
   "source": [
    "#Q16.a\n",
    "f = open('inputs/16.txt')\n",
    "inp = f.read().split(',')\n",
    "inp = [[item[0]]+item[1:].split('/')  for item in inp]\n",
    "\n",
    "\n",
    "\n",
    "def apply_cmd(p,cmd):\n",
    "\n",
    "    p = list(p)\n",
    "    dummy = list(p)\n",
    "    if cmd[0] == 'x':\n",
    "        p[int(cmd[1])] = p[int(cmd[2])]\n",
    "        p[int(cmd[2])] = dummy[int(cmd[1])]\n",
    "        return(''.join(p))\n",
    "    elif cmd[0] == 's':\n",
    "        p = p[-int(cmd[1]):] + p[:-int(cmd[1])] \n",
    "        return(''.join(p))\n",
    "    else:\n",
    "        \n",
    "        p[p.index(cmd[1])] = cmd[2]\n",
    "        p[dummy.index(cmd[2])] = cmd[1]\n",
    "        return(''.join(p))\n",
    "\n",
    "p = 'abcdefghijklmnop'\n",
    "\n",
    "for cmd in inp:\n",
    "    p = apply_cmd(p,cmd)    \n",
    "print(p)\n",
    "\n",
    "#Q16.b\n",
    "\n",
    "i = 1\n",
    "while p != 'abcdefghijklmnop': \n",
    "    for cmd in inp:\n",
    "        p = apply_cmd(p,cmd)\n",
    "    i += 1\n",
    "\n",
    "j = (10**9)%i\n",
    "\n",
    "p = 'abcdefghijklmnop'\n",
    "for i in range(j):\n",
    "    for cmd in inp:\n",
    "        p = apply_cmd(p,cmd)\n",
    "\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1971\n",
      "17202899\n"
     ]
    }
   ],
   "source": [
    "#Q17.a\n",
    "f = open('inputs/17.txt')\n",
    "inp = int(f.read())\n",
    "\n",
    "buf = [0]\n",
    "cur = 0\n",
    "\n",
    "for i in range(2017):\n",
    "    cur = (cur + inp)%len(buf)\n",
    "    buf = buf[:cur+1] + [i+1] + buf[cur+1:]\n",
    "    cur += 1\n",
    "    \n",
    "print(buf[buf.index(2017)+1])\n",
    "\n",
    "#Q17.b\n",
    "buf = [0]\n",
    "cur = 0\n",
    "length = 1\n",
    "\n",
    "i = 0\n",
    "while i < 50000000:\n",
    "    cur = (cur + inp)%length +1\n",
    "    length += 1\n",
    "    i += 1\n",
    "    if cur == 1:\n",
    "        res = i\n",
    "\n",
    "print(res)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4601\n",
      "6858\n"
     ]
    }
   ],
   "source": [
    "#Q18.a\n",
    "f = open('inputs/18.txt')\n",
    "inp = [item.split(' ') for item in f.read().split('\\n')]\n",
    "\n",
    "regs = {item[1]:0 for item in inp if item[1].isalpha()}\n",
    "rec_freq = 0\n",
    "snd_freq = 0\n",
    "\n",
    "setv = lambda x: int(x) if str(x).lstrip(\"-\").isnumeric() else regs[x]\n",
    "\n",
    "i = 0\n",
    "while (i < len(inp)) or (i >= 0):\n",
    "    item = inp[i]\n",
    "    \n",
    "    if item[0] == 'snd':\n",
    "        snd_freq= regs[item[1]]\n",
    "    elif item[0] == 'set':\n",
    "        regs[item[1]] = setv(item[2])  \n",
    "    elif item[0] == 'mul':\n",
    "        regs[item[1]] *= setv(item[2])\n",
    "    elif item[0] == 'add':\n",
    "        regs[item[1]] += setv(item[2])\n",
    "    elif item[0] == 'mod':\n",
    "        regs[item[1]] %= setv(item[2])\n",
    "    elif item[0] == 'rcv':\n",
    "        if regs[item[1]] != 0:    \n",
    "            break\n",
    "    elif item[0] == 'jgz' and (regs[item[1]] != 0) :\n",
    "        i += setv(item[2]) - 1\n",
    "    i += 1\n",
    "    \n",
    "print(snd_freq)\n",
    "\n",
    "#Q18.b\n",
    "\n",
    "def apply_cmd(pid, msg_my, msg_oth):\n",
    "    \n",
    "    regs = {item[1]:0 for item in inp if item[1].isalpha()}\n",
    "    regs['p'] = pid\n",
    "    \n",
    "    setv = lambda x: int(x) if str(x).lstrip(\"-\").isnumeric() else regs[x]\n",
    "    \n",
    "    i = 0\n",
    "    \n",
    "    while 0 <= i < len(inp):\n",
    "        item = inp[i]\n",
    "    \n",
    "        if item[0] == 'snd':\n",
    "            msg_my.append(setv(item[1]))\n",
    "            yield(\"Sent\")\n",
    "\n",
    "        elif item[0] == 'rcv':\n",
    "            while len(msg_oth) == 0:\n",
    "                yield(\"Wait\")\n",
    "            else:\n",
    "                regs[item[1]] = msg_oth.popleft()\n",
    "                yield(\"Received\")\n",
    "                \n",
    "        elif item[0] == 'set':\n",
    "            regs[item[1]] = setv(item[2])  \n",
    "        elif item[0] == 'mul':\n",
    "            regs[item[1]] *= setv(item[2])\n",
    "        elif item[0] == 'add':\n",
    "            regs[item[1]] += setv(item[2])\n",
    "        elif item[0] == 'mod':\n",
    "            regs[item[1]] %= setv(item[2])\n",
    "        elif item[0] == 'jgz' and (setv(item[1]) > 0) :\n",
    "            i += setv(item[2]) - 1\n",
    "        i += 1\n",
    "\n",
    "f = open('inputs/18.txt')\n",
    "inp = [item.split(' ') for item in f.read().split('\\n')]\n",
    "\n",
    "msg0 = deque()\n",
    "msg1 = deque() \n",
    "\n",
    "counter_1 = 0\n",
    "\n",
    "g0 = apply_cmd(0, msg0, msg1)\n",
    "g1 = apply_cmd(1, msg1, msg0)\n",
    "\n",
    "while True:\n",
    "    a = next(g0)\n",
    "    b = next(g1)\n",
    "    if (a == \"Wait\") and (b == \"Wait\"):\n",
    "        break\n",
    "    if b == \"Sent\":\n",
    "        counter_1 += 1\n",
    "print(counter_1)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LIWQYKMRP\n",
      "16764\n"
     ]
    }
   ],
   "source": [
    "#Q19.a\n",
    "f = open('inputs/19.txt')\n",
    "inp = [list(item) for item in f.read().split('\\n')]\n",
    "\n",
    "letters = []\n",
    "j = inp[0].index('|')\n",
    "cur = inp[1][j]\n",
    "if cur.isalpha(): letters.append(cur)\n",
    "\n",
    "i = 1\n",
    "dy = 1\n",
    "steps = 1\n",
    "\n",
    "while cur != ' ':\n",
    "    while (cur != '+') and (cur != ' '):\n",
    "        i += dy\n",
    "        steps += 1\n",
    "        cur = inp[i][j]\n",
    "        if cur.isalpha(): letters.append(cur)\n",
    "        \n",
    "    if inp[i][j+1] == ' ':\n",
    "        dx = -1\n",
    "    else:\n",
    "        dx = 1\n",
    "    j += dx\n",
    "    steps += 1\n",
    "    cur = inp[i][j]\n",
    "    if cur.isalpha(): letters.append(cur)\n",
    "    while (cur != '+') and (cur != ' '):\n",
    "        j += dx\n",
    "        steps += 1\n",
    "        cur = inp[i][j]\n",
    "        if cur.isalpha(): letters.append(cur)\n",
    "\n",
    "    if inp[i+1][j] == ' ':\n",
    "        dy = -1\n",
    "    else:\n",
    "        dy = 1\n",
    "    i += dy\n",
    "    steps += 1\n",
    "    cur = inp[i][j]\n",
    "    if cur.isalpha(): letters.append(cur)\n",
    "print(''.join(letters))\n",
    "\n",
    "#Q19.b\n",
    "print(steps-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "457\n",
      "448\n"
     ]
    }
   ],
   "source": [
    "#Q20.a\n",
    "f = open('inputs/20.txt')\n",
    "inp = [[[item3 for item3 in item2.split('=')] for item2 in item.split(', ')] for item in f.read().split('\\n')]\n",
    "inp = [[[int(item3) for item3 in item2[1].strip('<').strip('>').split(',')] for item2 in item] for item in inp]\n",
    "\n",
    "#inp = [[3,0,0],[2,0,0], [-1,0,0]], [[4,0,0], [0,0,0], [-2,0,0]]\n",
    "\n",
    "p = np.matrix([item[0] for item in inp])\n",
    "v = np.matrix([item[1] for item in inp])\n",
    "a = np.matrix([item[2] for item in inp])\n",
    "\n",
    "for i in range(10000):\n",
    "    v += a \n",
    "    p += v \n",
    "p = p.tolist()\n",
    "\n",
    "print([sum(map(abs,item)) for item in p].index(min([sum(map(abs,item)) for item in p])))\n",
    "\n",
    "#Q20.b\n",
    "def removeCollusions(p, v, a):\n",
    "    i = 0\n",
    "    while i < len(p):\n",
    "        s = [sum(map(abs, item)) == 0 for item in (p - p[i]).tolist()]\n",
    "        if sum(s) > 1:\n",
    "            p = np.matrix([p.tolist()[j]  for j,item in enumerate(s) if s[j] == False])\n",
    "            v = np.matrix([v.tolist()[j] for j,item in enumerate(s) if s[j] == False ])\n",
    "            a = np.matrix([a.tolist()[j]  for j,item in enumerate(s) if s[j] == False])\n",
    "            i -= sum(s[0:i+1]) \n",
    "        i += 1\n",
    "    return(p, v, a)\n",
    "\n",
    "f = open('inputs/20.txt')\n",
    "inp = [[[item3 for item3 in item2.split('=')] for item2 in item.split(', ')] for item in f.read().split('\\n')]\n",
    "inp = [[[int(item3) for item3 in item2[1].strip('<').strip('>').split(',')] for item2 in item] for item in inp]\n",
    "\n",
    "p = np.matrix([item[0] for item in inp])\n",
    "v = np.matrix([item[1] for item in inp])\n",
    "a = np.matrix([item[2] for item in inp])\n",
    "\n",
    "for i in range(100):\n",
    "    v += a \n",
    "    p += v\n",
    "    [p, v, a] = removeCollusions(p, v, a)\n",
    "\n",
    "p = p.tolist()\n",
    "\n",
    "print(len(p))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 359,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "136\n",
      "1911767\n"
     ]
    }
   ],
   "source": [
    "#Q21.a\n",
    "\n",
    "def rotate_pixel(pixel):\n",
    "    return(np.rot90(np.matrix(pixel)).tolist())\n",
    "def flip_pixel(pixel):\n",
    "    return(np.flip(np.matrix(pixel),1).tolist())\n",
    "def pixel_find(pix, rule_dict):\n",
    "    for i in range(4):\n",
    "        if str(pix) in rule_dict:\n",
    "            return([pix, rule_dict[str(pix)]])\n",
    "        elif str(flip_pixel(pix)) in rule_dict:\n",
    "            return([flip_pixel(pix), rule_dict[str(flip_pixel(pix))]])\n",
    "        pix = rotate_pixel(pix)\n",
    "def pixel_iterate(pix, rule_dict):\n",
    "    if len(pix) < 4:\n",
    "        return(pixel_find(pix, rule_dict)[1] )\n",
    "    elif len(pix) % 2 == 0:\n",
    "        mat_pix = [np.split(item,len(pix)/2,1) for item in np.split(np.matrix(pix),len(pix)/2,0)]\n",
    "        mat_pix_ret = [[[]] * int(len(pix)/2) for i in range(int(len(pix)/2))]\n",
    "        for i,x in enumerate(mat_pix):\n",
    "            for j,y in enumerate(x):\n",
    "                mat_pix_ret[i][j] = pixel_find(y.tolist(), rule_dict)[1]\n",
    "        return(np.concatenate([np.concatenate(item,1) for item in mat_pix_ret],0).tolist())\n",
    "    elif len(pix) % 3 == 0:\n",
    "        mat_pix = [np.split(item,len(pix)/3,1) for item in np.split(np.matrix(pix),len(pix)/3,0)]\n",
    "        mat_pix_ret = [[[]] * int(len(pix)/3) for i in range(int(len(pix)/3))]\n",
    "        for i,x in enumerate(mat_pix):\n",
    "            for j,y in enumerate(x):\n",
    "                mat_pix_ret[i][j] = pixel_find(y.tolist(), rule_dict)[1]\n",
    "        return(np.concatenate([np.concatenate(item,1) for item in mat_pix_ret],0).tolist())\n",
    "\n",
    "f = open('inputs/21.txt')\n",
    "enh_rules = [ [[list(item3) for item3 in item2.split('/')] for item2 in item.split(' => ') ] for item in f.read().split('\\n') ]\n",
    "\n",
    "for i,rule in enumerate(enh_rules):\n",
    "    for j,pixel in enumerate(rule):\n",
    "        for k,s in enumerate(pixel):\n",
    "            for l,c in enumerate(s):\n",
    "                if c == '.':\n",
    "                    enh_rules[i][j][k][l] = 0\n",
    "                else:\n",
    "                    enh_rules[i][j][k][l] = 1\n",
    "rule_dict = {}\n",
    "\n",
    "for rule in enh_rules:\n",
    "    rule_dict[str(rule[0])] = rule[1]\n",
    "    \n",
    "ini = [[0, 1, 0], [0, 0, 1], [1, 1, 1]]\n",
    "\n",
    "for i in range(5):\n",
    "    ini = pixel_iterate(ini, rule_dict)\n",
    "print(sum([sum(item) for item in ini]))\n",
    "\n",
    "#Q21.b\n",
    "ini = [[0, 1, 0], [0, 0, 1], [1, 1, 1]]\n",
    "\n",
    "for i in range(18):\n",
    "    ini = pixel_iterate(ini, rule_dict)\n",
    "print(sum([sum(item) for item in ini]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 513,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5565\n",
      "2511978\n"
     ]
    }
   ],
   "source": [
    "#Q22.a\n",
    "def step(board,i,j,dct):\n",
    "    global counter\n",
    "    dct = dct_dict[dct][board[i][j]]\n",
    "    if board[i][j] == 0:\n",
    "        counter += 1\n",
    "    board[i][j] = board[i][j]^1\n",
    "    if dct == 'u':\n",
    "        i = int((i - 1)%len(board))\n",
    "    elif dct == 'd':\n",
    "        i = int((i + 1)%len(board))\n",
    "    elif dct == 'r':\n",
    "        j = int((j + 1)%len(board))\n",
    "    else:\n",
    "        j = int((j - 1)%len(board))\n",
    "    return([board,i,j,dct])\n",
    "\n",
    "f = open('inputs/22.txt')\n",
    "inp = [list(item) for item in f.read().split('\\n')]\n",
    "inp = [[0 if i =='.' else 1 for i in item]  for item in inp ]\n",
    "\n",
    "n = 1000\n",
    "board = [[0] * n for i in range(n)]\n",
    "\n",
    "for i in range(len(inp)):\n",
    "    for j in range(len(inp)):\n",
    "        board[i][j] = inp[i][j]\n",
    "        \n",
    "i = int((len(inp)-1)/2)\n",
    "j = i\n",
    "\n",
    "dct = 'u'\n",
    "dct_dict = {'u':['l','r'], 'l':['d','u'], 'd':['r','l'], 'r':['u','d']}\n",
    "counter = 0\n",
    "\n",
    "for ind in range(10000):\n",
    "    [board,i,j,dct] = step(board,i,j,dct)\n",
    "print(counter)\n",
    "\n",
    "#Q22.bb\n",
    "def step2(board,i,j,dct):\n",
    "    global counter\n",
    "    dct = dct_dict[dct][board[i][j]]\n",
    "    if board[i][j] == 1:\n",
    "        counter += 1\n",
    "    board[i][j] = (board[i][j] + 1)%4\n",
    "    if dct == 'u':\n",
    "        i = int((i - 1)%len(board))\n",
    "    elif dct == 'd':\n",
    "        i = int((i + 1)%len(board))\n",
    "    elif dct == 'r':\n",
    "        j = int((j + 1)%len(board))\n",
    "    else:\n",
    "        j = int((j - 1)%len(board))\n",
    "    return([board,i,j,dct])\n",
    "\n",
    "f = open('inputs/22.txt')\n",
    "inp = [list(item) for item in f.read().split('\\n')]\n",
    "inp = [[0 if i =='.' else 2 for i in item]  for item in inp ]\n",
    "\n",
    "n = 10000\n",
    "board = [[0] * n for i in range(n)]\n",
    "\n",
    "for i in range(len(inp)):\n",
    "    for j in range(len(inp)):\n",
    "        board[i][j] = inp[i][j]\n",
    "        \n",
    "i = int((len(inp)-1)/2)\n",
    "j = i\n",
    "\n",
    "dct = 'u'\n",
    "dct_dict = {'u':['l','u','r','d'], 'l':['d','l','u','r'], 'd':['r','d','l','u'], 'r':['u','r','d','l']}\n",
    "counter = 0\n",
    "\n",
    "for ind in range(10000000):\n",
    "    [board,i,j,dct] = step2(board,i,j,dct)\n",
    "print(counter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4225\n",
      "905\n"
     ]
    }
   ],
   "source": [
    "#Q23.a\n",
    "f = open('inputs/23.txt')\n",
    "inp = [item.split(' ') for item in f.read().split('\\n')]\n",
    "\n",
    "setv = lambda x: int(x) if str(x).lstrip(\"-\").isnumeric() else regs[x]\n",
    "\n",
    "regs = {'a':0,'b':0,'c':0,'d':0,'e':0,'f':0,'g':0,'h':0}\n",
    "\n",
    "i = 0\n",
    "cntr = 0\n",
    "while  0 <= i < len(inp):\n",
    "    item = inp[i]\n",
    "\n",
    "    if item[0] == 'set':\n",
    "        regs[item[1]] = setv(item[2])\n",
    "    elif item[0] == 'sub':\n",
    "        regs[item[1]] -= setv(item[2])\n",
    "    elif item[0] == 'mul':\n",
    "        cntr += 1\n",
    "        regs[item[1]] *= setv(item[2])\n",
    "    elif item[0] == 'add':\n",
    "        regs[item[1]] += setv(item[2])\n",
    "    elif item[0] == 'mod':\n",
    "        regs[item[1]] %= setv(item[2])\n",
    "    elif item[0] == 'rcv':\n",
    "        if regs[item[1]] != 0:    \n",
    "            break\n",
    "    elif item[0] == 'jnz' and (setv(item[1]) != 0) :\n",
    "        i += setv(item[2]) - 1\n",
    "    i += 1\n",
    "print(cntr)\n",
    "\n",
    "#Q23.b\n",
    "regs = {'a':1,'b':0,'c':0,'d':0,'e':0,'f':0,'g':0,'h':0}\n",
    "\n",
    "regs['b'] = 67\n",
    "regs['c'] = regs['b']\n",
    "\n",
    "if regs['a'] != 0:\n",
    "    regs['b'] = 100*regs['b'] + 100000\n",
    "    regs['c'] = regs['b'] + 17000\n",
    "    \n",
    "for i in range(regs['b'], regs['c']+1, 17):\n",
    "    for j in range(2, int(i**0.5)):\n",
    "        if i % j == 0:\n",
    "            regs['h'] += 1\n",
    "            break\n",
    "            \n",
    "print(regs['h'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1868\n",
      "1841\n"
     ]
    }
   ],
   "source": [
    "#Q24.a\n",
    "f = open('inputs/24.txt')\n",
    "inp = [item.split('/') for item in f.read().split('\\n')]\n",
    "inp = [[int(item2) for item2 in item] for item in inp ]\n",
    "\n",
    "def findleafs(root, inp):\n",
    "    leafs = []\n",
    "    for item in inp:\n",
    "        if root in item: leafs.append(item)\n",
    "    return(leafs)\n",
    "\n",
    "def buildtree(tree, inp):\n",
    "    root = tree[-1]\n",
    "    root_end = root[-1]\n",
    "    leafs = findleafs(root[-1], inp)\n",
    "    for leaf in leafs:\n",
    "        leaf_copy = copy.deepcopy(leaf)\n",
    "        leaf_copy.remove(root[-1])\n",
    "        leaf_end = leaf_copy\n",
    "        tree.extend([root + leaf_end])\n",
    "        tree = buildtree(tree, [item for item in inp if item != leaf])\n",
    "    return(tree)\n",
    "\n",
    "tree = buildtree([[0]], inp)\n",
    "tree.remove([0])\n",
    "\n",
    "print(max([sum(item)*2 - item[-1] for item in tree]))\n",
    "\n",
    "#Q24.b\n",
    "maxlen = max([len(item) for item in tree])\n",
    "print(max([sum(item)*2 - item[-1] for item in [item for item in tree if len(item) == maxlen]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4287\n"
     ]
    }
   ],
   "source": [
    "#Q25\n",
    "f = open('inputs/25.txt')\n",
    "inp = [item for item in f.read().split('\\n\\n')]\n",
    "\n",
    "state = inp[0].split('.\\n')[0][-1]\n",
    "no_chksm = int(inp[0].split(' ')[-2])\n",
    "del inp[0]\n",
    "\n",
    "inp = [item.split('\\n') for item in inp]\n",
    "\n",
    "inp_dict = {}\n",
    "for inp_state in inp:\n",
    "    inp_dict[inp_state[0].split(' ')[-1][0]] = [(int(inp_state[2].split(' ')[-1][0]), int(inp_state[6].split(' ')[-1][0])),\n",
    "                                                (inp_state[3].split(' ')[-1].strip('.'), inp_state[7].split(' ')[-1].strip('.')),\n",
    "                                                (inp_state[4].split(' ')[-1][0], inp_state[8].split(' ')[-1][0])]\n",
    "for item in inp_dict:\n",
    "    new = [0,0]\n",
    "    if inp_dict[item][1][0] == 'right': new[0] = 1 \n",
    "    else: new[0] = -1 \n",
    "    if inp_dict[item][1][1] == 'right': new[1] = 1 \n",
    "    else: new[1] = -1\n",
    "    inp_dict[item][1] = tuple(new)\n",
    "    \n",
    "tape = np.zeros(100000)\n",
    "ind = 0\n",
    "\n",
    "for i in range(no_chksm):\n",
    "    cval = int(tape[ind])\n",
    "    tape[ind] = inp_dict[state][0][cval]\n",
    "    ind = int((ind + inp_dict[state][1][cval]) % len(tape))\n",
    "    state = inp_dict[state][2][cval]   \n",
    "print(int(sum(tape)))"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}