sudoku.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "sudoku.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyPSHkvY0niP7mYIAkWiJW/O",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/matteonerini/sudoku-generator-and-solver/blob/main/sudoku.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-9hwW-4cpN4h"
      },
      "source": [
        "# Sudoku Generator and Solver\r\n",
        "\r\n",
        "Sudoku is a logic-based puzzle in which the objective is to fill a 9x9 grid with numerical digits from 1 to 9. Each row, each column, and each 3x3 region must contain all the digits from 1 to 9.\r\n",
        "\r\n",
        "In this script, we propose simple yet interesting recucrsive algorithms to find all the solutions of a given Sudoku, and to generate new puzzles such that they have a unique solution."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SNMIUH1Jx2C6"
      },
      "source": [
        "# Import relevant libraries\r\n",
        "import numpy as np\r\n",
        "from random import randint, shuffle\r\n",
        "import matplotlib.pyplot as plt\r\n",
        "import math\r\n",
        "\r\n",
        "# Utility variables\r\n",
        "d = 9\r\n",
        "d_sqrt = int(math.sqrt(d))\r\n",
        "numbers = list(range(1,d+1))\r\n",
        "cells = list(range(d**2))\r\n",
        "\r\n",
        "# Check if the cell 'grid[y,x]' can assume the value 'n'\r\n",
        "def possible(grid,y,x,n):\r\n",
        "    # Check if 'n' is already in row 'y' or in column 'x'\r\n",
        "    for i in range(d):\r\n",
        "        if grid[y][i] == n or grid[i][x] == n:\r\n",
        "            return False\r\n",
        "    # Check if 'n' is already in the 3x3 region\r\n",
        "    y0 = y - (y % d_sqrt)\r\n",
        "    x0 = x - (x % d_sqrt)\r\n",
        "    for i in range(d_sqrt):\r\n",
        "        for j in range(d_sqrt):\r\n",
        "            if grid[y0 + i][x0 + j] == n:\r\n",
        "                return False\r\n",
        "    return True\r\n",
        "\r\n",
        "# Backtracking algorithm implementation to solve a Sudoku\r\n",
        "def solve(grid):\r\n",
        "    global grid_solved\r\n",
        "    global n_solutions\r\n",
        "    for y in range(d):\r\n",
        "        for x in range(d):\r\n",
        "            if grid[y][x] == 0:\r\n",
        "                for n in range(1,d+1):\r\n",
        "                    if possible(grid,y,x,n):\r\n",
        "                        grid[y][x] = n\r\n",
        "                        solve(grid)\r\n",
        "                        grid[y][x] = 0\r\n",
        "                return\r\n",
        "    print(grid)\r\n",
        "    #input(\"More solutions?\")\r\n",
        "    #grid_solved = np.copy(grid)\r\n",
        "    n_solutions+=1\r\n",
        "\r\n",
        "# Faster implementation of the backtraking algorithm whose objective is to\r\n",
        "# determine if the Sudoku does not have a unique solution\r\n",
        "def solve_fast(grid):\r\n",
        "    global grid_solved\r\n",
        "    global n_solutions\r\n",
        "    global end_solver\r\n",
        "    for y in range(d):\r\n",
        "        for x in range(d):\r\n",
        "            if grid[y][x] == 0:\r\n",
        "                for n in range(1,d+1):\r\n",
        "                    if possible(grid,y,x,n):\r\n",
        "                        grid[y][x] = n\r\n",
        "                        solve_fast(grid)\r\n",
        "                        if not(end_solver):\r\n",
        "                            grid[y][x] = 0\r\n",
        "                return\r\n",
        "    #print(grid)\r\n",
        "    n_solutions+=1\r\n",
        "    if n_solutions == 2:\r\n",
        "        end_solver = True\r\n",
        "\r\n",
        "# Randomly fill an empty grid with dimension d\r\n",
        "def fill(grid):\r\n",
        "    global grid_filled\r\n",
        "    for y in range(d):\r\n",
        "        for x in range(d):\r\n",
        "            if grid[y][x] == 0:\r\n",
        "                shuffle(numbers)\r\n",
        "                for n in numbers:\r\n",
        "                    if possible(grid,y,x,n):\r\n",
        "                        grid[y][x] = n\r\n",
        "                        if not(np.all(grid)):\r\n",
        "                            fill(grid)\r\n",
        "                            grid[y][x] = 0\r\n",
        "                        else:\r\n",
        "                            grid_filled = np.copy(grid)\r\n",
        "                return\r\n",
        "\r\n",
        "# Create a Sudoku from a fully filled grid\r\n",
        "def create(grid):\r\n",
        "    global n_solutions\r\n",
        "    global end_solver\r\n",
        "    shuffle(cells)\r\n",
        "    for i in range(d**2):\r\n",
        "        y = cells[i] // d\r\n",
        "        x = cells[i] % d\r\n",
        "        backup = grid[y][x]\r\n",
        "        grid[y][x] = 0\r\n",
        "        grid_copy = np.copy(grid)\r\n",
        "        n_solutions = 0\r\n",
        "        end_solver = False\r\n",
        "        solve_fast(grid_copy)\r\n",
        "        if n_solutions != 1:\r\n",
        "            grid[y][x] = backup\r\n",
        "        #print('\\b\\b\\b\\b{:03d}'.format(i+1) )\r\n",
        "\r\n",
        "# Substitute '0' with ' ' in a grid\r\n",
        "def get_grid_str(i):\r\n",
        "    return ' ' if i == 0 else '{}'.format(i)\r\n",
        "\r\n",
        "# Plot the grid to create an enjoyable Sudoku\r\n",
        "def grid2pdf(grid):\r\n",
        "    grid_str = np.vectorize(get_grid_str)(grid)\r\n",
        "    # Create a figure\r\n",
        "    fig, ax = plt.subplots()\r\n",
        "    im = ax.imshow(grid,cmap='binary', vmin=255, vmax=255)\r\n",
        "    # Add the Sudoku clues to the figure\r\n",
        "    for i in range(d):\r\n",
        "        for j in range(d):\r\n",
        "            text = ax.text(j, i, grid_str[i,j],\r\n",
        "                           ha='center', va='center', color='k')\r\n",
        "    # Add the lines\r\n",
        "    plt.axhline(y=-0.5, linewidth=5, color='k')\r\n",
        "    plt.axvline(x=-0.5, linewidth=5, color='k')\r\n",
        "    for i in range(d-1):\r\n",
        "        if (i+1) % d_sqrt == 0:\r\n",
        "            plt.axhline(y=i+0.5, linewidth=3, color='k')\r\n",
        "            plt.axvline(x=i+0.5, linewidth=3, color='k')\r\n",
        "        else:\r\n",
        "            plt.axhline(y=i+0.5, linewidth=1, color='k')\r\n",
        "            plt.axvline(x=i+0.5, linewidth=1, color='k')           \r\n",
        "    plt.axhline(y=d-0.5, linewidth=5, color='k')\r\n",
        "    plt.axvline(x=d-0.5, linewidth=5, color='k')\r\n",
        "    # Plot the figure without axis\r\n",
        "    plt.axis('off')\r\n",
        "    plt.savefig('sudoku.pdf', bbox_inches='tight')\r\n",
        "    plt.savefig('sudoku.png', bbox_inches='tight')"
      ],
      "execution_count": 39,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P-h_of6Xi4ip"
      },
      "source": [
        "## Sudoku Resolution\r\n",
        "\r\n",
        "The function `solve`, implementing the backtraking algorithm, is called to solve a given Sudoku, specified by the variable `grid`. Thus, all the possible solutions, i.e. the complete grids, are showed."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2BU1IwTglmt9",
        "outputId": "58c41da0-e229-4bf3-9da7-274dcfe2d80e"
      },
      "source": [
        "# Input grid\r\n",
        "d = 9\r\n",
        "grid = np.array([[5, 3, 0, 0, 7, 0, 0, 0, 0],\r\n",
        "                 [6, 0, 0, 1, 9, 5, 0, 0, 0],\r\n",
        "                 [0, 9, 8, 0, 0, 0, 0, 6, 0],\r\n",
        "                 [8, 0, 0, 0, 6, 0, 0, 0, 3],\r\n",
        "                 [4, 0, 0, 8, 0, 3, 0, 0, 1],\r\n",
        "                 [7, 0, 0, 0, 2, 0, 0, 0, 6],\r\n",
        "                 [0, 6, 0, 0, 0, 0, 2, 8, 0],\r\n",
        "                 [0, 0, 0, 4, 1, 9, 0, 0, 5],\r\n",
        "                 [0, 0, 0, 0, 8, 0, 0, 7, 9]])\r\n",
        "\r\n",
        "# Utility variables\r\n",
        "d_sqrt = int(math.sqrt(d))\r\n",
        "numbers = list(range(1,d+1))\r\n",
        "cells = list(range(d**2))\r\n",
        "\r\n",
        "n_solutions = 0\r\n",
        "print('Solution(s):\\n')\r\n",
        "solve(grid)\r\n",
        "#print(grid_solved)\r\n",
        "print('\\nNumber of solutions:', n_solutions)"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Solution(s):\n",
            "\n",
            "[[5 3 4 6 7 8 9 1 2]\n",
            " [6 7 2 1 9 5 3 4 8]\n",
            " [1 9 8 3 4 2 5 6 7]\n",
            " [8 5 9 7 6 1 4 2 3]\n",
            " [4 2 6 8 5 3 7 9 1]\n",
            " [7 1 3 9 2 4 8 5 6]\n",
            " [9 6 1 5 3 7 2 8 4]\n",
            " [2 8 7 4 1 9 6 3 5]\n",
            " [3 4 5 2 8 6 1 7 9]]\n",
            "\n",
            "Number of solutions: 1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eiNGm1yqo4yA"
      },
      "source": [
        "## Sudoky Generation\r\n",
        "\r\n",
        "The generation of a Sudoku with unique solution takes place according to the following steps:\r\n",
        "1. Generate a completely filled grid which satisfies the Sudoku rules with the function `fill`. This will be the unique solution of our Sudoku.\r\n",
        "2. Iteratively, remove one random element from the grid.\r\n",
        "3. Find the number of solutions of the new obtained grid with the function `solve_fast`, a simplified Sudoku solver.\r\n",
        "4. If the grid has no longer a unique solution, reinsert the removed element.\r\n",
        "5. Return to Step 2 until a certain number of iteraction is reached. The higher this number, the more difficult is the generated Sudoku since more cells are removed."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 860
        },
        "id": "Ya32y5hxpFrC",
        "outputId": "a7a9e755-2606-4890-b6c3-f27c5f346bf5"
      },
      "source": [
        "# Insert the dimension 'd'. Possible values: 4, 9, 16\r\n",
        "d = 9\r\n",
        "\r\n",
        "# Utility variables\r\n",
        "d_sqrt = int(math.sqrt(d))\r\n",
        "numbers = list(range(1,d+1))\r\n",
        "cells = list(range(d**2))\r\n",
        "grid_empty = np.zeros((d,d), dtype=int)\r\n",
        "\r\n",
        "# Fill randomly the empty grid\r\n",
        "fill(grid_empty)\r\n",
        "print('Filled grid randomly generated:')\r\n",
        "print(grid_filled, '\\n')\r\n",
        "\r\n",
        "# Create a Sudoku\r\n",
        "print('Generated Sudoku:')\r\n",
        "#print('Progress (/', d**2, '):   ')\r\n",
        "create(grid_filled)\r\n",
        "print(grid_filled)\r\n",
        "print('Number of clues:', np.count_nonzero(grid_filled), '\\n')\r\n",
        "\r\n",
        "# Solve the created Sudoku\r\n",
        "n_solutions = 0\r\n",
        "print('Solution:')\r\n",
        "solve(grid_filled)\r\n",
        "#print(grid_solved)\r\n",
        "print('Number of solutions:', n_solutions, '\\n')\r\n",
        "\r\n",
        "# Print the created Sudoku\r\n",
        "print('Printed generated Sudoku:')\r\n",
        "grid2pdf(grid_filled)"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Filled grid randomly generated:\n",
            "[[1 6 7 4 8 9 2 3 5]\n",
            " [8 3 9 7 5 2 6 4 1]\n",
            " [4 2 5 3 6 1 9 7 8]\n",
            " [2 4 3 6 1 5 7 8 9]\n",
            " [9 7 6 2 3 8 1 5 4]\n",
            " [5 8 1 9 4 7 3 6 2]\n",
            " [3 1 2 8 7 4 5 9 6]\n",
            " [7 5 4 1 9 6 8 2 3]\n",
            " [6 9 8 5 2 3 4 1 7]] \n",
            "\n",
            "Generated Sudoku:\n",
            "[[1 0 7 0 0 9 0 0 5]\n",
            " [0 0 0 0 0 2 0 4 0]\n",
            " [0 0 0 0 0 1 9 0 0]\n",
            " [0 4 0 6 0 0 0 0 0]\n",
            " [9 7 0 0 0 8 1 0 0]\n",
            " [0 8 0 0 4 0 3 0 0]\n",
            " [3 0 0 0 0 4 0 9 0]\n",
            " [0 0 0 0 0 0 8 0 0]\n",
            " [0 0 0 5 0 0 0 0 7]]\n",
            "Number of clues: 23 \n",
            "\n",
            "Solution:\n",
            "[[1 6 7 4 8 9 2 3 5]\n",
            " [8 3 9 7 5 2 6 4 1]\n",
            " [4 2 5 3 6 1 9 7 8]\n",
            " [2 4 3 6 1 5 7 8 9]\n",
            " [9 7 6 2 3 8 1 5 4]\n",
            " [5 8 1 9 4 7 3 6 2]\n",
            " [3 1 2 8 7 4 5 9 6]\n",
            " [7 5 4 1 9 6 8 2 3]\n",
            " [6 9 8 5 2 3 4 1 7]]\n",
            "Number of solutions: 1 \n",
            "\n",
            "Printed generated Sudoku:\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAQtklEQVR4nO3dX0xT5/8H8HelbgluKGQWtQ7qTNDSIyvFrFliIGpoTOYuEFxASdyEmOxqXphwsWS7WeJitkg13qiLFzOxF0sTGaJxwCYMx4j4J7IQolMmxWUYIlNbCbQ+v4v9ytfvvqWc2lOf58D7lTQxDj7PJ4+8dw7nnH5qEUKAiNSzSHYDRJQYw0mkKIaTSFEMJ5GiGE4iRVmT/UeLxcJLuUQZJoSwJPp7HjmJFMVwEikq6Wnt8zLxsILFYslI3Ze1hsXyn7ORTK6RyT3i/sir//z+JMIjJ5GiGE4iRTGcRIpiOIkUZUg49+7dC5vNBk3TjCj30g0NDcHtds+8cnJy0NzcLLst5fj9fmiaBpfLxf1JwOFwYMOGDXC73di4cWP6BYUQs74AiPgrmUuXLon+/n7hcrmSft2/zVXXCKmuEY1GRX5+vhgeHtZVW8/+pCPTe6S3/s2bN4XL5RLhcFhMT0+LrVu3ilu3bs1Ze6HsjxBCFBYWigcPHqRU+//rJ8yfIUfO8vJy5OXlGVFKuo6ODqxduxaFhYWyW1HK4OAgvF4vsrOzYbVaUVFRgWAwKLuteY2/c/5LIBBAXV2d7DaUo2kauru7MT4+jkgkgra2NoyMjMhuSykWiwU+nw9lZWU4fvx42vV0P4SwEExNTaGlpQUHDx6U3YpynE4nmpqa4PP5sGTJErjdbmRlZcluSyk///wz7HY7xsbGUFlZifXr16O8vPyF6/HI+Zzz58/D4/EgPz9fditKamhoQH9/P7q6upCbm4uioiLZLSnFbrcDAGw2G6qqqtDX15dWPYbzOWfOnOEpbRJjY2MAgHv37iEYDGLXrl2SO1JHOBzG48ePZ/588eLF9O9ezHalSKRwtba2tlasWLFCWK1WYbfbxcmTJ3Vfrco0vWs8efJE5OXliYmJiZRq69mfdGR6j1Kpv2nTJuF0OkVJSYlob2/XVXuh7M/vv/8uSkpKRElJiSguLhZffPGFrtpIcrXWIpI81Pv8+zmTfd2L4oPv+tbI5B5xf+TVj++P4Ps5icyF4SRSFMNJpCiGk0hRDCeRohhOIkUxnESKYjiJFKX7IQQiyozZHkLgaMw0a8fxCZjEteO4P4lrJ8PTWiJFMZxEimI4iRTFcBIpiuEkUhTDSbqMjIxg8+bNKC4uhsvlgt/vl93SC4nFYigtLcX27dtltzInDvgiXaxWK77++mt4PB48fvwYZWVlqKysRHFxsezWUuL3++F0OvHo0SPZrcyJR07SZeXKlfB4PACA119/HU6nE6Ojo5K7Sk0oFMK5c+fQ2NgouxVdGE5K2fDwMK5duwav1yu7lZTs378fhw4dwqJF5vixN0eXpIwnT56guroazc3NyMnJkd2Obq2trbDZbCgrK5Pdim4MJ+k2PT2N6upq7N69Gzt27JDdTkp6enrQ0tICh8OB2tpadHZ2or6+XnZbSXH6Xpq14+b7s6NCCOzZswd5eXm6P2FM1f356aef8NVXX6G1tTUj9fXi9D0yRE9PD7799lt0dnbOfFRiW1ub7LbmNR4506wdp9KRQZX63J+5awM8chKZDsNJpCiGk0hRDCeRohhOIkUxnESKYjiJFMVwEimKc2uJJOPc2gzVjuMTMIlrx3F/EtdOhqe1RIpiOIkUxXASKYrhJFIUw0mkKIaTSFEMJ+myd+9e2Gw2aJqWsTX8fj80TYPL5dI9CmU+YzhJlw8//BAXLlzIWP2BgQGcOHECfX19uHHjBlpbW3H79u2MrWcGDCfpUl5ejry8vIzVHxwchNfrRXZ2NqxWKyoqKhAMBjO2nhkwnKQETdPQ3d2N8fFxRCIRtLW1YWRkRHZbUvGzUkgJTqcTTU1N8Pl8WLJkCdxuN7KysmS3JRWPnKSMhoYG9Pf3o6urC7m5uSgqKpLdklQ8cpIyxsbGYLPZcO/ePQSDQfT29spuSSoeOUmXuro6vPvuuxgaGsLq1avxzTffGL5GdXU1iouL8f777+PYsWNYtmyZ4WuYCYdKp1k7jm+JSlw7jvuTuDbAodJEpsNwEimK4SRSFMNJpCiGk0hRDCeRojgak0gy3kohMhmGk0hRHCqdZu04PgGTuHYc9ydx7WR45CRSFMNJpCiGk0hRDCeRohhOIkWZKpyxWAylpaXYvn277FZSNjExgZqaGqxfvx5OpxO//PKL7JZIcaYaU+L3++F0OvHo0SPZraTsk08+wbZt2/Ddd99hamoKkUhEdkukONMcOUOhEM6dO4fGxkbZraTs77//RldXFxoaGgAAr7zyyoIfwUFzM0049+/fj0OHDmHRItO0POPu3btYvnw5PvroI5SWlqKxsRHhcFh2W6Q4U/ykt7a2wmazoaysTHYrLyQajeLq1av4+OOPce3aNSxZsgRffvml7LZIcaYIZ09PD1paWuBwOFBbW4vOzk7U19fLbku31atXY/Xq1fB6vQCAmpoaXL16VXJXpDpThPPgwYMIhUIYHh5GIBDAli1bcPr0adlt6bZixQq8+eabGBoaAgB0dHSguLhYclekOlNdrTWzo0ePYvfu3ZiamsJbb72FU6dOyW6JFMe5tWnWjuO7LhLXjuP+JK4N8M3WRKbDcBIpiuEkUhTDSaQohpNIUQwnkaIYTiJFcag0kWSz3efkaMw0a8fxJnvi2nHcn8S1k+FpLZGiGE4iRTGcRIpiOIkUxXASKYrhJFKUYeH0+/3QNA0ulwvNzc1GlQUADA0Nwe12z7xycnIMX4PmdvjwYbhcLmiahrq6OkxOThpWe+/evbDZbNA0zbCapieEmPUFQMRfydy8eVO4XC4RDofF9PS02Lp1q7h161bS7xH/LDDn1/xbNBoV+fn5Ynh4WNfXv8gaeundn3TXyCS99UOhkHA4HCISiQghhNi5c6c4derUnLX17s+lS5dEf3+/cLlcuvp5fo1Mehk/P2KW/Bly5BwcHITX60V2djasVisqKioQDAaNKP0/Ojo6sHbtWhQWFmakPs0uGo3i6dOniEajiEQiWLVqlWG1y8vLkZeXZ1i9+cCQcGqahu7uboyPjyMSiaCtrQ0jIyNGlP4fgUAAdXV1GalNs7Pb7Thw4AAKCgqwcuVKLF26FD6fT3Zb85oh4XQ6nWhqaoLP58O2bdvgdruRlZVlROn/MjU1hZaWFuzcudPw2pTcw4cPcfbsWdy9exf3799HOBw21QREMzLsglBDQwP6+/vR1dWF3NxcFBUVGVV6xvnz5+HxeJCfn294bUquvb0da9aswfLly7F48WLs2LEDly9flt3WvGZYOMfGxgAA9+7dQzAYxK5du4wqPePMmTM8pZWkoKAAvb29iEQiEEKgo6MDTqdTdlvz22xXikQKV2uFEGLTpk3C6XSKkpIS0d7ervtqlV5PnjwReXl5YmJiQvf3pLpGqlLZn3TWyKRU6n/22Wdi3bp1wuVyifr6ejE5OTlnbb37U1tbK1asWCGsVquw2+3i5MmTunpSaX9epDaSXK3l3No0a8dlco1M7hH3R159zq0lMimGk0hRDCeRohhOIkUxnESKYjiJFMVwEimKc2uJJJvtPifn1qZZO4432RPXjuP+JK6dDE9riRTFcBIpiuEkUhTDSaQohpNIUQwnkaJME85MzkydL2KxGEpLS7F9+3bZraRscnIS77zzDt5++224XC58/vnnsluSzhThHB0dxZEjR3DlyhUMDAwgFoshEAjIbks5fr/ftKNDXn31VXR2duLGjRu4fv06Lly4gN7eXtltSWWKcAKZnZk6H4RCIZw7dw6NjY2yW3khFosFr732GgBgenoa09PTc96kn+9MEU7OTJ3b/v37cejQISxaZIp/0oRisRjcbjdsNhsqKyvh9XpltySVKf4lOTM1udbWVthsNpSVlcluJS1ZWVm4fv06QqEQ+vr6MDAwILslqUwRTs5MTa6npwctLS1wOByora1FZ2cn6uvrZbf1wpYtW4bNmzfjwoULsluRyhTh5MzU5A4ePIhQKITh4WEEAgFs2bLFdGcWDx48wMTEBADg6dOn+OGHH7B+/XrJXcml+10pMnm9XtTU1MDj8cBqtaK0tBT79u2T3RYZ6M8//8SePXsQi8Xw7NkzfPDBB6a8JWQkzq1Ns3Yc3xKVuHYc9ydxbYBza4lMh+EkUhTDSaQohpNIUQwnkaIYTiJFcTQmkWS8lUJkMgwnkaI4VDrN2nF8AiZx7TjuT+LayfDISaQohpNIUQwnkaIYTiJFMZxEijIknJw5ujCYeS4u8M/oUE3T4HK50NzcLLudORkSTs4cXRjMPBd3YGAAJ06cQF9fH27cuIHW1lbcvn1bdltJGRJOzhyd/8w+F3dwcBBerxfZ2dmwWq2oqKhAMBiU3VZShv3OyZmj85vZ5+Jqmobu7m6Mj48jEomgra0NIyMjsttKyrCd5szR+Ws+zMV1Op1oamqCz+fDtm3b4Ha7kZWVJbutpAz/3yBnjs4/82UubkNDA/r7+9HV1YXc3FwUFRXJbik5IcSsLwAi/kpmbGxMPHz4UAghRCQSEZs2bRLff/990u8R/yww59ekK5Nr6N2fdNfIpFTr//jjj+K9997TXVul/fnrr7+EEEL88ccfYt26dTM/s0bVT9Vze5Mwf4bMreXMUTKD6upqjI+PY/HixTh27BiWLVsmu6WkOLc2zdpxmVwjk3vE/ZFXn3NriUyK4SRSFMNJpCiGk0hRDCeRohhOIkUxnESK4lBpIslmu8/J0Zhp1o7jTfbEteO4P4lrJ8PTWiJFMZxEimI4iRTFcBIpiuEkUhTDSaQohpOUcfjwYbhcLmiahrq6OkxOTspuSSqGk5QwOjqKI0eO4MqVKxgYGEAsFkMgEJDdllQMJykjGo3i6dOniEajiEQiWLVqleyWpGI4SQl2ux0HDhxAQUEBVq5ciaVLl8Ln88luSyqGk5Tw8OFDnD17Fnfv3sX9+/cRDodx+vRp2W1JxXCSEtrb27FmzRosX74cixcvxo4dO3D58mXZbUnFcJISCgoK0Nvbi0gkAiEEOjo6TPuhSUZhOEkJXq8XNTU18Hg82LBhA549e4Z9+/bJbksqzq1Ns3Yc3xKVuHYc9ydxbYBza4lMh+EkUhTDSaQohpNIUQwnkaIYTiJFMZxEimI4iRTFodJEknGodIZqx/EJmMS147g/iWsnw9NaIkUxnESKYjiJFMVwEimK4SRSFMNJpCiG8yVxOBzYsGED3G43Nm7cKLsdMtjQ0BDcbvfMKycnB83NzWnV5CSENGvHzbWGw+HAlStX8MYbb6S8xny4j7eQ7nPGYjHY7Xb8+uuvKCwsTFob4CQEopemo6MDa9euTRpMPRjOl8RiscDn86GsrAzHjx+X3Q5lUCAQQF1dXdp1eFqbZu24udYYHR2F3W7H2NgYKisrcfToUZSXl+taQ7XTtlRqxy2U09qpqSmsWrUKv/32G/Lz8+esDfC0Vjq73Q4AsNlsqKqqQl9fn+SOKBPOnz8Pj8czZzD1YDhfgnA4jMePH8/8+eLFi9A0TXJXlAlnzpwx5JQW4Glt2rXjkq1x584dVFVVAfjnk7R27dqFTz/9VPcaKp22pVo7biGc1obDYRQUFODOnTtYunSprtrA7Ke1DGeateMWwg/fi9SO4/4krg3wd04i02E4iRTFcBIpiuEkUhTDSaQoTt8jkoxXa4lMJumRk4jk4ZGTSFEMJ5GiGE4iRTGcRIpiOIkUxXASKer/AG3kAFescN6zAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u7agI_Zva_ow"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}