Sudoku Solver.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Build a Sudoku Solver\n",
    "\n",
    "I have created a simple project where I have built an intelligent agent that will solve every sudoku which uses two very important tecniques used in A.I. :\n",
    "- Constraint propagation\n",
    "- Search techniques"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functions import *\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> Naming conventions</h2>\n",
    "\n",
    "- The 9 rows will be labelled by the letters A, B, C, D, E, F, G, H, I.\n",
    "- The 9 columns will be labelled by the numbers 1, 2, 3, 4, 5, 6, 7, 8, 9.\n",
    "- Boxes: Each intersection of row and column will be called box. These boxes will have labels 'A1', 'A2', …, 'I9'.\n",
    "- Units: The complete rows, columns, and 3x3 squares, will be called units. Thus, each unit is a set of 9 boxes, and there are 27 units in total.\n",
    "- Peers: For a particular box (such as 'A1'), its peers will be all other boxes that belong to a common unit (namely, those that belong to the same row, column, or 3x3 square).\n",
    "\n",
    "The file [utils.py](utils.py) contains codes to extract peers for each cell and display the grids."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "row_units = [cross(r, cols) for r in rows]\n",
    "column_units = [cross(rows, c) for c in cols]\n",
    "square_units = [cross(rs, cs) for rs in ('ABC','DEF','GHI') for cs in ('123','456','789')]\n",
    "unitlist = row_units + column_units + square_units\n",
    "\n",
    "unitlist = unitlist\n",
    "units = extract_units(unitlist, boxes)\n",
    "peers = extract_peers(units, boxes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Constaint Propagation\n",
    "\n",
    "\n",
    "Constraint Propagation is all about using local constraints in a space (in the case of Sudoku, the constraints of each square) to dramatically reduce the search space. As we enforce each constraint, we see how it introduces new constraints for other parts of the board that can help us further reduce the number of possibilities."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>1. Eliminate strategy</h2>\n",
    "\n",
    "In Sudoku, a box  cannot have a value already present in its peers.<br>\n",
    "Therefore we go over every box that has doesn't has a value, and eliminate that values from  its peers's possible values.<br>\n",
    "The function takes a dictionary with every box(A1,A2,etc) as key and its value (or possible values) as the value.\n",
    "It returns the values dictionary with the assigned values eliminated from peers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eliminate(values):\n",
    "    for x in peers:\n",
    "        if len(values[x])== 1:\n",
    "            digit =values[x]\n",
    "            for peer in peers[x]:\n",
    "                values[peer]=values[peer].replace(digit,\"\")\n",
    "                    \n",
    "    return values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>2. Only Choice</h2>\n",
    "\n",
    " The only choice strategy says that if only one box in a unit allows a certain digit, then that box must be assigned that digit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def only_choice(values):\n",
    "    \n",
    "    for unit in unitlist:\n",
    "        for digit in '123456789':\n",
    "            boxeswithdigit=[x for x in unit if digit in values[x]]\n",
    "            if(len(boxeswithdigit)==1):\n",
    "                #values[boxeswithdigit[0]]=digit\n",
    "                assign_value(values, boxeswithdigit[0], digit)\n",
    "            \n",
    "    return values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>3. Naked Twins Technique</h2>\n",
    "\n",
    "Popular technique to remove possibilities. It says that if 2 boxes which are peers, have the same 2 possible values, then those values are locked in those two boxes, and hence can be removed from their peers.\n",
    "<img src='images/nakedtwins.png' width=400px>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def naked_twins(values):\n",
    "    for unit in unitlist:\n",
    "        \n",
    "        s = set()\n",
    "        for x in unit:\n",
    "            if(len(values[x])==2):\n",
    "                if values[x] not in s:\n",
    "                    s.add(values[x])\n",
    "                else:\n",
    "                    val = values[x]\n",
    "                    for digit in val:\n",
    "                        for  z in unit:\n",
    "                            if(values[z]!= val):\n",
    "                                values[z]= values[z].replace(digit,'')                              \n",
    "    return values           "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Reduce Puzzle</h2>\n",
    "\n",
    "Reduce the Sudoku puzzle by repeatedly applying all these constraint strategies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reduce_puzzle(values):\n",
    "    running = True\n",
    "    while running==True:\n",
    "        solved_values_before = len([box for box in values.keys() if len(values[box]) == 1])\n",
    "        values = eliminate(values)\n",
    "        values = only_choice(values)\n",
    "        values = naked_twins(values)\n",
    "        solved_values_after = len([box for box in values.keys() if len(values[box]) == 1])\n",
    "        #print(\"before:\"+ str(solved_values_before)+\"  after: \"+str(solved_values_after))\n",
    "        if solved_values_after==solved_values_before:\n",
    "            running =False\n",
    "        \n",
    "        if len([box for box in values.keys() if len(values[box]) == 0]):\n",
    "            return False\n",
    "    \n",
    "    return values  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Search\n",
    "\n",
    "If the puzzle is still not solved using constraints, we apply Search on the least difficult box for all its *possible values* \n",
    "and the one that solves the problem is kept.\n",
    "\n",
    "Here we apply Depth First Search."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def search(values):\n",
    "\n",
    "    # First, reduce the puzzle using the previous function\n",
    "    values =reduce_puzzle(values)\n",
    "    if values is False:\n",
    "        return False\n",
    "    if all(len(values[s]) == 1 for s in boxes):\n",
    "        return values#Solved\n",
    "    # Choose one of the unfilled squares with the fewest possibilities\n",
    "    l=[s for s in boxes if len(values[s])>1]\n",
    "    z= min(l)\n",
    "    # Now use recursion to solve each one of the resulting sudokus, and if one returns a value (not False), return that answer!\n",
    "    for digit in values[z]:\n",
    "        new_val = values.copy()\n",
    "        #new_val[z]=digit\n",
    "        assign_value(new_val, z, digit)\n",
    "        attempt = search(new_val)\n",
    "        if attempt:\n",
    "            return attempt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solve\n",
    "Find the solution to the Sudoku puzzle using all these techniques."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solve(grid):\n",
    "    values = grid2values(grid)\n",
    "    values = search(values)\n",
    "    return values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Input\n",
    "\n",
    "We take the input sudoku as a /string with continuous values row by row and '.'representing empty spaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAXNklEQVR4nO2de9AcVZnGfw+oXAUkiFldBBJREFxiVBYUNQF0BQQhEkqtIKCgblGmKGWVsuQiW9YGESFgeUFwg0AVChhKCHdNEUDQWoVlJV7AEAQ1RohyDbfw7h+n22+YfLeZ7p4533zPr2qqT7pnnj4c+v36nLfPeVoRgTEmPzbodwWMMcPj4DQmUxycxmSKg9OYTHFwGpMpDk5jMsXBaUymODiNyRQHpzGZ4uA0JlMcnMZkioPTmExxcBqTKQ5OYzLlJXWISPrHurOIUB2aEw23QcLtUF8bqOp6ztaKGGPWp9sAdbfWmExxcBqTKZW7tdDsOENSNDF2qVvXbTCkWZbrbt/J1ga+cxqTKQ5OYzLFwWlMpjg4jckUB6cxmeLgNCZTHJzGZIqD05hMcXAakykOTmMyxcFpTKY4OI3JFAenMZni4DQmUxycxmSKg9OYTHFwGpMpDk5jMsXBaUym1O4hZIwZooqHUC2m0q1MVnMrG3wNaZZlG3xVw91aYzLFwWlMpjg4Tc+RNEXSMZIWS7pP0lpJj0q6VdLHJXV1XUpaKSlG+KzqUvOoUTTLz7putMei9jGnMeNgLvBN4M/AUuAPwKuAOcD5wP6S5kZ32cpHgbOH2f9El3W9C/jSCMfeCewDXNul9qjY8b1GvbI8Wdug1CzLI2lL2gfYDFgSES+07J8K/BzYDjgsIq7opK6SVhbn3aGT+nbbBpJuB/YEPhARP2rVLMt2fDcTioj4SURc1RqYxf5VwLeKf87qecU6QNJupMD8I7CkiXO4W2ty47li+3yXv99I0jzgtcCTwN3Asoioe1z4yWJ7QQPagIPTZISklwAfLf55XZcyU4GL2vbdL+noiLi568q1IGkTYB7wAmmM3Aju1pqcWADsBlwTEdd38fv/BvYlBehmwJuAbwM7ANdK2r2meh4ObAVcGxEP1qS5Hk4I1ahXlidrG5SaZbkTbUnzgYXAb4B3RMSadt0KiZuvAp8FroyIQ6vqSroNeDtwcERcNczxPF47X2dlRtKeCBem22BIsyyPV1vSccDXgeXAvkViaD3dCsH5OuBeYE1ETKmiK+mNwD3AQ8AOw403na01A4Gk40mB+Stg9nCBWQOri+1mNWg1nggqcXCaviHp88BZpAf9syNi9Rg/6Za9iu2KKiKSNgaOICWCLqhaqbFwcJq+IOkkUgLoF6Su7MMV9XaVtPUw+7cn3ZkBLq5yDtLMpleQElaNJYJK/CjF9BxJRwKnAeuAW4D50npDs5URsagD2bnAiZKWAvcDjwPTgQOBjYFrgK9WqzmfKLbnVdQZFw5O0w92LLYbAseP8J2bgUUdaC4F3gC8mdSN3Qz4O3Ar6bnnRV3O1QVA0i7A3qRE0DXd6nR0Tmdr69Mry5O1DUrNsuzF1s7WGjOQODiNyRQHpzGZYvc9YxrE7nsZ6DohNKRZlp0Qqoa7tcZkioPTmExxcGaApCNanNyOqaBzoKQbJD1UONqtkHSZpL3G/vWImpL0MUl3SHpc0lOS7pQ0X9KG3eqasXFw9hlJ2wHn0r07XKlzOnA1MJPkIrAQ+CXwAeC2wrqjGy4kTfLeEfg+8B3gZYX+9zXMvDtTExFR+QNE+alDr127bs0mdLtpA0DATcDvgTOK3x/TaV1JK//XAauAbduOzS50V3She0j5W2Cblv0vBRYXx47qxbUwUa6DOtvAd87+Mp/ke3o0yYyqW7Yn9YJ+Fm3LriJiKWkS+Cu70J1TbM+MllUjEfEccFLxz093oWvGgYOzTxQTqRcACyNiWUW5e4FngT0kbdN2nncBLyfdoTtlarEdbh1kuW+mpK260DZj4FUpfaBwmbuI5HT+hap6EbGmWLj8NWC5pCuBR0hLpg4GbmRoBX8nlHfLHYc5Nq2lvDNwRxf6ZhQcnP3hZNLSpr0jYm0dghFxduF4/l3g2JZD9wGL2ru74+Rq4MPAZyRdGoXpVvHHpfUVBa/ortZmNNyt7TGS9iDdLc+MiNtr1P0ccDlpDeR00nrGt5C6n5dI+koXspeS3gMynXRHPk/S2SRbkQNI3WlIyShTNzllpyZylm48bUDqqfyW5DK3UduxU+k+Wzur+O0Phzm2KWmB8DpgWqdtUNT5s6SAXAs8RnpU8xbg9uK8M5q+FibKdVBnG/jO2Vs2B14P7AI83foaOeCU4jvfKfYN96askXh/sV3afiAiniK9HGgDUle6IyLi+Yg4MyJmRMQmEbFFRLyP9AdmBilg7+lU14yNx5y95RlGdm2bSQqeW0l31066vBsV25Eel5T7n+1AcyyOIHnzXBjp0Yqpm5xu4xO5O1O1DajWrT28+O0q4DVtx/YnWTmuBaZ02gbAFsPsexuwhvT8dL2uchPXwkS5DupsA985B4PLSc8x9wN+LWkxKVB3IXV5BZwYEY90oX2jpLUk0+fHgV1JyaBngDkRUckL1oyMg3MAiIgXJB0AHAd8CDiUlAhaQ3KKOycibuhS/vJCcx6wCfAn0pu1FkTEyopVN6Ng970a9cryZG2DUrMs192+k60NnK01JlMq3zntH2TM6HR79/Sd05hMcXAakylOCNWoV5YnaxuUmmXZCSEnhIwZSBycxmSKg9OYTHFwGpMpDk5jMsXBaUymODiNyRQHpzGZ4uA0JlMcnMZkioPTmExxcBqTKQ5OYzLFwWlMpjg4jckUB6cxmeLgNCZTHJzGZIqD05hMqd1DyBgzRBUPodpfxzBZza1s8DWkWZZt8FUNd2uNyRQHpzGZ4uA0fUHSytY3e7d9VlXQPVDSDZIekrRW0gpJl0naq0u9KZKOkbRY0n2F5qOSbpX0cUmNxZBfAWj6yaPA2cPsf6IbMUmnA58DHgGuBB4GXgd8APigpI9GxMUdys4Fvgn8GVgK/AF4FTCH9CrE/SXNjToyq23Y8b1GvbI8Wdug1CzLo2lLWll8Z4fx6o6hNxX4I/BX4F8iYnXLsdnAT4D7I2Jah7r7AJsBSyLihbbz/RzYDjgsIq5o1SzLdnw3BrYnXc8/aw1MgIhYSnor9ys7FY2In0TEVa2BWexfBXyr+Oesrmo8Bu7Wmn6ykaR5wGuBJ4G7gWURsa4LrXuBZ4E9JG0TEQ+XByS9C3g5qatbJ88V2+dr1gUcnKa/TAUuatt3v6SjI+LmToQiYo2kzwNfA5ZLupI09pwOHAzcCHyyhjoDIOklwEeLf15Xl+6LiIjKHyDKTx167dp1azah6zborB2AU4B9SMmVTYHdSN3EF4CngN27qStwCLCmtR6ku+pH6mwD4KuF9pKmroWe/g/J5QJqQtdtUE87tFz0izutKylT+zzp7jmtCPqZwPWF5lfqaANgfqH3a2Drpq4FZ2tr1CvLk7UNSs2y3I22pNeR7nRrImJKq+5oepJmkR51LI6IOW3HNgV+B/wTsFNErBiv7jDnOQ74OrAc2DdSYqj9O87WmoGkzLRu1uHv3l9sl7YfiIinSI89NgDe3G3FJB1PCsxfAbOHC8w6cXCa3Chn8qwY9Vvrs1GxHelxSbn/2Y5rBBTJprOAu0iBuXqMn1TGwWl6jqRdJW09zP7tSXcmgE5n8txSbD8h6TVtuvsD7wCeBn7aoS6STgIWAL8gdWUfHuMnteAxZ416ZXmytkGpWZZH0pZ0KnAiqQt6P2mCwHTgQGBj4Brg0Ih4tuU3Y405NyAlfvYr9BYDq4BdSF1eAcdHxML2+o6heySwCFgHnEuactjOyohY1KpZlqu0r59zmn6wFHgDafy3F2l8+XfgVtJzz4uiw7tGRLwg6QDgOOBDwKGkbO0aUrCfExE3dFHXHYvthsDxI3znZlIA14rvnDXqleXJ2galZlmuu30nWxt4zGlMpjg4jckUB6cxmWL3PWMaJKts7WRNhjghNKRZlp0Qqoa7tcZkioPTmExxcI6CpNMl/VjSg4Xr2hpJd0o6RdKUsRV6Q9MOcXU72jWFpMMknSvpFkmPFU5+nU4DHM95jtCQU+Axdev/4zyehDDqd54FfklaHrSaNJNlT+CtwJ+APSPiwVKv/F2v20DSpxjZIW5L4ApgPYe4cbbBSI52B5NyFi9ytOvnmFPSXcDuJPe+h4CdgUsiYl4V3bbvbwf8H2nG0ObAsRFxfrtmWa7UBlUWg5YfBnShMbDxCPu/XPz3fiOHNiA5ChwEbNC2fyopUAP4YBe6U0lzSlcB27Ydm13orujFtTDO/1+zgZ1I82hnFfW4uK7rq9C9Cfg9cEahf8xwmnW0gbu1oxART49w6AfFdqde1WU0ojmHuEYc7ZoiIpZGxL1RREgDzCf9ITyaZEjWKA7O7jio2N7d11qMjyoOcS9ytGs90OJod1O16k0MJO1CWja2MCKW9eKcXpUyDiSdQBpfbEkab+5NCswF/azXWFR1iIseO9rlStGOF5GGCF/o1XkdnOPjBFKCpeQ64KiI+Guf6jNeFpBc7a6JiOu7EYiIswt39u8Cx7Ycug9Y1N7dHVBOJi1v2zsi1vbqpO7WjoOImBop6zaVlAGdBtwpaWZ/azYykuYDnwV+AxxRQedzwOWk9YrTSRnrt5BsRC6R9JXKlc0YSXuQ7pZnRsTtPT15XZk0BjBbO8pvtweeAX6VYxuQFhwHcA8wtVtdhjKePxzm2KakxxXrgGlNt0MXbVDWvetsLaln+VvSo7SN2o6dirO1+RERD5D+h+3anijpNzU7xDXuaJc5mwOvJ1mdPN0y8SBIptgA3yn2Dfe2tEp4zNk9ry623bzXoxGK5M0CkkPce6K6EVWjjnYTgGeAC0Y4NpP0R+lW0t21/i5vXV0OMunS1aVLml2yXpeQdKcoJyHclksbACcV5/8fhnEh77INDi80VwGvaTu2P+nVCWuBKU23Q6d6NDAJoe13p9Jwt9Z3zpF5H3CGpGWkGSGPkDK27yYlhFbx4uxl3ygc4k4j3cVvAeZL680aWxktDnHj5HLSc8z9gF9LGs7R7sSIeKT72teHpENI70qBlLwD2EvSoqL8cESc0POKdYmDc2RuAs4j+Z3uDmxFmhXyO9Izr3MiYk3/qvciGnGIi+Yc7ZpiBnBk275pxQfgAdJjsQmBJ77XqFeWJ2sblJplue72nWxt4GytMZni4DQmUyp3a23uZczodNu19Z3TmExxcBqTKc7W1qhXlidrG5SaZdnZWmdrjRlIBio4Jb1T0hWS/izpmWJ7Q/Eg3XRI065+ZnQGZoaQpC8C/0lyh7ua5ES3DWly8izSjBbTGXMZ2dXvfGB/Seu5+pl6GIgxp6S5JNOtm4A5EfF42/GXRsRzbfs85hzbcnMf0uLqJdFiHiZpKmm52HbAYRFxRatmWfaYc5KPOYuu1enAU8BH2gMToD0wzfiI5lz9zDgYhG7t20kTvy8H/ibpQJJvztPAz6PX1hKThyqufmYcDEJwvq3Y/oXkzv6m1oPFkq/DIn8zrglDVVc/Mz4mfLcW2LbYfgrYhLT28OWku+f1wLuAy/pTtYGlsqufGZtBCM4Ni61Id8gfR8QTEXEPaf3hQ8C7c3vpzkSlLlc/MzaDEJx/K7YrIuJ/Ww9E8hgt/7Lv0dNaDSCSjgMWkszNZme02HwgGYTg/G2x/fsIx8vg3aQHdRlYanb1M+NgEIJzGSljuJOklw1zfLdiu7JnNRowCle/s0iufrNjcri8950JH5yR7B+/T3qPycmtxyS9B/g34FGcVewKSSeREkC/APaN6nabZpwMygyhbYHbSC91vYU0e2V7UkIoSJMTLmv7jWcIjT1D6EiSKdg64FzSH7l2XuTq5xlC9bXBIDznJCJWS/pX4IukgNyT9O7IJcB/RcQd/azfBKYRVz8zPgbizpmDrttgSLMs+845yefWGjOoODiNyZTau7XGmCGySghN1vGWx5xDmmXZY85quFtrTKY4OI3JFAenMZky4YPTDnG9RdIRLa9fP6ZLjcMknSvpFkmPFVoX113XulDiY5LukPS4pKck3SlpvqQNx1bojkGYIWSHuB4haTvSNL4ngM0rSH2R9M7TJ0jrbXeuXrtGuZC0dnU1aR73k6RF/QuBdzV2fUVNrwQvP3XotWuPcXwf4CBgg7b9U0mBGsAHO9WdSG3QC13SYvabSG/5PoMKr1wHZgM7FZqzaPD18FXbgPSm7ABWANu07H8psLg4dlQT18KE7/KFHeJ6xXzSH8KjSXeOromIpRFxbxRXcubMKbZnRsuKnEiOjicV//x0Eyee8ME5BnaIqwFJu5CWjS2MiGX9rk+PmVpsVwxzrNw3U9JWdZ94YIPTDnH1ULTjRaQhwhf6XJ1+UN4tdxzm2LSWcu3j5oENTuwQVxcnk15pcVQkT6bJxtXF9jOSti53Fn+0vtTyvVfUfeJByNauhx3i6kHSHqS75Zkxec25LwXmAfsDyyX9iPR2gf2A6cC9pOTWurpPPHB3TjvE1UNLd/Z3DCU+Jh1FovFg4ARgFemP/cdIj4D2Bh4pvlq7r9JALbYuHOLOIjnE7RujGFF54vvoukWC42/DHRuGhRFxfKlZ7hxPnSXNIj2fviQi5nVT1ypU0ZW0CbCG9NhkyyKDa5uSdgqHuAUkh7j3hI2oqvIMcMEIx2aSxqG3kqxJJ2uX9whgY+DCaOBlWQMRnIVD3Gkkh7j3uitbnSL5M+z0PEmnkoLzwog4v5f16geStoiIx9r2vY10M3iCdO3VzoQPzsIh7jTSgPwWYL60Xk9iZbQ4xJn+IukQ0swbGHqOuJekRUX54Yg4oecVG5kbJa0lDZceB3YFDiD1LuZExHDPQCsz4YMTO8RNRGYAR7btm8bQc8MHSAmYXLgc+BApa7sJ8CfSvO0FEbGyqZMOVEKon7pugyHNslx3+062Nhi4RynGDAoOTmMyxe57xjRIVs85J+t4y2POIc2y7DFnNdytNSZTHJzGZIqDs8c0ZW7VLxOqbpB0VItJ2Eif2ld5dIuk0yX9WNKDhYHcmqJtT5E0pbHz+jlnfXpleTRdSXexvrlV5Unfkr7HkAnVVQyZUL0RuAJYz4SqX2NOSTMYmiHUzjtJdihLIuL9TdZ1vLqSngV+SVrptBrYjPSaybeSJiTsGREPtmqW5Up1rmJAVH4YcHOrOtuABsyt6MKEqqm2rXotkCbRB3BwLtcBsPEI+79c1PUbdbZB+XG3tsdEM+ZWfTOhqhNJu5HuSH8kvfg4CyLi6REO/aDY7tTEeR2cg0HfTKhq5pPF9oKIyGbMOQoHFdu7mxAfhInvpjMTqjuar07nFAuX5wEvkCaVZ4ekE0hm2luSxpt7kwJzQRPnc3AOBlcDHyaZUF0axXrWXphQ1cjhwFakRNCDY325T5xAeptAyXWksfxfmziZu7WDwaXAtSTDqeWSzpN0NskV4gCSCRU0YEJVI58ott/uay1GISKmRsq+TiWN86cBd0qa2cT5HJwDQPTRhKoOJL0ReDupvtf0uTpjEhF/iYjFwHuBKcD3mjiPu7UDQkQ8D5xZfP5BMZabAawF7ulD1cbDREsEARARD0haDsyQtE3U7FvlO+fgU5pQ/SAaMKGqiqSNSXV8gZENxXLm1cXWvrVmeCRtMcy+xk2oamAuKVF1TY6JIEk7S5o6zP4NJH0Z2Bb4aUSM10Z03Lhb22MaNLfqiwlVDZSJoPP6WouReR9whqRlpNcfPkLK2L6blBBaBRzbxIk9t7ZGvbI8mm5hK3nKKFIPRMQO7dpj1VXSf5BMqKYzZEJ1PaOYUPV7PafS28uWkxJBO4w23uzXdVDMWvp34B3AP5Me9zxJcsJfApwTbVasdcWDg7NGvbI8Wdug1CzLdbfvZGsDjzmNyRQHpzGZUrlba3MvY0an266t75zGZIqD05hMyT5bO1FwGyTcDpk9SjHG1I+7tcZkioPTmExxcBqTKQ5OYzLFwWlMpjg4jckUB6cxmeLgNCZTHJzGZIqD05hMcXAakykOTmMyxcFpTKY4OI3JlP8HTNtmcH0jeS0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sudoku_grid = '...............257...489..................582..3.28.14.6...2....2...41.9...19.7.3'\n",
    "#'48...2....5.......71..5..3...5....9.39.178.42.2....7...3..1..29.......8....6...17'\n",
    "#'2.............62....1....7...6..8...3...9...7...6..4...4....8....52.............3'\n",
    "plot_sudoku(grid2values(sudoku_grid))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "result = solve(sudoku_grid)\n",
    "plot_sudoku(result)"
   ]
  },
  {
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}