2020-06-24_numberOfDecodings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This problem was asked by Facebook.\n",
    "\n",
    "Given the mapping a = 1, b = 2, ... z = 26, and an encoded message, count the number of ways it can be decoded.\n",
    "\n",
    "For example, the message '111' would give 3, since it could be decoded as 'aaa', 'ka', and 'ak'.\n",
    "\n",
    "You can assume that the messages are decodable. For example, '001' is not allowed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def number_of_decodings(code):\n",
    "    \"\"\" Returns the number of ways code can be decoded.\n",
    "    This is solved by recursion in O(number_of_decodings) \n",
    "    time and O(1) space.\n",
    "    Since the number_of_decodings can be up to O(2^n) in the\n",
    "    worst case, this quickly becomes very slow. \"\"\"\n",
    "\n",
    "    if (len(code) <= 1):\n",
    "        # assume all such codes are unambiguously decodable\n",
    "        return 1\n",
    "    \n",
    "    # test if the current and next digit lead\n",
    "    # to ambiguity, and if so branch out to \n",
    "    # consider both cases\n",
    "    elif (\n",
    "        # a '1' is ambiguous if followed by\n",
    "        # a digit X=[1-9] since it could be\n",
    "        # decoded as '1X' or '1'+'X'\n",
    "        code[0]=='1' and \n",
    "        code[1] in [str(k) for k in (range(1,10))]\n",
    "    ) or (\n",
    "        # a '2' is ambiguous if followed by \n",
    "        # a digit X=[1-6] since it could be\n",
    "        # decoded as '2X' or '2'+'X'\n",
    "        code[0]=='2' and \n",
    "        code[1] in [str(k) for k in range(1,7)]\n",
    "    ):\n",
    "        # branch out due to ambiguity\n",
    "        return (number_of_decodings(code[1:]) + \n",
    "                number_of_decodings(code[2:]))\n",
    "    \n",
    "    # if no ambiguity, just move on to next digit\n",
    "    else:\n",
    "        return number_of_decodings(code[1:])\n",
    "\n",
    "def number_of_decodings_fast(code):\n",
    "    \"\"\" Same as number_of_decodings(), but \n",
    "    dynamic programming implementation which runs in \n",
    "    O(n) time and O(1) space. \n",
    "    The implementation is very similar to the dynamic programming\n",
    "    solution for the Fibonacci series. \"\"\"\n",
    "    length = len(code)\n",
    "    if (length <= 1):\n",
    "        # assume all such codes are unambiguously decodable\n",
    "        return 1\n",
    "    else:\n",
    "        n_prev = 1 # len 0\n",
    "        n_current = 1 # len 1\n",
    "        for i in range(1,length):\n",
    "            if (\n",
    "                # a '1' is ambiguous if followed by\n",
    "                # a digit X=[1-9] since it could be\n",
    "                # decoded as '1X' or '1'+'X'\n",
    "                code[i-1]=='1' and \n",
    "                code[1] in [str(k) for k in (range(1,10))]\n",
    "            ) or (\n",
    "                # a '2' is ambiguous if followed by \n",
    "                # a digit X=[1-6] since it could be\n",
    "                # decoded as '2X' or '2'+'X'\n",
    "                code[i-1]=='2' and \n",
    "                code[i] in [str(k) for k in range(1,7)]\n",
    "            ):\n",
    "                # New number of decodings is the sum of\n",
    "                # decodings obtainable from the code two digits back\n",
    "                # (code[0:(i-2)] + '[1-2]X' interpretation)\n",
    "                # and decodings obtainable from the code one digit back\n",
    "                # (code[0:(i-1)] + 'X' interpretation).\n",
    "                n_new = n_prev + n_current\n",
    "            else:\n",
    "                # New number of decodings is the same as\n",
    "                # that obtainable from the code one digit back\n",
    "                # (code[0:(i-1)] + 'X' interpretation).\n",
    "                n_new = n_current\n",
    "            # update n_prev and n_current\n",
    "            n_prev = n_current\n",
    "            n_current = n_new\n",
    "        return n_current"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "code = \"\"\n",
    "assert number_of_decodings(code) == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "code = \"111\"\n",
    "assert number_of_decodings_fast(code) == 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "code = \"11\"\n",
    "assert number_of_decodings_fast(code) == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "code = \"20\"\n",
    "assert number_of_decodings_fast(code) == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "code = \"29\"\n",
    "assert number_of_decodings_fast(code) == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "code = \"126\"\n",
    "assert number_of_decodings_fast(code) == 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "code = \"1216\"\n",
    "assert number_of_decodings_fast(code) == 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "code = \"12321\"\n",
    "assert number_of_decodings_fast(code) == 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "from timeit import default_timer as timer\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import math\n",
    "\n",
    "def runtime(fun, arr):\n",
    "    \"\"\" Return the execution time of fun with argument arr \"\"\"\n",
    "    start = timer()\n",
    "#     print(fun(arr))\n",
    "    res = fun(arr)\n",
    "    end = timer()\n",
    "    return (end-start, res)\n",
    "\n",
    "def benchmark(fun, min_array_len=10, max_array_len=1e4, n=20):\n",
    "    \"\"\" \n",
    "    Benchmark runtime of function fun with arrays of varying length. \n",
    "    Return a DataFrame specifying execution times in seconds for a\n",
    "    set of array lengths.\n",
    "    \"\"\"\n",
    "    bench_df = pd.DataFrame({\n",
    "        'len': np.logspace(\n",
    "            math.log10(min_array_len),\n",
    "            math.log10(max_array_len),\n",
    "            num=n,\n",
    "            dtype=np.int32\n",
    "        ),\n",
    "        'execution_time': np.empty(n),\n",
    "        'res': np.empty(n)\n",
    "    })\n",
    "    for i, n in enumerate(bench_df['len']):\n",
    "#         arr = np.arange(1,n) # this leads to float64 overflow\n",
    "        arr = ['1'] * n\n",
    "        bench_df.at[i, 'execution_time'], bench_df.at[i, 'res'] = runtime(fun,arr)\n",
    "    return bench_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursive_stats_df = benchmark(\n",
    "    number_of_decodings,\n",
    "    min_array_len=1,\n",
    "    max_array_len=30\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "dynamicProg_stats_df = benchmark(\n",
    "    number_of_decodings_fast,\n",
    "    min_array_len=1,\n",
    "    max_array_len=30\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "any(dynamicProg_stats_df['res'] != recursive_stats_df['res'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'decode dynamic prog')"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "sns.scatterplot('len', 'execution_time', data=recursive_stats_df, ax=ax)\n",
    "ax.set_title('decode recursive')\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "sns.scatterplot('len', 'execution_time', data=dynamicProg_stats_df, ax=ax)\n",
    "ax.set_title('decode dynamic prog')"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}