Lecture-03-Dynamic-Programming-Pre-Course.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dynamic Programming For Cutting Problems"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "original_price = [1, 5, 8, 9, 10, 17, 17, 20, 24, 30]\n",
    "price = defaultdict(int)\n",
    "for i, p in enumerate(original_price):\n",
    "    price[i+1] = p\n",
    "assert price[1] == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "price[132]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](Picture1.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "solution = {}\n",
    "## for a given length N, we set the corrsponding split parts\n",
    "## solution = \n",
    "# {\n",
    "#     4: (2, 2)\n",
    "# }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func_1(n):\n",
    "    for i in range(n):\n",
    "        print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def call_time(func_1, arg): # 脚手架程序 \n",
    "    start = time.time()\n",
    "    func_1(arg)\n",
    "    print('used time: {}'.format(time.time() - start))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import wraps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [],
   "source": [
    "function_called_time = defaultdict(int)\n",
    "\n",
    "def get_call_time(func):\n",
    "    @wraps(func)\n",
    "    def _inner(arg): ## *args, **kwargs\n",
    "        \"\"\"It's inner function\"\"\"\n",
    "        global function_called_time\n",
    "        function_called_time[func.__name__] += 1\n",
    "        result = func(arg)\n",
    "        print('function called time is : {}'.format(function_called_time[func.__name__]))\n",
    "        return result\n",
    "    return _inner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "used time: 0.0005786418914794922\n",
      "used time: 0.0006239414215087891\n"
     ]
    }
   ],
   "source": [
    "call_time(func_1, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "func_1 = get_call_time(func_1) ## => @ ( decorator ) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "function called time is : 1\n"
     ]
    }
   ],
   "source": [
    "func_1(10) # we get the new func 1 😀"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "@get_call_time\n",
    "def func_1(n):\n",
    "    \"\"\"\n",
    "    @param n: is the number of customers\n",
    "    @return int: the customers value point\n",
    "    \"\"\"\n",
    "    for i in range(n):\n",
    "        print(n)\n",
    "    return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function func_1 in module __main__:\n",
      "\n",
      "func_1(n)\n",
      "    @param n: is the number of customers\n",
      "    @return int: the customers value point\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(func_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "function called time is : 45\n"
     ]
    }
   ],
   "source": [
    "func_1(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "function called time is : 4\n",
      "used time: 0.20224428176879883\n"
     ]
    }
   ],
   "source": [
    "call_time(func_slow, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [],
   "source": [
    "@get_call_time\n",
    "def func_slow(n):\n",
    "    for i in range(n):\n",
    "        time.sleep(0.2)\n",
    "        print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "function called time is : 8\n"
     ]
    }
   ],
   "source": [
    "func_slow(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func_slow(n):\n",
    "    for i in range(n):\n",
    "        time.sleep(0.2)\n",
    "        print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "5\n",
      "5\n",
      "5\n",
      "5\n",
      "used time: 1.0214979648590088\n"
     ]
    }
   ],
   "source": [
    "func_slow(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [],
   "source": [
    "def memo(func):\n",
    "    cache = {}\n",
    "    @wraps(func)\n",
    "    def _wrap(n): ## ? *args, **kwargs\n",
    "        if n in cache: result = cache[n]\n",
    "        else:\n",
    "            result = func(n)\n",
    "            cache[n] = result\n",
    "        return result\n",
    "    return _wrap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [],
   "source": [
    "@memo\n",
    "def r(n):\n",
    "    max_price, split_point = max(\n",
    "        [(price[n], 0)] + [(r(i) + r(n-i), i) for i in range(1, n)], key=lambda x: x[0]\n",
    "    )\n",
    "    solution[n] = (split_point, n - split_point)\n",
    "    \n",
    "    return max_price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "691"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r(231)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dynamic Programming\n",
    "\n",
    "不断查表的意思\n",
    "+ 分析子问题的重复性\n",
    "+ 子问题进行存储\n",
    "+ Solution 要进行解析"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 16)"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solution[18]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 2)"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solution[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6, 10)"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solution[16]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 6)"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solution[6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 10)"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solution[10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: (0, 1),\n",
       " 2: (0, 2),\n",
       " 3: (0, 3),\n",
       " 4: (2, 2),\n",
       " 5: (2, 3),\n",
       " 6: (0, 6),\n",
       " 7: (1, 6),\n",
       " 8: (2, 6),\n",
       " 9: (3, 6),\n",
       " 10: (0, 10),\n",
       " 11: (1, 10),\n",
       " 12: (2, 10),\n",
       " 13: (3, 10),\n",
       " 14: (2, 12),\n",
       " 15: (2, 13),\n",
       " 16: (6, 10),\n",
       " 17: (1, 16),\n",
       " 18: (2, 16),\n",
       " 19: (3, 16),\n",
       " 20: (10, 10),\n",
       " 21: (1, 20),\n",
       " 22: (2, 20),\n",
       " 23: (3, 20),\n",
       " 24: (2, 22),\n",
       " 25: (2, 23),\n",
       " 26: (6, 20),\n",
       " 27: (1, 26),\n",
       " 28: (2, 26),\n",
       " 29: (3, 26),\n",
       " 30: (10, 20),\n",
       " 31: (1, 30),\n",
       " 32: (2, 30),\n",
       " 33: (3, 30),\n",
       " 34: (2, 32),\n",
       " 35: (2, 33),\n",
       " 36: (6, 30),\n",
       " 37: (1, 36),\n",
       " 38: (2, 36),\n",
       " 39: (3, 36),\n",
       " 40: (10, 30),\n",
       " 41: (1, 40),\n",
       " 42: (2, 40),\n",
       " 43: (3, 40),\n",
       " 44: (2, 42),\n",
       " 45: (2, 43),\n",
       " 46: (6, 40),\n",
       " 47: (1, 46),\n",
       " 48: (2, 46),\n",
       " 49: (3, 46),\n",
       " 50: (10, 40),\n",
       " 51: (1, 50),\n",
       " 52: (2, 50),\n",
       " 53: (3, 50),\n",
       " 54: (2, 52),\n",
       " 55: (2, 53),\n",
       " 56: (6, 50),\n",
       " 57: (1, 56),\n",
       " 58: (2, 56),\n",
       " 59: (3, 56),\n",
       " 60: (10, 50),\n",
       " 61: (1, 60),\n",
       " 62: (2, 60),\n",
       " 63: (3, 60),\n",
       " 64: (2, 62),\n",
       " 65: (2, 63),\n",
       " 66: (6, 60),\n",
       " 67: (1, 66),\n",
       " 68: (2, 66),\n",
       " 69: (3, 66),\n",
       " 70: (10, 60),\n",
       " 71: (1, 70),\n",
       " 72: (2, 70),\n",
       " 73: (3, 70),\n",
       " 74: (2, 72),\n",
       " 75: (2, 73),\n",
       " 76: (6, 70),\n",
       " 77: (1, 76),\n",
       " 78: (2, 76),\n",
       " 79: (3, 76),\n",
       " 80: (10, 70),\n",
       " 81: (1, 80),\n",
       " 82: (2, 80),\n",
       " 83: (3, 80),\n",
       " 84: (2, 82),\n",
       " 85: (2, 83),\n",
       " 86: (6, 80),\n",
       " 87: (1, 86),\n",
       " 88: (2, 86),\n",
       " 89: (3, 86),\n",
       " 90: (10, 80),\n",
       " 91: (1, 90),\n",
       " 92: (2, 90),\n",
       " 93: (3, 90),\n",
       " 94: (2, 92),\n",
       " 95: (2, 93),\n",
       " 96: (6, 90),\n",
       " 97: (1, 96),\n",
       " 98: (2, 96),\n",
       " 99: (3, 96),\n",
       " 100: (10, 90),\n",
       " 101: (1, 100),\n",
       " 102: (2, 100),\n",
       " 103: (3, 100),\n",
       " 104: (2, 102),\n",
       " 105: (2, 103),\n",
       " 106: (6, 100),\n",
       " 107: (1, 106),\n",
       " 108: (2, 106),\n",
       " 109: (3, 106),\n",
       " 110: (10, 100),\n",
       " 111: (1, 110),\n",
       " 112: (2, 110),\n",
       " 113: (3, 110),\n",
       " 114: (2, 112),\n",
       " 115: (2, 113),\n",
       " 116: (6, 110),\n",
       " 117: (1, 116),\n",
       " 118: (2, 116),\n",
       " 119: (3, 116),\n",
       " 120: (10, 110),\n",
       " 121: (1, 120),\n",
       " 122: (2, 120),\n",
       " 123: (3, 120),\n",
       " 124: (2, 122),\n",
       " 125: (2, 123),\n",
       " 126: (6, 120),\n",
       " 127: (1, 126),\n",
       " 128: (2, 126),\n",
       " 129: (3, 126),\n",
       " 130: (10, 120),\n",
       " 131: (1, 130),\n",
       " 132: (2, 130),\n",
       " 133: (3, 130),\n",
       " 134: (2, 132),\n",
       " 135: (2, 133),\n",
       " 136: (6, 130),\n",
       " 137: (1, 136),\n",
       " 138: (2, 136),\n",
       " 139: (3, 136),\n",
       " 140: (10, 130),\n",
       " 141: (1, 140),\n",
       " 142: (2, 140),\n",
       " 143: (3, 140),\n",
       " 144: (2, 142),\n",
       " 145: (2, 143),\n",
       " 146: (6, 140),\n",
       " 147: (1, 146),\n",
       " 148: (2, 146),\n",
       " 149: (3, 146),\n",
       " 150: (10, 140),\n",
       " 151: (1, 150),\n",
       " 152: (2, 150),\n",
       " 153: (3, 150),\n",
       " 154: (2, 152),\n",
       " 155: (2, 153),\n",
       " 156: (6, 150),\n",
       " 157: (1, 156),\n",
       " 158: (2, 156),\n",
       " 159: (3, 156),\n",
       " 160: (10, 150),\n",
       " 161: (1, 160),\n",
       " 162: (2, 160),\n",
       " 163: (3, 160),\n",
       " 164: (2, 162),\n",
       " 165: (2, 163),\n",
       " 166: (6, 160),\n",
       " 167: (1, 166),\n",
       " 168: (2, 166),\n",
       " 169: (3, 166),\n",
       " 170: (10, 160),\n",
       " 171: (1, 170),\n",
       " 172: (2, 170),\n",
       " 173: (3, 170),\n",
       " 174: (2, 172),\n",
       " 175: (2, 173),\n",
       " 176: (6, 170),\n",
       " 177: (1, 176),\n",
       " 178: (2, 176),\n",
       " 179: (3, 176),\n",
       " 180: (10, 170),\n",
       " 181: (1, 180),\n",
       " 182: (2, 180),\n",
       " 183: (3, 180),\n",
       " 184: (2, 182),\n",
       " 185: (2, 183),\n",
       " 186: (6, 180),\n",
       " 187: (1, 186),\n",
       " 188: (2, 186),\n",
       " 189: (3, 186),\n",
       " 190: (10, 180),\n",
       " 191: (1, 190),\n",
       " 192: (2, 190),\n",
       " 193: (3, 190),\n",
       " 194: (2, 192),\n",
       " 195: (2, 193),\n",
       " 196: (6, 190),\n",
       " 197: (1, 196),\n",
       " 198: (2, 196),\n",
       " 199: (3, 196),\n",
       " 200: (10, 190),\n",
       " 201: (1, 200),\n",
       " 202: (2, 200),\n",
       " 203: (3, 200),\n",
       " 204: (2, 202),\n",
       " 205: (2, 203),\n",
       " 206: (6, 200),\n",
       " 207: (1, 206),\n",
       " 208: (2, 206),\n",
       " 209: (3, 206),\n",
       " 210: (10, 200),\n",
       " 211: (1, 210),\n",
       " 212: (2, 210),\n",
       " 213: (3, 210),\n",
       " 214: (2, 212),\n",
       " 215: (2, 213),\n",
       " 216: (6, 210),\n",
       " 217: (1, 216),\n",
       " 218: (2, 216),\n",
       " 219: (3, 216),\n",
       " 220: (10, 210),\n",
       " 221: (1, 220),\n",
       " 222: (2, 220),\n",
       " 223: (3, 220),\n",
       " 224: (2, 222),\n",
       " 225: (2, 223),\n",
       " 226: (6, 220),\n",
       " 227: (1, 226),\n",
       " 228: (2, 226),\n",
       " 229: (3, 226),\n",
       " 230: (10, 220),\n",
       " 231: (1, 230)}"
      ]
     },
     "execution_count": 227,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [],
   "source": [
    "def not_cut(split): return split == 0\n",
    "\n",
    "def parse_solution(target_length, revenue_solution):\n",
    "    left, right = revenue_solution[target_length]\n",
    "    \n",
    "    if not_cut(left): return [right]\n",
    "\n",
    "    return parse_solution(left, revenue_solution) + parse_solution(right, revenue_solution)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 6, 10]"
      ]
     },
     "execution_count": 248,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parse_solution(19, solution)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Edit Distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {},
   "outputs": [],
   "source": [
    "solution = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "metadata": {},
   "outputs": [],
   "source": [
    "@lru_cache(maxsize=2**10)\n",
    "def edit_distance(string1, string2):\n",
    "    \n",
    "    if len(string1) == 0: return len(string2)\n",
    "    if len(string2) == 0: return len(string1)\n",
    "    \n",
    "    tail_s1 = string1[-1]\n",
    "    tail_s2 = string2[-1]\n",
    "    \n",
    "    candidates = [\n",
    "        (edit_distance(string1[:-1], string2) + 1, 'DEL {}'.format(tail_s1)),  # string 1 delete tail\n",
    "        (edit_distance(string1, string2[:-1]) + 1, 'ADD {}'.format(tail_s2)),  # string 1 add tail of string2\n",
    "    ]\n",
    "    \n",
    "    if tail_s1 == tail_s2:\n",
    "        both_forward = (edit_distance(string1[:-1], string2[:-1]) + 0, '')\n",
    "    else:\n",
    "        both_forward = (edit_distance(string1[:-1], string2[:-1]) + 1, 'SUB {} => {}'.format(tail_s1, tail_s2))\n",
    "\n",
    "    candidates.append(both_forward)\n",
    "    \n",
    "    min_distance, operation = min(candidates, key=lambda x: x[0])\n",
    "    \n",
    "    solution[(string1, string2)] = operation \n",
    "    \n",
    "    return min_distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 288,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "edit_distance('ABCDE', 'ABCCEF')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{('A', 'A'): '',\n",
       " ('A', 'AB'): 'ADD B',\n",
       " ('A', 'ABC'): 'ADD C',\n",
       " ('A', 'ABCC'): 'ADD C',\n",
       " ('AB', 'A'): 'DEL B',\n",
       " ('AB', 'AB'): '',\n",
       " ('AB', 'ABC'): 'ADD C',\n",
       " ('AB', 'ABCC'): 'ADD C',\n",
       " ('ABC', 'A'): 'DEL C',\n",
       " ('ABC', 'AB'): 'DEL C',\n",
       " ('ABC', 'ABC'): '',\n",
       " ('ABC', 'ABCC'): 'ADD C',\n",
       " ('ABCD', 'A'): 'DEL D',\n",
       " ('ABCD', 'AB'): 'DEL D',\n",
       " ('ABCD', 'ABC'): 'DEL D',\n",
       " ('ABCD', 'ABCC'): 'SUB D => C',\n",
       " ('A', 'ABCCE'): 'ADD E',\n",
       " ('A', 'ABCCEF'): 'ADD F',\n",
       " ('AB', 'ABCCE'): 'ADD E',\n",
       " ('AB', 'ABCCEF'): 'ADD F',\n",
       " ('ABC', 'ABCCE'): 'ADD E',\n",
       " ('ABC', 'ABCCEF'): 'ADD F',\n",
       " ('ABCD', 'ABCCE'): 'ADD E',\n",
       " ('ABCD', 'ABCCEF'): 'ADD F',\n",
       " ('ABCDE', 'A'): 'DEL E',\n",
       " ('ABCDE', 'AB'): 'DEL E',\n",
       " ('ABCDE', 'ABC'): 'DEL E',\n",
       " ('ABCDE', 'ABCC'): 'DEL E',\n",
       " ('ABCDE', 'ABCCE'): '',\n",
       " ('ABCDE', 'ABCCEF'): 'ADD F'}"
      ]
     },
     "execution_count": 289,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{('1', '1'): '',\n",
       " ('1', '11'): 'ADD 1',\n",
       " ('1', '111'): 'ADD 1',\n",
       " ('1', '1110'): 'ADD 0',\n",
       " ('1', '11100'): 'ADD 0',\n",
       " ('10', '1'): 'DEL 0',\n",
       " ('10', '11'): 'DEL 0',\n",
       " ('10', '111'): 'DEL 0',\n",
       " ('10', '1110'): '',\n",
       " ('10', '11100'): 'ADD 0',\n",
       " ('101', '1'): 'DEL 1',\n",
       " ('101', '11'): '',\n",
       " ('101', '111'): 'ADD 1',\n",
       " ('101', '1110'): 'DEL 1',\n",
       " ('101', '11100'): 'DEL 1',\n",
       " ('1010', '1'): 'DEL 0',\n",
       " ('1010', '11'): 'DEL 0',\n",
       " ('1010', '111'): 'DEL 0',\n",
       " ('1010', '1110'): '',\n",
       " ('1010', '11100'): 'ADD 0',\n",
       " ('b', 'b'): '',\n",
       " ('b', 'bi'): 'ADD i',\n",
       " ('b', 'bie'): 'ADD e',\n",
       " ('b', 'biej'): 'ADD j',\n",
       " ('b', 'bieji'): 'ADD i',\n",
       " ('b', 'biejin'): 'ADD n',\n",
       " ('be', 'b'): 'DEL e',\n",
       " ('be', 'bi'): 'DEL e',\n",
       " ('be', 'bie'): '',\n",
       " ('be', 'biej'): 'ADD j',\n",
       " ('be', 'bieji'): 'ADD i',\n",
       " ('be', 'biejin'): 'ADD n',\n",
       " ('bei', 'b'): 'DEL i',\n",
       " ('bei', 'bi'): '',\n",
       " ('bei', 'bie'): 'DEL i',\n",
       " ('bei', 'biej'): 'DEL i',\n",
       " ('bei', 'bieji'): '',\n",
       " ('bei', 'biejin'): 'ADD n',\n",
       " ('beij', 'b'): 'DEL j',\n",
       " ('beij', 'bi'): 'DEL j',\n",
       " ('beij', 'bie'): 'DEL j',\n",
       " ('beij', 'biej'): '',\n",
       " ('beij', 'bieji'): 'DEL j',\n",
       " ('beij', 'biejin'): 'DEL j',\n",
       " ('beiji', 'b'): 'DEL i',\n",
       " ('beiji', 'bi'): 'DEL i',\n",
       " ('beiji', 'bie'): 'DEL i',\n",
       " ('beiji', 'biej'): 'DEL i',\n",
       " ('beiji', 'bieji'): '',\n",
       " ('beiji', 'biejin'): 'ADD n',\n",
       " ('beijin', 'b'): 'DEL n',\n",
       " ('beijin', 'bi'): 'DEL n',\n",
       " ('beijin', 'bie'): 'DEL n',\n",
       " ('beijin', 'biej'): 'DEL n',\n",
       " ('beijin', 'bieji'): 'DEL n',\n",
       " ('beijin', 'biejin'): '',\n",
       " ('beijing', 'b'): 'DEL g',\n",
       " ('beijing', 'bi'): 'DEL g',\n",
       " ('beijing', 'bie'): 'DEL g',\n",
       " ('beijing', 'biej'): 'DEL g',\n",
       " ('beijing', 'bieji'): 'DEL g',\n",
       " ('beijing', 'biejin'): 'DEL g'}"
      ]
     },
     "execution_count": 275,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{('1', '1'): '',\n",
       " ('1', '11'): 'ADD 1',\n",
       " ('1', '111'): 'ADD 1',\n",
       " ('1', '1110'): 'ADD 0',\n",
       " ('1', '11100'): 'ADD 0',\n",
       " ('10', '1'): 'DEL 0',\n",
       " ('10', '11'): 'DEL 0',\n",
       " ('10', '111'): 'DEL 0',\n",
       " ('10', '1110'): '',\n",
       " ('10', '11100'): 'ADD 0',\n",
       " ('101', '1'): 'DEL 1',\n",
       " ('101', '11'): '',\n",
       " ('101', '111'): 'ADD 1',\n",
       " ('101', '1110'): 'DEL 1',\n",
       " ('101', '11100'): 'DEL 1',\n",
       " ('1010', '1'): 'DEL 0',\n",
       " ('1010', '11'): 'DEL 0',\n",
       " ('1010', '111'): 'DEL 0',\n",
       " ('1010', '1110'): '',\n",
       " ('1010', '11100'): 'ADD 0'}"
      ]
     },
     "execution_count": 273,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 269,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "edit_distance('ATCGGAA', 'ATCGGGA')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}