ipynb/xkcd-Name-Dominoes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align:right\">Peter Norvig<br>21 March 2018</div>\n",
    "\n",
    "# `xkcd` Name Dominoes\n",
    "\n",
    "The March 21, 2018 `xkcd` comic (#1970) was [Name Dominoes](https://xkcd.com/1970/): domino tiles laid out as if in a game, but the tiles contain names of famous people rather than numbers. \n",
    "In [dominoes](https://en.wikipedia.org/wiki/Dominoes) each tile has two halves, and a tile can be legally placed only if  one half is adjacent to another tile half with the same number/name, and neither half is adjacent to a tile half with a different number/name. (Exception: the very first tile can be placed anywhere.) \n",
    "\n",
    "I will write a function to lay out tiles in a random, legal array.  First, the key data structures:\n",
    "\n",
    "- **`Tile`**: a tile is a 2-element tuple of names, like `('TIM', 'COOK')`.\n",
    "The tile `('FRANK LLOYD', 'WRIGHT')` has a space in the first name.\n",
    "- **`Name`**: a name (first name or last name) is a string.\n",
    "- **`Board(width, height)`**: a `Board` represents\n",
    "a width × height array of squares, initially `empty`, but  when we put a tile on the board,\n",
    "the first name covers one location and the last name covers an adjacent location, e.g. `board[0, 0], board[0, 1] = ('TIM', 'COOK')`. Implemented as a subtype of `dict` that keeps track of `width` and `height`.\n",
    "- **`Location`**: a location is an `(x, y)` pair of coordinates for a square on the board.\n",
    "\n",
    "Now I need a strategy to fill the board with tiles.  I will randomly place tiles one at a time, and to make things easier I will *not* consider removing a tile from the board and backtracking. Some more concepts and functions:\n",
    "\n",
    "- **`frontier`**: I'll maintain a *frontier*, a set of locations that are adjacent to tiles on the board, and thus are candidates for placing new tiles.\n",
    "- **`dominoes(tiles)`**: makes a board and places tiles on it, one at a time, until no more can be placed. Chooses a random tile for the first tile, then repeatedly calls `try_one` to legally place an additional tile, stopping when either there is no `frontier` left (meaning no place to legally place a tile) or no `tiles` left to place.\n",
    "- **`try_one(tiles, board, frontier)`**: pop a location off the frontier, and try to find some tile that can legally put one of its halves there; when found, `put` the tile there, and remove it from `tiles`.\n",
    "- **`legal(name, loc, board)`**: a name can be placed if the location is empty, and there are no conflicts with any neighboring location.\n",
    "- **`neighbors(loc, board)`**: returns the (up to 4) neighbors of a location that are on the board.\n",
    "- **`put_tile(board, loc0, loc1, tile, frontier)`**: places a tile on the board across `loc0` and `loc1`; update the `frontier` to say that the just-covered locations are no longer in the frontier, but the empty neighbors of the tile are.\n",
    "- **`shuffle(items)`**: used to randomize lists; calls `random.shuffle` and returns the result.\n",
    "\n",
    "# The Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "empty = None # An empty square\n",
    "\n",
    "class Board(dict):\n",
    "    \"A mapping from location to name.\"\n",
    "    def __init__(self, width, height): self.width, self.height = width, height\n",
    "    def __missing__(self, loc): return empty\n",
    "\n",
    "def dominoes(tiles, width=16, height=24):\n",
    "    \"Place as many tiles on board as possible (legally and randomly).\"\n",
    "    tiles    = shuffle(list(tiles))\n",
    "    board    = Board(width, height)\n",
    "    frontier = set()\n",
    "    m        = min(width, height) // 2\n",
    "    put_tile(board, (m, m), (m, m + 1), tiles.pop(), frontier) # Place first tile\n",
    "    while tiles and frontier:\n",
    "        try_one(tiles, board, frontier)\n",
    "    return board\n",
    "          \n",
    "def try_one(tiles, board, frontier):\n",
    "    \"Pop a frontier location, and try to place a tile on that location.\"\n",
    "    loc0 = frontier.pop()\n",
    "    for tile in shuffle(tiles):\n",
    "        for (name0, name1) in [tile, tile[::-1]]:\n",
    "            if legal(name0, loc0, board):\n",
    "                for loc1 in shuffle(neighbors(loc0, board)):\n",
    "                    if legal(name1, loc1, board):\n",
    "                        put_tile(board, loc0, loc1, (name0, name1), frontier)\n",
    "                        tiles.remove(tile)\n",
    "                        return tile\n",
    "                        \n",
    "def legal(name, loc, board):\n",
    "    \"Is it legal to place this name on this location on board?\"\n",
    "    return (board[loc] is empty and\n",
    "            all(board[nbr] is empty or board[nbr] == name\n",
    "                for nbr in neighbors(loc, board)))\n",
    "\n",
    "def neighbors(loc, board):\n",
    "    \"Neighbors of this location on the board.\"\n",
    "    x, y = loc\n",
    "    return [(x+dx, y+dy) for (dx, dy) in ((0, 1), (1, 0), (0, -1), (-1, 0))\n",
    "            if 0 <= x+dx < board.width and 0 <= y+dy < board.height]\n",
    "\n",
    "def put_tile(board, loc0, loc1, tile, frontier): \n",
    "    \"Place the tile across the two locations, and update frontier.\"\n",
    "    board[loc0], board[loc1] = tile\n",
    "    frontier -= {loc0, loc1}\n",
    "    frontier |= {loc for loc in neighbors(loc0, board) + neighbors(loc1, board)\n",
    "                 if board[loc] is empty}\n",
    "                            \n",
    "def shuffle(items): random.shuffle(items); return items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(0, 0): 'RY',\n",
       " (1, 0): 'KE',\n",
       " (1, 1): 'KE',\n",
       " (2, 1): 'JO',\n",
       " (2, 2): 'JO',\n",
       " (3, 2): 'GR',\n",
       " (3, 3): 'GR',\n",
       " (3, 4): 'KE',\n",
       " (4, 4): 'KE',\n",
       " (4, 5): 'JA'}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tiles8 = [('BO', 'JA'), ('JA', 'PO'), ('JA', 'RY'), ('RY', 'KE'), \n",
    "          ('GR', 'KE'), ('GR', 'JO'), ('JA', 'KE'), ('KE', 'JO')]\n",
    "\n",
    "dominoes(tiles8, 6, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pretty Output\n",
    "\n",
    "Technically, this is a legal solution, but there are two problems with it: One, it is not visual. Two, it doesn't say where each tile is: when three names come together, which of the outside names goes with the middle name?  To fix those two problems I will:\n",
    "\n",
    "- Define `plot_board(board)` to use `matplotlib` to plot the board, the names, and the tiles.\n",
    "- Modify the `Board` class and the `put` function so that the board maintains a list of `boxes` that surround each two-location rectangle that a tile occupies: `[loc0, loc1]`. The constant ϵ is the distance between two adjacent tiles; we want them to not-quite touch (as in the xkcd comic)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "ϵ = 0.06 # A small amount; the space between adjacent lines\n",
    "\n",
    "class Board(dict):\n",
    "    \"A mapping from location to name.\"\n",
    "    def __init__(self, width=16, height=24): \n",
    "        self.width, self.height, self.boxes = width, height, []\n",
    "    def __missing__(self, loc): return empty\n",
    "    \n",
    "def plot_board(board):\n",
    "    \"Plot the box and name for every tile, plus a big box around the board.\"\n",
    "    plt.figure(figsize=(board.width, board.height))\n",
    "    plt.subplots_adjust(left=ϵ, right=1-ϵ, top=1-ϵ, bottom=ϵ)\n",
    "    plt.axis('off')  \n",
    "    plt.axis('equal')\n",
    "    for box in board.boxes:\n",
    "        plot_box(box)\n",
    "    plot_box([(-2*ϵ, -2*ϵ), (board.width - 1 + 2*ϵ, board.height - 1 + 2*ϵ)])\n",
    "    for (x, y) in board:\n",
    "        plt.text(x + 0.5, y + 0.5, board[x, y], \n",
    "                 va='center', ha='center', fontsize=8)\n",
    "\n",
    "def plot_box(box):\n",
    "    \"Plot a box, which is a [loc0, loc1] pair.\"\n",
    "    Xs, Ys = {loc[0] for loc in box}, {loc[1] for loc in box}\n",
    "    x0, x1 = min(Xs), max(Xs) + 1 - ϵ\n",
    "    y0, y1 = min(Ys), max(Ys) + 1 - ϵ\n",
    "    plt.plot([x0, x1, x1, x0, x0], \n",
    "             [y0, y0, y1, y1, y0], 'k-')\n",
    "\n",
    "def put_tile(board, loc0, loc1, tile, frontier): \n",
    "    \"Place the tile across the two locations, and update frontier and boxes.\"\n",
    "    board[loc0], board[loc1] = tile\n",
    "    frontier -= {loc0, loc1}\n",
    "    frontier |= {loc for loc in neighbors(loc0, board) + neighbors(loc1, board)\n",
    "                 if board[loc] is empty}\n",
    "    board.boxes.append([loc0, loc1])       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAGdCAYAAABU0qcqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAEFdJREFUeJzt3X/I7nV9x/HXW06bISjnZLa0tQ0nk6g/GkjtCDqUapkQ5bJlev4Yts1ibP9sI4SonX8CSdpgk5BFM0a0qS0o4eT0aDtr0f4xGTKChWNrMhce2xDW+vHeH/d17O4sPfdt59zv+3vdjwfceJ/rluPrvu7L63l/P/cNV3V3AGCnnTU9AIC9SYAAGCFAAIwQIABGCBAAIwQIgBECBMAIAQJghAABMEKAABghQACMECAARggQACMECIARAgTACAECYIQAATBCgAAYIUAAjBAgAEYIEAAjBAiAEQIEwAgBAmCEAAEwQoAAGCFAAIwQIABGCBAAIwQIgBECBMAIAQJghAABMEKAABghQACMECAARggQACMECIARAgTACAECYIQAATBCgAAYIUAAjBAgAEYIEAAjBAiAEQIEwAgBAmCEAAEwQoAAGCFAAIwQIABGCBAAIwQIgBECBMCIfdMDdpuqeirJ/ukdACvHu/vA9Igzobp7esOuUlXd3TW9AyBZ7+ckR3AAjBAgAEYIEAAjBAiAEQIEwAgBAmCEAAEwQoAAGCFAAIwQIABGCBAAIwQIgBECBMAIAQJghAABMEKAABghQACMECAARggQACMECIARAgTACAECYIQAATBCgAAYIUAAjBAgAEYIEAAjBAiAEQIEwAgBAmCEAAEwQoAAGCFAAIwQIABGCBAAIwQIgBECBMAIAQJghAABMEKAABghQACMECAARggQACMECIARAgTACAECYIQAATBCgAAYIUAAjBAgAEYIEAAjBAiAEfumByxBVT2VZP/0jj3meHcfmB7x41roY+fZ+36h+5dsLR73W1XdPb1hV6mq7u461W2cWetyny/x89i8eYn7l2yvPf84ggNghAABMEKAABghQACMECAARggQACMECIARAgTACAECYIQAATBCgAAYIUAAjBAgAEYIEAAjBAiAEQI0pKqurKrDq/fvrKo7pjdtxWr341X1YFX9bVX9QlW9uKo+XlVHq+qBqvrF6Z3r6sTjpqp+rqruW30d/qqqXjK9bSuWvP+k/2evq6q7q+rJ1efwYFXdPL1xabwi6qyuqrOSvDzL+mbgru7+QFW9PsktSf4nyZHu/nRVvTTJZ6rql7v7u7Mz19qdSX6ju79eVQeT/HGSdw9v2o6l7u/V3luSvC/Jrd19aHjTYi3pSW9dXZHkaJJjqyf0JTjx6oznJfmvJAe7+9NJ0t3/meSBJEv5XJbooiRPdPfXk6S7v5TkZVW1lFfNXPL+S5PcluRXs/GN1xI271oCNKuSvC3J3au3t8/O2bKbqurhJB9P8pdJTn5d929k46qOM+Onk/z7Sbc9meT8gS0vxJL3vzEbV/tPr/78hk1HcNdODlsiR3CzKslVSS5ZvX/B7JwtO3EE99Ikf5b//13gK5I8tvOz9ox/TXLhSbe9LMk3B7a8EEvef0eSy6vqTUn+KckXHMG9cK6AZr02yb3dfU13vznJkap69fSoLTgRnGeSnJvk76vq15Kkqi7IRlS/PLRtL/hGkgur6ueTpKouT/If3X3ylehuteT930nyziSHk5wdR3A/FldAcyrJI0ke2nTbw9k4kvvHiUHbcOPqSePsbPyP+FCSO6rqt5J8P8nv+AWEM6aSfDfJe5L8aVX9ZJKnkvzm6KqtW/r+dPfTVXUoybEk51bVRasPfb67PzI4bXFqGd907Jyq6u6uU912Gv47NyY5p7s/djr/3nVxJu7zCaf789iJx83mzUvcv2Q79fyzWziCG1BV12fjO8B7prewHEt/3Cx9P6efK6CT7LXvQHardbnPl/h5nMkrIJ7fXnv+cQUEwAgBAmCEAAEwQoAAGCFAAIwQIABGCBAAIwQIgBECBMAIAQJghAABMEKAABghQACMECAARggQACMECIARAgTAiH3TA5aiqrx07M46Pj2ADR77O2pPPe4FaAvW9eVw4VQ89jmTHMEBMMIV0BZU1VNJ9k/v2Kbj3X1gegTAcxGgrdm/tKMI5/bAbucIDoARAgTACAECYIQAATBCgAAYIUAAjBAgAEYIEAAjBAiAEQIEwAgBAmCEAAEwQoAAGCFAAIwQIABGCNCQqrqyqg6v3r+zqu6Y3sTuVlVXVNUDVXW0qu6vqoNV9fTqtmNVddn0RtgOL0g3q6vqrCQvj28GeB5V9ZIkH0pybXc/U1XnJLkkyaPdfXVVXZTko0neMbkTtsOT3rwrkhxNcqyqXj89hl3rmiSf7O5nkqS7n+nuR5KceKXe/Um8Ci6L4gpoViV5W5Lbk/xkkpuTfHl0EbvVhUkeTZKqeleS92bjsfKaqvpiklcluXpuHmyfAM2qJFdl4yilklwwO4dd7IkkFyVJd3+qqv4uG0dyj3b3FVX160kOJvnq4EbYFkdws16b5N7uvqa735zkSFW9enoUu9J9SW6sqnNXf37RSR//RJJDVVWBhRCgOZXkkSQPbbrt4WwcycEP6e5vJvlgks9W1d8k+ZMkf77p499PciTJW0cGwgtQ3X5uuVlVdXfXqW47Df+dG5Oc090fO51/76a//7RvZvuW+HVY4uZ1ts5fD1dAA6rq+iTvSXLP9BaAKa6ATrJTV0Bn2hI3r6Mlfh2WuHmdrfPXwxUQACMECIARAgTACAECYIQAATBCgAAYIUAAjBAgAEYIEAAjBAiAEQIEwAgBAmCEAAEwQoAAGCFAAIwQIABGCBAAIwQIgBH7pgfAuquqpb3u/fHpAewNAgRnUHfX9AbYrRzBATDCFRC7XlU9lWT/9I495Hh3H5gewfoTIJZgv6OsnbPAn1mxUI7gABghQACMECAARggQACMECIARAgTACAECYIQAATBCgAAYIUAAjBAgAEYIEAAjBAiAEQIEwAgBAmCEAA2oqiur6vGqeqCqjlTVDVV1+6aPH62qCyY3rqvVfX949f51VXV3VT1ZVQ+u3m6e3vhcquqK1WPmaFXdX1UHq+rp1W3Hquqy6Y2wHV6Qbs5d3f2BqrohG6/2eXFVXZzkdUnu7+4nZ+etta6qg0luSfK+JLd296HhTc+rql6S5ENJru3uZ6rqnCSXJHm0u6+uqouSfDTJOyZ3wnYI0JwTr/C5P0kneX+S25IcSPKmqVF7xKVJrk7yliTn5Qdfi93smiSf7O5nkmT1z0eq6uTHESyGAM25qap+JcmLk/xSd/93VX0ryee6+9vD29bdG5Pc3t1PV9V5Sd5QVQ+uPnZ7d39ucNtzuTDJo0lSVe9K8t4kX07ymqr6YpJXZSOqsBh+BjTnru6+LMlXkrxyddvjqzfOrDuSXF5VJ640v9DdV63edmN8kuSJJBclSXd/Ksm7k5yfjSO4K5L8fpKDc/Ng+wRo3oeT3Do9Yo/5TpJ3Jjmc5Ows4wjuviQ3VtW5qz+/6KSPfyLJoU1HcrDrOYIb1t1fq6rzV7/15gx/h6yO3w4lOZbk3NUP8ZPk8939kcFpP1J3f7OqPpjks1X1vSTfzcY3L3+4+vj3q+pIkrcm+euxobAN1e05b7Oq6u6uU9222y1x83NZp89lCdzfu8s6fz0cwQEwQoAAGCFAAIwQIABGCBAAIwQIgBECBMAIAQJghAABMEKAABghQACMECAARggQACMECIARAgTACAECYIQAATBCgAAYIUAAjNg3PWApqqqnN2zT8ekBp9MC7/8lW6vHDruXAG1Bd9f0hr3M/Q/ryREcACNcAW1BVT2VZP/0jj3meHcfSBZ5/z+7HXhuArQ1+x0D7ayTfuazqPvfz6tgaxzBATBCgAAYIUAAjBAgAEYIEAAjBAiAEQIEwAgBAmCEAAEwQoAAGCFAAIwQIABGCBAAIwQIgBECBMAIARpQVVdW1eNV9UBVHamqG6rq9k0fP1pVF0xufC6r7YdX719XVXdX1ZNV9eDq7ebpjc9n6fthnXhBujl3dfcHquqGbLza58VVdXGS1yW5v7ufnJ33vLqqDia5Jcn7ktza3YeGN23H0vfDWhCgOSde4XN/kk7y/iS3JTmQ5E1To7bo0iRXJ3lLkvPyg89lKZa+H9aCI7g5N1XVP2Tju/BPdvdjSb6VjSujb89OO6U3JjnS3U+v/vyGTUdY104O26Kl74e1IEBz7uruy5J8JckrV7c9vnrb7e5IcnlVnbhS+0J3X7V6+9zksC1a+n5YCwI078NJbp0esU3fSfLOJIeTnJ3lHWEtfT+sBT8DGtbdX6uq81e/9dbTe7aqu5+uqkNJjiU5t6ouWn3o8939kcFpW7L0/bAOqnsxz3k7oqq6u+tUt3Fmbb7Pl3b/L20vu9s6P54cwQEwQoAAGCFAAIwQIABGCBAAIwQIgBECBMAIAQJghAABMEKAABghQACMECAARggQACMECIARAgTACAECYIQAATBCgAAYIUAAjBAgAEbsmx6wFFXV0xv2mOPTA4AzS4C2oLtregPAunEEB8AIV0BwBlXVU0n2T+/YQ45394HpEWyNAMGZtd8R7s7xs9plcQQHwAgBAmCEAAEwQoAAGCFAAIwQIABGCBAAIwQIgBECBMAIAQJghAABMEKAABghQACMECAARggQACMEiD2nqq6sqsOr9++sqjumN23VUrevdj9eVQ9W1Weq6ieq6g+q6uHV26Hpjew8AWKv6qo6K8nLk/zM9JhtWur2u7r7qiRfSnJ9kp/t7iuTXJXkuqq6dHQdO06A2MuuSHI0ybGqev30mG1a8vavJrkryW1J0t3fS/JHSd4xOYqdJ0DsVZXkbUnuXr29fXbOtix1+4mXJr8yyf8meWLTx/4tyU/t+CJG7ZseAEMqG0c/l6zev2B2zrYsdftNVXUwyWNJ/iLJhUn+efWxV+SHg8Qe4AqIveq1Se7t7mu6+81JjlTVq6dHbdFSt9/V3Vd3928nuSfJ7yVJVe1L8rtJ7p0cx84TIPaiSvJIkoc23fZwNo61drslb39Wd9+X5F+q6otJHkxyT3c/NjyLHVbdPb1hV6mq7u469b/JTjndX5OqujHJOd39sdP1d5709z+7d2nbl24d//9dx8/pBFdA7ClVdX2S92TjCGhRlrwdfhRXQCdZ5+82lmppX5MzeQXE81vH+3sdP6cTXAEBMEKAABghQACMECAARggQACMECIARAgTACAECYIQAATBCgAAYIUAAjBAgAEYIEAAjBAiAEQIEwAgBAmCEAAEwYt/0ANiKqlrSS/ce3/yHhW1fuuOn/lfYLQSIXW/JL0e85O1wpjmCA2CEAAEwQoAAGCFAAIzwSwg/gt9aAnaRtf3Nvur2XAvAznMEB8AIAQJghAABMEKAABghQACMECAARggQACMECIARAgTACAECYIQAATBCgAAYIUAAjBAgAEYIEAAjBAiAEQIEwAgBAmCEAAEwQoAAGCFAAIwQIABGCBAAIwQIgBECBMAIAQJghAABMEKAABghQACMECAARggQACMECIARAgTACAECYIQAATBCgAAYIUAAjBAgAEYIEAAjBAiAEQIEwAgBAmCEAAEwQoAAGCFAAIwQIABGCBAAIwQIgBECBMAIAQJghAABMEKAABghQACMECAARggQACMECIARAgTACAECYIQAATBCgAAYIUAAjPg/Iw0BSE0gbhAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x110568940>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_board(dominoes(tiles8, 6, 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# All the Names\n",
    "\n",
    "Now let's try all the names from the comic, courtesy of \n",
    " [explainxkcd](http://www.explainxkcd.com/wiki/index.php/1970:_Name_Dominoes), with a few typos corrected:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def name_tiles(text):\n",
    "    \"For each line of text, create a tile of ('First Name(s)', 'Lastname').\"\n",
    "    return [name.strip().rpartition(' ')[0::2]\n",
    "            for name in text.upper().split(',')]\n",
    "           \n",
    "xkcdtiles = name_tiles(\"\"\"Christian Campbell, Neve Campbell, Joe McCarthy, Eugene McCarthy, \n",
    "  Gene Vincent, Gene Kelly, Kate Hudson, Rock Hudson, Gordon Brown, James Brown, Jon Brown, \n",
    "  John Howard, Columbo, Chris Columbus, Christopher Columbus, Naomi Campbell, Joseph Campbell, \n",
    "  Joseph Smith, Frank Vincent, John Kelly, Katherine Johnson, The Rock, Chris Rock, Chris Isaac, \n",
    "  James Newton Howard, John Wayne, Howard Stern, Howard Hunt, Chris Hughes, Naomi Watts, \n",
    "  Naomi Klein, Kevin Kline, Francis Bacon, Francis Drake, Lyndon Johnson, Oscar The Grouch, \n",
    "  Oscar Isaac, Isaac Hayes, Isaac Newton, Wayne Newton, Wayne Knight, Helen Hunt, Helen Hughes, \n",
    "  James Watt, James Watt, Kevin Costner, Kevin Bacon, Kevin Love, Lisa Frank, Frank Drake, Drake, \n",
    "  Oscar de la Renta, Oscar de la Hoya, Sean Hayes, Wallace Shawn, Wayne Howard, Wayne Brady, \n",
    "  James Brady, Tom Brady, Helen Thomas, Tom Hanks, Hank Aaron, Aaron Carter, Stephen James, \n",
    "  Will Smith, Kevin Smith, Kevin James, Garfield, James Garfield, Warren Buffett, Jimmy Buffett, \n",
    "  Warren Beatty, Elizabeth Warren, Earl Warren, Elizabeth Kolbert, Stephen Colbert, \n",
    "  Charles Wallace, James Monroe, Marilyn Monroe, Hank Williams, William C. Williams, Steve Harvey,\n",
    "  Domino Harvey, Harvey Milk, James Saint James, Etta James, Jim Jones, James Earl Jones, \n",
    "  Charlie Parker, Ray Parker, Ray Charles, Charles Manson, Marilyn Manson, Robin Williams, \n",
    "  Billy D. Williams, Will Wright, Fats Domino, Bill Clinton, Jimmy John, Tom Jones, Tommy John, \n",
    "  Quincy Jones, James Earl Ray, Man Ray, Rachel Ray, Ray Allen, Tim Allen, Tim Cook, Tim Howard, \n",
    "  Robin Wright, Wilbur Wright, Fatty Arbuckle, Fat Joe, George Clinton, John Kerry, \n",
    "  Kerry Washington, John Irving, John Quincy Adams, John Adams, Amy Adams, Aimee Mann, Super Man, \n",
    "  Bat Man, Ayn Rand, Lily Allen, Paul Allen, Ron Howard, Howard Hughes, Joe Kennedy, George Bush, \n",
    "  George Washington, Washington Irving, Martha Washington, Ma Rainey, Jack Ma, Super Grover, \n",
    "  Jack Black, Rand Paul, Paul Ryan, Paul Simon, Ron Paul, John Hughes, Langston Hughes, \n",
    "  John F. Kennedy, Little Richard, Rich Little, Martha Stewart, Yo Yo Ma, Ma Bell, \n",
    "  Grover Cleveland Alexander, Grover Cleveland, Jack White, Jack Ryan, Debby Ryan, Carly Simon, \n",
    "  Carly Hughes, Charles Evans Hughes, John Williams, Little John, Stuart Little, Potter Stewart, \n",
    "  Kristen Stewart, Kristen Bell, Kristen Hooks, Alexander Graham Bell, Franklin Graham, \n",
    "  Lloyd Alexander, Meg White, Meg Ryan, Debbie Reynolds, John Reynolds, Carly Fiorina, \n",
    "  Grace Lee Boggs, Wade Boggs, William Safire, Prince William, Little Prince, Harry Potter, \n",
    "  James Potter, James Hook, James Dean, Aretha Franklin, Frank Lloyd Wright, Barry White, \n",
    "  Walter White, Walt Whitman, John Kelly, Grace Lee, Nancy Grace, Garnet, Prince, Prince Fielder, \n",
    "  Prince Harry, Harry Styles, John Dean, Benjamin Franklin, Harold Lloyd, Harold Ford, \n",
    "  Betty White, Meg Whitman, Christine Todd Whitman, Megyn Kelly, Grace Kelly, Grace Jones, \n",
    "  Jack Nicholson, Jack Ruby, Jack Russell, Harry Fielder, Harry Truman, Harry Jon Benjamin, \n",
    "  John Edward, Benjamin Harrison, Harrison Ford, Henry Ford, Betty Ford, Betty Friedan, \n",
    "  Chris Christie, Chris Pratt, Maggie Grace, Grace Hopper, Russell Crowe, Russ Smith, John Smith, \n",
    "  Justin Long, John Bel Edwards, John Candy, John Henry, Henry James, Bill James, Chris Cooper, \n",
    "  Chris Hemsworth, Chris Evans, Topher Grace, Van Morrison, Sheryl Crow, Sheryl Sandberg, \n",
    "  Cameron Crowe, Long John Silver, Olivia Newton John, Huey Long, John Edwards, Candy Crowley, \n",
    "  Aleister Crowley, James Fenimore Cooper, James Cook, Robert Frost, Bob Evans, Evan Taylor Jones,\n",
    "  James Cameron, Cam Newton, Cameron Diaz, Huey Newton, Huey Lewis, John Lewis, Jenny Lewis, \n",
    "  Ryan Lewis, Burt Reynolds, Alistair Cooke, Alistair Cookie, Cokie Roberts, John Roberts, \n",
    "  Robert Johnson, Robert E. Lee, Tommy Lee, Tommy Lee Jones, Etta James, John Oliver, \n",
    "  Ryan Reynolds, Alastair Reynolds, George Wallace\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "270"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(xkcdtiles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('JAMES EARL', 'RAY'),\n",
       " ('BURT', 'REYNOLDS'),\n",
       " ('CHRISTOPHER', 'COLUMBUS'),\n",
       " ('KRISTEN', 'STEWART'),\n",
       " ('FAT', 'JOE'),\n",
       " ('HAROLD', 'LLOYD'),\n",
       " ('ISAAC', 'HAYES'),\n",
       " ('PAUL', 'RYAN'),\n",
       " ('GENE', 'KELLY'),\n",
       " ('MEGYN', 'KELLY')]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.sample(xkcdtiles, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Approximate and Partial Matches\n",
    "\n",
    "Two tile halves match if they are an exact match, like \"ADAMS\" and \"ADAMS\", or if they are an **approximate match**, like \"AMY\" and \"AIMEE\". To accomodate this, you can manually define allowable approximate matches by making the global variable `synsets` (synonym sets) be a mapping from a name to the set of approximate matches it should match, which can be done like this:\n",
    "\n",
    "     synsets = synonyms(\"AMY=AIMEE, COOK=COOKE=COOKIE=COKIE, ...\")\n",
    "\n",
    "Another issue is  a **partial match**: in the comic, some tiles, like \"FRANK LLOYD WRIGHT\" are 3 squares wide, and some, like \"PRINCE\" are only one square wide. For simplicity, I chose to have all my tiles be 2 squares wide, but I still want `'LLOYD'` to match the first name of `('FRANK LLOYD', 'WRIGHT')`. To accomplish this, the second argument to `synonyms` is a list of tiles; the function will go through these and add synset entries for parts of first names,\n",
    "so that both `'FRANK'` and `'LLOYD'` will match `'FRANK LLOYD'`. As for \"PRINCE\", he gets represented as the tile `('', 'PRINCE')`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import collections\n",
    "\n",
    "def synonyms(text='', tiles=()): \n",
    "    \"synonyms('AMY=AIMEE') => dict(AMY={'AMY', 'AIMEE'}, AIMEE={'AMY', 'AIMEE'})\"\n",
    "    synsets = collections.defaultdict(set)\n",
    "    # Process `text`\n",
    "    for text1 in text.upper().split(','):\n",
    "        synset = set(text1.strip().split('='))\n",
    "        for s in synset:\n",
    "            synsets[s] |= synset\n",
    "    # Process `tiles`\n",
    "    for (first, last) in tiles:\n",
    "        for part in first.split():\n",
    "            synsets[part].add(first)\n",
    "            synsets[first].add(part)\n",
    "    return synsets\n",
    "\n",
    "synsets = synonyms(\"\"\"AMY=AIMEE, COOK=COOKE=COOKIE=COKIE, ALASTAIR=ALISTAIR, \n",
    "  COLUMBO=COLUMBUS, SAFIRE=SAPPHIRE=GARNET, GARNET=RUBY, CHARLIE=CHARLES, SEAN=SHAWN,\n",
    "  JIMMY=JAMES, MAN=MANN, JACK=JOHN, TOM=TOMMY, WILL=WILLIAM=WILLIAMS, ROBERT=ROBERTS=BOB, \n",
    "  CAM=CAMERON, OLIVER=OLIVIA, EDWARD=EDWARDS, RICH=RICHARD, CHRIS=CHRISTOPHER=TOPHER, \n",
    "  FAT=FATS=FATTY, WALT=WALTER, HANK=HANKS, CROW=CROWE, COLBERT=KOLBERT\"\"\", xkcdtiles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "To make this work, I update `legal` to consult the `synsets` global variable for an approximate or partial matches, and while I'm changing `legal`, I'll also disallow a match between the empty first name of \"PRINCE\" with the empty first name of \"DRAKE\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def legal(name, loc, board):\n",
    "    \"Is it legal to place this value on this location on board?\"\n",
    "    return (board[loc] is empty and \n",
    "            all(board[nbr] is empty \n",
    "                or board[nbr] == name != '' \n",
    "                or board[nbr] in synsets[name]\n",
    "                for nbr in neighbors(loc, board)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Final Result (with Random Restart)\n",
    "\n",
    "The program sometimes gets stuck after placing relatively few tiles. I could modify the program to *back up* in this case, but it will be easier to just *give up* and restart with an empty board. I can restart multiple times, and accept the best board (the one on which the most tiles were placed):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11058c668>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def best(boards): return max(boards, key=lambda board: len(board.boxes))\n",
    "\n",
    "plot_board(best(dominoes(xkcdtiles) for _ in range(100)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note:* I used a 16×24 square board while the xkcd comic used 27×35, but if I tried to fit 27 squares across then each tile would be smaller, and many names would overflow the sides of the dominoes too much. Here is the original xkcd comic:\n",
    "\n",
    "[![](https://imgs.xkcd.com/comics/name_dominoes_2x.png)](https://xkcd.com/1970/)\n",
    "\n",
    "# What's Next?\n",
    "\n",
    "I'm happy with the results, but here are some ideas for improvements, if you want something to work on:\n",
    "- Allow tiles that are 1 or 3 squares wide, like `('PRINCE',)` or `('FRANK', 'LLOYD', 'WRIGHT')`.\n",
    "- Print names vertically in tiles that are placed vertically, and upside down for tiles that are placed horizontally, but with the first name on the right.\n",
    "- Print shorter names with a bigger font and longer names with a smaller font.\n",
    "- Download a bunch of names from Wikipedia and fill a 200 × 300 board.\n",
    "- If you like xkcd try [regex golf](https://github.com/norvig/pytudes/blob/master/ipynb/xkcd1313.ipynb), and [part 2](https://github.com/norvig/pytudes/blob/master/ipynb/xkcd1313-part2.ipynb).\n"
   ]
  }
 ],
 "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.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}