2021_02_Hooks7.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "Oq1xibzMT1Wl"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import time\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import requests\n",
    "from bs4 import BeautifulSoup\n",
    "import itertools\n",
    "from copy import deepcopy as dcopy,copy\n",
    "from skimage.morphology import label\n",
    "from scipy.ndimage import measurements\n",
    "from scipy.signal import convolve2d\n",
    "import sys\n",
    "import numba as nb\n",
    "from IPython.display import Markdown, display"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "ICTfvjZUT1Wr"
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "### Hooks #7\n",
       "\n",
       "Show Solution\n",
       "The grid above can be partitioned into 9 L-shaped “hooks”. The largest\n",
       "is 9-by-9 (contains 17 squares), the next largest is 8-by-8 (contains\n",
       "15 squares), and so on. The smallest hook is just a single square.\n",
       "Find where the hooks are located, and place nine 9’s in the largest\n",
       "hook, eight 8’s in the next-largest, etc., down to one 1 in the\n",
       "smallest hook.\n",
       "The filled squares must form a connected region. (Squares are\n",
       "“connected” if they are orthogonally adjacent.) Furthermore, every\n",
       "2-by-2 region must contain at least one unfilled square."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Hooks again but quite different to the previous ones.\n",
    "# 19 regions each which must add up to 15\n",
    "# same approch as hooks #5 &#6\n",
    "# -run through the hook placements to see which are allowed\n",
    "# -for each hook placement check the ones that are forced by \n",
    "#  the constraints\n",
    "# -solve the final cells with backtracking\n",
    "# using old code from hooks #6 but adding in some numba speed ups to the checks.\n",
    "# starting top right and looping cols then rows is much faster than starting top left\n",
    "# and looping rows then cols\n",
    "\n",
    "url='https://www.janestreet.com/puzzles/hooks-7-index/'\n",
    "res = requests.get(url)\n",
    "soup = BeautifulSoup(res.content, 'html.parser')\n",
    "y =[text for text in soup.body.stripped_strings]\n",
    "#display([(i,j) for i,j in enumerate(y)])\n",
    "display(Markdown(\"### \"+y[7]+\"\\n\\n\"+str(\"\\n\".join(y[9:12]))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U9Yh1D3HT1Ws"
   },
   "source": [
    "### Puzzle details\n",
    "<img src=\"https://www.janestreet.com/puzzles/20210217_hooks_7.png\" width=\"350\" height=\"300\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "0VI0NM6ET1Wt"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Setup the constraints\n",
    "# use 20 for the filled cells and treat as smaller \n",
    "# groups with a different total\n",
    "# then print the grid\n",
    "\n",
    "groups = np.array([[0 ,0 ,0 ,0 ,1 ,2 ,2 ,3 ,3 ],\n",
    "                   [0 ,0 ,6 ,0 ,1 ,2 ,3 ,3 ,4 ],\n",
    "                   [5 ,0 ,6 ,0 ,20,4 ,4 ,4 ,4 ],\n",
    "                   [5 ,5 ,6 ,6 ,0 ,4 ,8 ,9 ,9 ],\n",
    "                   [7 ,7 ,6 ,16,0 ,4 ,8 ,9 ,10],\n",
    "                   [18,7 ,16,16,15,8 ,8 ,10,10],\n",
    "                   [18,18,16,15,20,15,8 ,11,11],\n",
    "                   [17,17,16,15,14,13,13,12,12],\n",
    "                   [17,17,16,15,14,13,13,12,12]                   \n",
    "                 ])\n",
    "\n",
    "fixed = np.array([[0,0,0,0,0,0,0,0,0],\n",
    "                  [0,0,0,0,0,0,0,0,0],\n",
    "                  [0,0,0,0,4,0,0,0,0],\n",
    "                  [0,0,0,0,0,0,0,0,0],\n",
    "                  [0,0,0,0,0,0,0,0,0],\n",
    "                  [0,0,0,0,0,0,0,0,0],\n",
    "                  [0,0,0,0,5,0,0,0,0],\n",
    "                  [0,0,0,0,0,0,0,0,0],\n",
    "                  [0,0,0,0,0,0,0,0,0]\n",
    "                 ])\n",
    "\n",
    "def grid_print(groups,numbers):\n",
    "    fig,ax = plt.subplots(1,1,figsize=(3,3))\n",
    "    x = np.array((numbers).astype('int').astype('str'))\n",
    "    x[x==\"0\"] =\"-\"\n",
    "    ax = sns.heatmap(groups,annot=x,cbar=False,cmap=\"tab20\",fmt=\"\",linewidths=1)\n",
    "    ax.axis(\"off\")\n",
    "    plt.tight_layout()\n",
    "    \n",
    "grid_print(groups,fixed)\n",
    "\n",
    "# use -1 to denote unfilled\n",
    "fixed[fixed==0] =-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 374
    },
    "id": "zexQ8t1kT1W3",
    "outputId": "7c2aec4e-d2fb-45d8-fc7e-679051faafed"
   },
   "outputs": [],
   "source": [
    "class Matrix():\n",
    "    def __init__(self,groups):\n",
    "        self.groups = groups\n",
    "        self.potential_grids = [[-9,np.ones((9,9),dtype=int)*-1,[0,0,9,9]]] # list of all grids not yet ruled out.[Level,grid,coordinates of the grid yet to be filled]\n",
    "        self.solution = []\n",
    "        self.totals =np.array([11,15,15,15,15,15,15,15,15,15,15,15,15,15,15,10,15,15,15],dtype=int)\n",
    "        self.splits ={}\n",
    "        self.end_flag = 0\n",
    "        # work out the possible permutations for each group\n",
    "        for i in range(19):\n",
    "            length = np.sum(groups==i)\n",
    "            self.splits[i] =  np.array([list(i) for i in itertools.product([0, 1], repeat=length)],dtype=int)\n",
    "     \n",
    "    #########################################################\n",
    "    # Code to get the initial valid grids \n",
    "    # add layer by layer until it is not possible to create the sum \n",
    "    # for every filled group\n",
    "    def add_layer(self,grid,coords,lvl,alignment):\n",
    "        row_start,col_start,row_end, col_end = coords\n",
    "    \n",
    "        if alignment == 0:\n",
    "            grid[row_start:row_end,col_start] =lvl\n",
    "            grid[row_start,col_start:col_end] =lvl\n",
    "            row_start +=1\n",
    "            col_start +=1\n",
    "    \n",
    "        elif alignment == 1:\n",
    "            grid[row_start:row_end,col_start] =lvl\n",
    "            grid[row_end-1,col_start:col_end] =lvl\n",
    "            row_end -=1\n",
    "            col_start +=1 \n",
    "\n",
    "        elif alignment == 2:\n",
    "            grid[row_start:row_end,col_end-1] =lvl\n",
    "            grid[row_start,col_start:col_end] =lvl\n",
    "            row_start +=1\n",
    "            col_end -=1\n",
    "        \n",
    "        else: # alignment == 3:\n",
    "            grid[row_start:row_end,col_end-1] =lvl\n",
    "            grid[row_end-1,col_start:col_end] =lvl\n",
    "            row_end -=1\n",
    "            col_end -=1 \n",
    "    \n",
    "        coords = [row_start,col_start,row_end, col_end]\n",
    "        \n",
    "        return grid,coords\n",
    "    \n",
    "    def check_grid(self,grid):\n",
    "        # check the 2 fixed numbers\n",
    "        if (grid[2,4] !=-1) & (grid[2,4] !=4):\n",
    "            return False\n",
    "        if (grid[6,4] != -1) &(grid[6,4] != 5):\n",
    "            return False\n",
    "        \n",
    "        for i in range(19):\n",
    "            group = grid[groups==i]\n",
    "            if -1 not in group:\n",
    "                if not self.check_group(group,self.totals[i],self.splits[i]):\n",
    "                    return False\n",
    "\n",
    "        return True\n",
    "    \n",
    "    @staticmethod\n",
    "    @nb.njit(fastmath=True)\n",
    "    def check_group(group,param,splits):\n",
    "        for split in splits:\n",
    "            test = group * split\n",
    "            if np.sum(test) == param:\n",
    "                return True\n",
    "        return False\n",
    "    \n",
    "    @staticmethod\n",
    "    @nb.njit(fastmath=True)\n",
    "    def valid_group(pos,param):\n",
    "        if np.sum(pos) !=param:\n",
    "                return False\n",
    "        return True\n",
    "    \n",
    "    #########################################################\n",
    "    # Code to get the cells forced by the group params\n",
    "    # loop through all the splits for each group saving the valid ones\n",
    "    # for the digits common to all the valid plits set as forced\n",
    "    # done the 2 fixed cells manually\n",
    "    def forced_cells(self,hook):\n",
    "        forced = np.ones((9,9),dtype=int)*-1\n",
    "        forced[2,4] == 1\n",
    "        forced[6,4] == 1        \n",
    "        # loop through the params to determine forced cells\n",
    "        for i in range(19):\n",
    "            forced[self.groups==i] = self.forced_group(hook[self.groups==i],self.totals[i],self.splits[i])\n",
    "               \n",
    "        # Set the cell with 1 in as 1. Then loop through and fill in cells neeeded to ensure connectivity \n",
    "        forced[hook==1] =1\n",
    "        changes =1\n",
    "        while changes >0:\n",
    "\n",
    "            changes = 0\n",
    "            for i,j in itertools.product(range(9),range(9)):\n",
    "                if forced[i,j] == -1:\n",
    "                    test =forced*hook\n",
    "                    test[i,j] = 0\n",
    "                    if np.max(label(test!=0,connectivity=1)) > 1:\n",
    "                    #if placing zero would break connectivity set 1\n",
    "                        forced[i,j]=1\n",
    "                        changes =1\n",
    "        \n",
    "        test =forced*hook\n",
    "        # check that the forced cells do not violate the count\n",
    "        for i in range(1,10):\n",
    "            if np.sum(test==i) > i:\n",
    "                return 0,forced\n",
    "            \n",
    "        # check that the forced cells do not violate 2x2\n",
    "        if self.twobytwo(test):\n",
    "            return 0,forced\n",
    "        \n",
    "        # check that the forced cells do not violate connectivity\n",
    "        if np.max(label(forced!=0,connectivity=1)) > 1:\n",
    "            return 0,forced\n",
    "    \n",
    "        return  1,forced\n",
    "    \n",
    "    def forced_group(self,group,param,splits):\n",
    "        # loop through every split.Save the valid ones an then determine \n",
    "        # if any entries are common to all valid splits\n",
    "        poss_group =[]\n",
    "        length = len(splits[0])\n",
    "        for split in splits:\n",
    "            test = group * split\n",
    "            if self.valid_group(test,param):\n",
    "                    poss_group.append(split)\n",
    "        poss_array = np.array(poss_group)\n",
    "        forced = np.ones(length,dtype=int)*-1\n",
    "        for i in range(length):\n",
    "            if np.all(poss_array[:,i]==1):\n",
    "                forced[i] =1\n",
    "            elif np.all(poss_array[:,i]==0):\n",
    "                forced[i] =0\n",
    "        return forced\n",
    "    \n",
    "    def twobytwo(self, grid):\n",
    "        return np.any(convolve2d(grid > 0, np.ones((2, 2)), mode='valid') == 4)\n",
    "    \n",
    "    ########################################################\n",
    "    # Fill the final cells by backtracking\n",
    "    def fill_rest(self,grid,hooks):\n",
    "        for col,row in itertools.product(range(8,-1,-1),range(9)):\n",
    "            if grid[row,col]==-1:\n",
    "                for digit in range(2):\n",
    "                    if self.possible(digit,row,col,grid,hooks):\n",
    "                        grid[row,col] = digit\n",
    "                        self.fill_rest(grid,hooks)\n",
    "                        grid[row,col] = -1\n",
    "                return\n",
    "        sol_print(grid,hooks,self.groups)\n",
    "        print(\"The product of the areas is : {:,.0f}\".format(self.areas(grid)))\n",
    "        self.end_flag = 1\n",
    "             \n",
    "    def possible(self,digit,row,col,grid,hooks):\n",
    "        test = grid*hooks\n",
    "        test[row,col] = hooks[row,col]*digit\n",
    "    \n",
    "    #check the placement doesn't break connectivity\n",
    "        if np.max(label(test!=0,connectivity=1)) > 1:\n",
    "            return False\n",
    "        \n",
    "    #check the placement doesn't break 2 by 2\n",
    "        if self.twobytwo(test):\n",
    "            return False\n",
    "    \n",
    "     #check the placement doesn't exceed the permitted count of that number\n",
    "        if not self.count(test):\n",
    "            return False\n",
    "                \n",
    "    #check groups\n",
    "        if not self.group_count(test,self.totals,self.groups):\n",
    "            return False\n",
    "        return True\n",
    "    \n",
    "    @staticmethod\n",
    "    @nb.njit(fastmath=True)\n",
    "    def count(grid):\n",
    "        for num in range(2,10):\n",
    "            if np.sum(grid == num) > num:\n",
    "                   return False\n",
    "        return True\n",
    "    \n",
    "    @staticmethod\n",
    "    @nb.njit(fastmath=True)\n",
    "    def group_count(grid,totals,groups):\n",
    "        for i in range(19):\n",
    "            group = np.ravel(grid)[np.ravel(groups)==i]\n",
    "            if np.all(group > -1):\n",
    "                if np.sum(group) != totals[i]:\n",
    "                    return False\n",
    "        return True\n",
    "            \n",
    "    ##############################################\n",
    "    # Get the products of the areas of the connected cells\n",
    "    def areas(self,grid):\n",
    "        labels, num = measurements.label(grid==0)\n",
    "        areas = measurements.sum(grid==0, labels, index=range(1, num+1))\n",
    "        return np.prod(areas)\n",
    "\n",
    "    ###############################################\n",
    "    # Main solver.    \n",
    "    def solve(self):  \n",
    "        while len(self.potential_grids) > 0:\n",
    "            temp_grid = self.potential_grids.pop(0)\n",
    "            #create the potential rotations at the given level\n",
    "            rotations = []\n",
    "        \n",
    "            for alignment in range(3,-1,-1):\n",
    "                lvl,grid,coords = dcopy(temp_grid)\n",
    "                grid,coords = self.add_layer(grid,coords,-lvl,alignment)\n",
    "                if lvl != -1 :\n",
    "                    rotations.append([lvl+1,grid,coords])\n",
    "                else:\n",
    "                     rotations = [[lvl+1,grid,coords]]\n",
    "    \n",
    "            #check valid grids (where the sum can be made from available digits) and save the ones that work\n",
    "            for i in range(len(rotations)):\n",
    "                lvl,g,coords = rotations[i]\n",
    "                if self.check_grid(g):\n",
    "                    if lvl !=0:    \n",
    "                        self.potential_grids.append([lvl,g,coords])\n",
    "                    else:\n",
    "                        self.solution.append(g)                     \n",
    "                    \n",
    "        print(\"There are {} valid hook placements\\n\".format(len(self.solution)))\n",
    "\n",
    "        #solve each grid in the cut down list\n",
    "        forced_grids = []\n",
    "        for i in range(len(self.solution)):\n",
    "            #print(\"Checking: \",i+1)\n",
    "            hooks = self.solution[i]\n",
    "            if self.end_flag == 0:\n",
    "                flag,forced_grid = self.forced_cells(hooks)\n",
    "                if flag:\n",
    "                    #print(\"Checking: \",i+1)\n",
    "                #for valid forced grids solve the final matrix\n",
    "                    #sol_print(forced_grid,hooks,self.groups)\n",
    "                    #print(\"still to solve\",np.sum(forced_grid==-1))\n",
    "                    self.fill_rest(forced_grid,hooks)\n",
    "            else:\n",
    "                break\n",
    "            #else:\n",
    "                #print(\"***INCONSISTENT***\")\n",
    "\n",
    "                \n",
    "#########################\n",
    "# Code to print in a \"nice\" format\n",
    "                            \n",
    "def sol_print(solved,matrix,groups):\n",
    "    fig,ax = plt.subplots(1,2,figsize=(6,3))\n",
    "    x = np.array((solved*matrix).astype('int').astype('str'))\n",
    "    x[x==\"0\"] =\"-\"\n",
    "    groups_fixed = dcopy(groups)\n",
    "    groups_fixed[2,4] = 0\n",
    "    groups_fixed[6,4] = 15\n",
    "    ax1 =sns.heatmap(matrix,annot=x,cbar=False,cmap=\"Pastel1_r\",fmt=\"\",linewidths=1,ax=ax[0])\n",
    "    ax2 =sns.heatmap(groups_fixed,annot=x,cbar=False,cmap=\"tab20\",fmt=\"\",linewidths=1,ax=ax[1])\n",
    "    ax1.axis(\"off\")\n",
    "    ax2.axis(\"off\")\n",
    "    plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 374
    },
    "id": "zexQ8t1kT1W3",
    "outputId": "7c2aec4e-d2fb-45d8-fc7e-679051faafed"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 172 valid hook placements\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/gh/y4xlwd0d05xc91xhsql5lf0w0000gn/T/ipykernel_9556/3348797895.py:202: DeprecationWarning: Please use `label` from the `scipy.ndimage` namespace, the `scipy.ndimage.measurements` namespace is deprecated.\n",
      "  labels, num = measurements.label(grid==0)\n",
      "/var/folders/gh/y4xlwd0d05xc91xhsql5lf0w0000gn/T/ipykernel_9556/3348797895.py:203: DeprecationWarning: Please use `sum` from the `scipy.ndimage` namespace, the `scipy.ndimage.measurements` namespace is deprecated.\n",
      "  areas = measurements.sum(grid==0, labels, index=range(1, num+1))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The product of the areas is : 2,200\n",
      "Solution took 3.0541 seconds\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "start = time.perf_counter()\n",
    "test = Matrix(groups)\n",
    "test.solve()\n",
    "stop =  time.perf_counter()\n",
    "print('Solution took {:0.4f} seconds'.format((stop-start)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 374
    },
    "id": "zexQ8t1kT1W3",
    "outputId": "7c2aec4e-d2fb-45d8-fc7e-679051faafed"
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "### February 2021 : Solution\n",
       "\n",
       "Here is the completed grid for this Hooks puzzle, which when you take\n",
       "the product of the sizes of the empty regions gives\n",
       "2200\n",
       "."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "url='https://www.janestreet.com/puzzles/hooks-7-solution/'\n",
    "res = requests.get(url)\n",
    "soup = BeautifulSoup(res.content, 'html.parser')\n",
    "y =[text for text in soup.body.stripped_strings]\n",
    "#display([(i,j) for i,j in enumerate(y)])\n",
    "display(Markdown(\"### \"+y[8]+\"\\n\\n\"+str(\"\\n\".join(y[10:13]))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ld_NFUIfT1W9"
   },
   "source": [
    "### Puzzle solution\n",
    "<img src=\"https://www.janestreet.com/puzzles/20210228_hooks_7_ans-1.png\" width=\"300\" >"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "include_colab_link": true,
   "name": "JaneSt-Feb18.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3.11.1 64-bit",
   "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.11.1"
  },
  "vscode": {
   "interpreter": {
    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}