peuler2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 4 7\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "maxcnt = 0\n",
    "\n",
    "for p in range(2, 1001, 2):\n",
    "    cnt = 0; t = int((p//2)**0.5)\n",
    "    for c in range(5, p//2):\n",
    "        for n in range(1, m):\n",
    "            if m*(m+n) == (p//2):\n",
    "                cnt += 1\n",
    "                if p == 120 : print(m, n, t)\n",
    "    if cnt > maxcnt: maxcnt = cnt\n",
    "        \n",
    "print(maxcnt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22.360679774997898"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10*5**0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(840, 8)\n",
      "0.009966135025024414\n"
     ]
    }
   ],
   "source": [
    "from collections import defaultdict\n",
    "import time\n",
    "\n",
    "stime = time.time()\n",
    "d = defaultdict(int)\n",
    "dlis = defaultdict(list)\n",
    "for m in range(2, 23):\n",
    "    for n in range(1, m):\n",
    "        p = 2*(m**2 + m*n)\n",
    "        if p > 1000: break\n",
    "        i, temp = 1, p\n",
    "        while temp <= 1000:\n",
    "            a = (i)*(m**2 - n**2)\n",
    "            b = (i)*(2*m*n)\n",
    "            if a not in dlis[temp]:\n",
    "                d[temp] += 1\n",
    "                dlis[temp].append(a)\n",
    "                dlis[temp].append(b)\n",
    "            i += 1\n",
    "            temp = p*i\n",
    "            \n",
    "print(max(d.items(), key = lambda x: x[1]))\n",
    "print(time.time()-stime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*********\n",
    "Problem 59 - XOR "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1455"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = open(\"p059_cipher.txt\")\n",
    "text = text.read().split(\",\")\n",
    "text = [int(i) for i in text]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "\n",
    "x = sorted(Counter(text).items(), key = lambda x: -x[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "69\n",
      "Comma i\n",
      "Question z\n",
      "88\n",
      "Question g\n",
      "Comma t\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "\n",
    "asciilow = string.ascii_lowercase\n",
    "\n",
    "for k in [69, 88]:\n",
    "    print(k)\n",
    "    for j in asciilow:\n",
    "        if (chr(k^ord(j))) == \"?\": print(\"Question\", j)\n",
    "        if (chr(k^ord(j))) == \",\": print(\"Comma\", j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [],
   "source": [
    "for j in asciilow:\n",
    "    chr(text[0]^ord(j)) # print, removed as taking too much space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [],
   "source": [
    "res = \" \"\n",
    "cnt = 0\n",
    "\n",
    "stri = \"exp\"\n",
    "for i, j in zip(text, it.cycle(stri)):\n",
    "    res += chr(i ^ ord(j))\n",
    "    \n",
    "#sorted(Counter(res.split(\" \")).items(), key = lambda x: -x[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*****\n",
    "Problem 107 - MST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = open(\"p107_network.txt\")\n",
    "text = text.read()\n",
    "text = text.split(\"\\n\")[0:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "259679\n",
      "39\n"
     ]
    }
   ],
   "source": [
    "# build adj matrix, named_tuple - anyone?\n",
    "from collections import namedtuple\n",
    "\n",
    "edge = namedtuple(\"edge\", [\"a\", \"b\", \"w\"])\n",
    "edges = []\n",
    "\n",
    "tot_val = 0\n",
    "\n",
    "for i in range(len(text)):\n",
    "    row = text[i].split(\",\")\n",
    "    for j in range(i, len(row)):\n",
    "        if (row[j] != \"-\"):\n",
    "            n = int(row[j])\n",
    "            e = edge(i, j, n)\n",
    "            edges.append(e)\n",
    "            tot_val += n\n",
    "\n",
    "edges = sorted(edges, key = lambda x: x.w)\n",
    "\n",
    "\n",
    "# this is bullshit -- why? coz we can't set values to tuple! immutable!!\n",
    "\n",
    "# vertex = namedtuple(\"vertex\", [\"num\", \"siz\"])\n",
    "\n",
    "# for i in range(len(text)):\n",
    "#     v = vertex(i, 1)\n",
    "#     vertices.append(v)\n",
    "\n",
    "# def join(a, b):\n",
    "#     if vertices[a].siz > vertices[b].siz:\n",
    "#         vertices[b].num = vertices[a].num\n",
    "#         vertices[b].siz += vertices[a].siz\n",
    "#     else:\n",
    "#         vertices[a].num = vertices[b].num\n",
    "#         vertices[a].siz += vertices[b].siz\n",
    "\n",
    "class vertex():\n",
    "    def __init__(self, num, siz):\n",
    "        self.num = num\n",
    "        self.siz = siz\n",
    "\n",
    "vertices = [vertex(i, 1) for i in range(len(text))]\n",
    "\n",
    "def find(a):\n",
    "    while (a != vertices[a].num): a = vertices[a].num\n",
    "    return a\n",
    "\n",
    "def join(a, b):\n",
    "    x = find(a)\n",
    "    y = find(b)\n",
    "    if vertices[x].siz < vertices[y].siz: x,y = y, x\n",
    "    vertices[x].siz += vertices[y].siz\n",
    "    vertices[y].num = x\n",
    "        \n",
    "ans = 0\n",
    "count = 0\n",
    "for e in edges:\n",
    "    if find(e.a) != find(e.b):\n",
    "        ans += e.w\n",
    "        join(e.a, e.b)\n",
    "        count += 1\n",
    "\n",
    "print(tot_val - ans)\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "****\n",
    "Problem 117 - Tiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 378,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20492570929"
      ]
     },
     "execution_count": 378,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# x + 2*y + 3*z + 4*w = 50\n",
    "import itertools as it\n",
    "\n",
    "fact = list(it.accumulate(range(1, 51), lambda x,y: x*y))\n",
    "fact = [1] + fact\n",
    "\n",
    "def f(n, idx):\n",
    "    ans = 0 \n",
    "    for q in range(0, n//3 + 1):\n",
    "        qf = fact[2*q] if idx is 0 else fact[2*q + 1]\n",
    "        for w in range(0, (n-3*q)//2 + 1):\n",
    "            wf = fact[w]\n",
    "            k = 2*n - 4*q - 3*w if idx is 0 else 2*n + 2 - 4*q - 3*w\n",
    "            k_ = n - 3*q - 2*w\n",
    "            for y in range(0, (n-3*q -2*w + 1)):\n",
    "                #numr = fact[k - y - max(k_ - y, y, 2*q, w)]\n",
    "                numr = fact[k-y]\n",
    "                denr = wf*qf*fact[y]*fact[2*(k_- y)] if idx is 0 else wf*qf*fact[y]*fact[2*(k_- y) + 1]\n",
    "                if idx is 0:\n",
    "                    if [y, 2*q, w].count(0) == 2: ans += numr//denr\n",
    "                else:\n",
    "                    if y == 0 and w == 0: ans += numr//denr\n",
    "                #ans += numr//denr\n",
    "\n",
    "    return ans\n",
    "       \n",
    "\n",
    "n = 50\n",
    "f(n // 2, 0) + f((n-4)//2, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*****\n",
    "Problem 114"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 418,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "978181\n"
     ]
    }
   ],
   "source": [
    "N = 167\n",
    "K = 50\n",
    "res = 0\n",
    "\n",
    "memo = [-1]*(N+1)\n",
    "\n",
    "def f(n):\n",
    "    if K > n : return 1\n",
    "    \n",
    "    if (memo[n] != -1): return memo[n]\n",
    "\n",
    "    res = 0\n",
    "    for i in range(0, n-K+1):\n",
    "        for j in range(K, n-i+1):\n",
    "            res += f(n-i-j-1)\n",
    "    \n",
    "    memo[n] = res + 1\n",
    "    \n",
    "    return res + 1\n",
    "\n",
    "print(f(N))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 424,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "a, b = 1, 2\n",
    "for i in range(3):\n",
    "    a, b = b, a+b\n",
    "\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 425,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "a, b, c = 1, 1, 2\n",
    "for i in range(2):\n",
    "    a, b, c = b, c, c + a\n",
    "\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 426,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "a, b, c, d = 1, 1, 1, 2\n",
    "for i in range(1):\n",
    "    a, b, c, d = b, c, d, a + d\n",
    "    \n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 435,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100808458960497"
      ]
     },
     "execution_count": 435,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a, b, c, d = 0, 0, 0, 1\n",
    "for i in range(50):\n",
    "    a, b, c, d = b, c, d, a + b + c + d\n",
    "    \n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*******\n",
    "Passcode Derivation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "73162890\n"
     ]
    }
   ],
   "source": [
    "file = open(\"p079_keylog.txt\")\n",
    "text = file.read().split(\"\\n\")[:-1]\n",
    "\n",
    "from collections import defaultdict\n",
    "d = defaultdict(set)\n",
    "vis = {}\n",
    "\n",
    "for t in text:\n",
    "    d[t[0]].add(t[1])\n",
    "    d[t[0]].add(t[2])\n",
    "    d[t[1]].add(t[2])\n",
    "    for i in range(3) :\n",
    "        if t[i] not in vis: vis[t[i]] = False\n",
    "    \n",
    "# topsort time\n",
    "def dfs(x, f):\n",
    "    if not vis[x]: \n",
    "        vis[x] = True\n",
    "        if x in d: \n",
    "            for e in d[x]:\n",
    "                if not vis[e]:\n",
    "                    f = dfs(e, f)\n",
    "                    f += 1\n",
    "                    finish[e] = f\n",
    "    return f\n",
    "        \n",
    "f = 0\n",
    "finish = {}\n",
    "for i in vis.keys():\n",
    "    if not vis[i]:\n",
    "        f = dfs(i, f)\n",
    "        f += 1\n",
    "        finish[i] = f\n",
    "        \n",
    "finish = sorted(finish.items(), key = lambda f: -f[1])\n",
    "print(\"\".join([x[0] for x in finish]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*****\n",
    "Path Sum - 2 ways"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "427337 0.0402989387512207\n",
      "427337 0.0251007080078125\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import itertools as it\n",
    "import time\n",
    "\n",
    "file = open(\"p081_matrix.txt\")\n",
    "text = file.read().split(\"\\n\")[:-1]\n",
    "matrix = []\n",
    "for line in text:\n",
    "    t = line.split(\",\")\n",
    "    matrix.append([int(i) for i in t])\n",
    "\n",
    "matrix = np.asarray(matrix).astype(int)\n",
    "soln = np.zeros([80, 80]).astype(int)\n",
    "soln[0] = list(it.accumulate(matrix[0]))\n",
    "soln[:, 0] = list(it.accumulate(matrix[:, 0]))\n",
    "\n",
    "# function + memoisation\n",
    "stime = time.time()\n",
    "def f(i, j):\n",
    "    if soln[i, j] == 0: \n",
    "        soln[i, j] = matrix[i, j] + min(f(i-1, j), f(i, j-1))\n",
    "    return soln[i, j]\n",
    "\n",
    "print(f(79, 79), time.time()-stime)\n",
    "\n",
    "# for loop + memoisation -- preferable ?\n",
    "stime = time.time()\n",
    "for i in range(1, 80):\n",
    "    for j in range(1, 80):\n",
    "        soln[i, j] = matrix[i, j] + min(soln[i-1, j], soln[i, j-1])\n",
    "print(soln[79, 79], time.time()-stime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "260324 8.604815483093262\n"
     ]
    }
   ],
   "source": [
    "file = open(\"p082_matrix.txt\")\n",
    "text = file.read().split(\"\\n\")[:-1]\n",
    "matrix = []\n",
    "for line in text:\n",
    "    t = line.split(\",\")\n",
    "    matrix.append([int(i) for i in t])\n",
    "\n",
    "matrix = np.asarray(matrix).astype(int)\n",
    "soln = matrix[:, 0]\n",
    "\n",
    "stime = time.time()\n",
    "n,m = matrix.shape\n",
    "for i in range(1, m):\n",
    "    column = matrix[:, i]\n",
    "    soln = [\n",
    "        column[rowval] + \n",
    "        min([\n",
    "            soln[prev_row] + sum(column[prev_row:rowval:(1 if prev_row <= rowval else -1)])\n",
    "            for prev_row in range(n)\n",
    "        ])\n",
    "        for rowval in range(n)\n",
    "    ]\n",
    "\n",
    "# https://codereview.stackexchange.com/questions/38404/project-euler-82-path-sum-three-ways\n",
    "# beautiful code\n",
    "# taking longer because of numpy... so avoid numpy\n",
    "# better write column = [matrix[row][col] for row in range(n)] -> to grad column\n",
    "# instead of matrix[:, col]\n",
    "print(min(soln), time.time()-stime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "260324 3.952613115310669\n"
     ]
    }
   ],
   "source": [
    "def euler82(matrix):\n",
    "    nrows, ncols = len(matrix), len(matrix[0])\n",
    "    best = [matrix[row][0] for row in range(nrows)]\n",
    "\n",
    "    for col in range(1, ncols):\n",
    "        column = [matrix[row][col] for row in range(nrows)]\n",
    "\n",
    "        best = [\n",
    "            # The cost of each cell, plus...\n",
    "            column[row] +\n",
    "\n",
    "            # the cost of the cheapest approach to it\n",
    "            min([\n",
    "                best[prev_row] + sum(column[prev_row:row:(1 if prev_row <= row else -1)])\n",
    "                for prev_row in range(nrows)\n",
    "            ])\n",
    "            for row in range(nrows)\n",
    "        ]\n",
    "\n",
    "        #print(best)\n",
    "\n",
    "    return min(best)\n",
    "\n",
    "stime = time.time()\n",
    "print(euler82(matrix), time.time()-stime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "****\n",
    "Counting rectangles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2000\n",
    "y = 1\n",
    "req = 2000000\n",
    "minerror = 1000\n",
    "while (x >= y):\n",
    "    rects = x*(x+1)*y*(y+1)*(1/4)\n",
    "    error = np.abs(req - rects)\n",
    "    if error < minerror: minarea = x*y\n",
    "    \n",
    "    if rects > req: x -= 1\n",
    "    else : y += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(52, 53, 2772)"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " x, y, minarea"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*****\n",
    "Coin Partition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35442"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(n):\n",
    "    p = []\n",
    "    p.append(n)\n",
    "    cnt = 0\n",
    "    while (p[0] != 1):\n",
    "        p = list(it.takewhile(lambda x: x != 1, p))\n",
    "        k = len(p)-1\n",
    "        p[k] -= 1\n",
    "        residue = n - sum(p)\n",
    "        if residue > p[k]: \n",
    "            p = p[:k+1] + [p[k]]*(residue // p[k])\n",
    "            if residue % p[k] != 0: p.append(1)\n",
    "        else: p = p[:k+1] + [residue]\n",
    "\n",
    "        cnt += 1\n",
    "    \n",
    "    return cnt+1\n",
    "\n",
    "# counter = it.count(start = 1)\n",
    "# n = next(counter)\n",
    "# while (f(n) % 1000000 != 0): \n",
    "#     n = next(counter) \n",
    "# print(n)\n",
    "f(40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55374\n"
     ]
    }
   ],
   "source": [
    "# much succinct algo\n",
    "N = 55400\n",
    "ways = [1] + [0] * N\n",
    "\n",
    "for i in range(1, N):\n",
    "    for j in range(i, N+1):\n",
    "        ways[j] = ways[j] + ways[j - i]\n",
    "\n",
    "for i,way in enumerate(ways):\n",
    "    if way % 1000000 == 0: \n",
    "        print(i); break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*****\n",
    "Problem 345- Matrix Sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "matrix = \"7  53 183 439 863 497 383 563  79 973 287  63 343 169 583 627 343 773 959 943 767 473 103 699 303 957 703 583 639 913 447 283 463  29  23 487 463 993 119 883 327 493 423 159 743 217 623   3 399 853 407 103 983  89 463 290 516 212 462 350 960 376 682 962 300 780 486 502 912 800 250 346 172 812 350 870 456 192 162 593 473 915  45 989 873 823 965 425 329 803 973 965 905 919 133 673 665 235 509 613 673 815 165 992 326 322 148 972 962 286 255 941 541 265 323 925 281 601  95 973 445 721  11 525 473  65 511 164 138 672  18 428 154 448 848 414 456 310 312 798 104 566 520 302 248 694 976 430 392 198 184 829 373 181 631 101 969 613 840 740 778 458 284 760 390 821 461 843 513  17 901 711 993 293 157 274  94 192 156 574 34 124   4 878 450 476 712 914 838 669 875 299 823 329 699 815 559 813 459 522 788 168 586 966 232 308 833 251 631 107 813 883 451 509 615  77 281 613 459 205 380 274 302  35 805\"\n",
    "matrix = matrix.split(\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.0"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "matrix = [int(s) for s in matrix if s != \"\"]\n",
    "\n",
    "import itertools as it\n",
    "\n",
    "it.permutations()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'np' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-18-0e0abd914c4c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfact\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m15\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}