From ddad3bbaa730b46bd216eb0a1fa3feeb2a123bba Mon Sep 17 00:00:00 2001 From: Peter Norvig Date: Sat, 11 Apr 2020 21:41:45 -0700 Subject: [PATCH] Add files via upload --- ipynb/xkcd-Name-Dominoes.ipynb | 675 ++++++++++++++++++--------------- 1 file changed, 378 insertions(+), 297 deletions(-) diff --git a/ipynb/xkcd-Name-Dominoes.ipynb b/ipynb/xkcd-Name-Dominoes.ipynb index fe7aa2e..bbfeed1 100644 --- a/ipynb/xkcd-Name-Dominoes.ipynb +++ b/ipynb/xkcd-Name-Dominoes.ipynb @@ -8,30 +8,20 @@ "\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", + "![](https://norvig.com/xkcd-dominoes.png)\n", "\n", - "I will write a function to lay out tiles in a random, legal array. First, the key data structures:\n", + "The March 21, 2018 `xkcd` comic (#1970) was **[Name Dominoes](https://xkcd.com/1970/)**: tiles laid out as if in a game of dominoes, but the tiles contain names of famous people. \n", + "In regular [dominoes](https://en.wikipedia.org/wiki/Dominoes) a tile consists of two squares, each with a number of spots from 0 to 6. In xkcd name dominoes, the tiles can be one, two, or three squares in length, and each square contains a name (first, middle, or last). In both versions, a tile can be placed if it is adjacent to another tile on the board, and if no two adjacent squares contain different numbers/names.\n", + "I will write a function, `place_tiles`, to lay out name dominoes according to these rules. \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", + "# Key Data Structures:\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" + "- **`Tile`**: a tile is a tuple of names, like `('ISSAC', 'NEWTON')`\n", + "or `('FRANK', 'LLOYD', 'WRIGHT')` or `('DRAKE',)`.\n", + "- **`Name`**: a name (first, middle, or last) is a string, like `'FRANK'`.\n", + "- **`Box`**: a structure with a tile, the square that the tile's first name goes on, and the direction in which to move to place subsequent names.\n", + "- **`Point`**: an `(x, y)` pair denoting the coordinates of a square on the board. Can also be used for **directions**: `(0, 1)` is the direction that goes 0 in the x axis and 1 in the y axis; also known as \"up\" or \"90 degrees\".\n", + "- **`Board`**: a [width × height] grid of squares, where each square can be filled with a name. `Board` is implemented as a subclass of `dict` of the form `{(0, 0): 'ISSAC', (0, 1): 'NEWTON', ...}`, but with additional attributes to keep track of the width and height, and the boxes placed so far. If an `(x, y)` square is not in the dict, it is `empty` by default, unless the `(x, y)` coordinates are out of bounds; then it is `off` the board." ] }, { @@ -40,102 +30,63 @@ "metadata": {}, "outputs": [], "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", "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" + "from collections import namedtuple" ] }, { "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" - } - ], + "outputs": [], "source": [ - "tiles8 = [('BO', 'JA'), ('JA', 'PO'), ('JA', 'RY'), ('RY', 'KE'), \n", - " ('GR', 'KE'), ('GR', 'JO'), ('JA', 'KE'), ('KE', 'JO')]\n", + "Tile = tuple # e.g., ('ISSAC', 'NEWTON')\n", + "Name = str # e.g., 'ISSAC'\n", + "Box = namedtuple('Box', 'start, dir, tile')\n", "\n", - "dominoes(tiles8, 6, 6)" + "Point = tuple\n", + "def X(point) -> int: \"The x coordinate of a point\"; return point[0]\n", + "def Y(point) -> int: \"The x coordinate of a point\"; return point[1]\n", + "\n", + "directions = {(1, 0): 0, (0, 1): 90, (-1, 0): 180, (0, -1): 270}\n", + "\n", + "off = '.' # A square that is off the edge of the board\n", + "empty = '' # An empty square (does not have a tile covering it)\n", + "\n", + "class Board(dict):\n", + " \"\"\"A mapping from (x, y) squares to names; for a width x height board.\"\"\"\n", + " def __init__(self, width, height): \n", + " \"\"\"Keep track of the width and height, and of boxes that have been placed.\"\"\"\n", + " self.width = width \n", + " self.height = height\n", + " self.boxes = []\n", + " \n", + " def __missing__(self, square: Point) -> str: \n", + " \"\"\"The contents of a filled square is a name; a missing square is empty or off.\"\"\"\n", + " return empty if (0 <= X(square) < self.width and 0 <= Y(square) < self.height) else off" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Pretty Output\n", + "# Algorithm to Fill the Board\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", + "Now I need a strategy to fill the board with tiles. I will place tiles one at a time, and to make things easier I will *never* consider removing a tile from the board and backtracking. The major functions are:\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)." + "\n", + "- **`place_tiles(tiles)`**: The top-level strategy. 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_square` to legally place an additional tile on a square from the frontier, stopping when either there is no `frontier` left or no `tiles` left.\n", + "- **`frontier`**: I'll maintain a *frontier*, a set of `(x, y)` squares that are adjacent to tiles on the board, and thus are candidates for placing new tiles.\n", + "- **`try_one_square(tiles, board, frontier)`**: pop a square off the frontier, and try to find some tile that can legally put one of its names there; when found, `put_tile` the tile there, and remove it from `tiles`.\n", + "- **`can_put_tile(tile, board, start, dir)`**: Can we put this tile on the board at this start square, going in this direction?\n", + "- **`can_put_name(name, board, square)`**: Can this one name (first, middle, or last) be placed on this square?\n", + "- **`allowed(name, nbr_contents)`**: Is this name allowed to be placed next to this neighboring square's contents?\n", + "- **`neighbors(square, board)`**: returns the four neighbors of a square.\n", + "- **`put_tile(tile, board, start, dir, tiles, frontier)`**: places a tile on the board starting at `start` and going in direction `dir`; update the `frontier` to say that the just-covered squares are not in the frontier, but the empty neighbors of new tiles are. Remove the tile from `tiles`.\n", + "- **`move(start, steps, dir)`**: Returm the square that results from starting at `start` and going `steps` in \n", + "direction `dir`." ] }, { @@ -144,65 +95,220 @@ "metadata": {}, "outputs": [], "source": [ - "%matplotlib inline\n", - "import matplotlib.pyplot as plt\n", + "def place_tiles(tiles, width=16, height=35) -> Board:\n", + " \"\"\"Place as many tiles on board as possible.\"\"\"\n", + " tiles = list(tiles); random.shuffle(tiles)\n", + " board = Board(width, height)\n", + " frontier = set()\n", + " put_tile(tiles[0], board, (width//2, height//2), (0, 1), tiles, frontier)\n", + " while tiles and frontier:\n", + " try_one_square(tiles, board, frontier) \n", + " return board\n", "\n", - "ϵ = 0.06 # A small amount; the space between adjacent lines\n", + "def try_one_square(tiles, board, frontier):\n", + " \"\"\"Pop a frontier square, and try to place a tile on that square.\"\"\"\n", + " square = frontier.pop()\n", + " for tile in tiles:\n", + " # The offset is used to shift the tile along `direction`\n", + " for offset in range(len(tile)):\n", + " for dir in directions:\n", + " start = move(square, -offset, dir)\n", + " if can_put_tile(tile, board, start, dir):\n", + " return put_tile(tile, board, start, dir, tiles, frontier)\n", + " \n", + "def can_put_tile(tile, board, start, dir) -> bool:\n", + " \"\"\"Is it legal to put this tile on this square/direction on board?\"\"\"\n", + " return all(can_put_name(name, board, move(start, i, dir))\n", + " for i, name in enumerate(tile))\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", + "def can_put_name(name, board, square) -> bool:\n", + " return (board[square] is empty \n", + " and all(allowed(name, board[nbr])\n", + " for nbr in neighbors(square, board)))\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", + "def allowed(name, nbr_contents) -> bool: return nbr_contents in (name, empty, off)\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]) " + "def neighbors(square, board) -> list:\n", + " \"\"\"Neighbors of this square on the board.\"\"\"\n", + " x, y = square\n", + " return [(x+dx, y+dy) for (dx, dy) in directions]\n", + "\n", + "def put_tile(tile, board, start, dir, tiles, frontier): \n", + " \"\"\"Place the tile on the board at the start square, going in the given direction. \n", + " Update tiles and frontier.\"\"\"\n", + " board.boxes.append(Box(start, dir, tile))\n", + " tiles.remove(tile)\n", + " for i, name in enumerate(tile):\n", + " square = move(start, i, dir)\n", + " board[square] = name\n", + " frontier -= {square}\n", + " frontier |= {L for L in neighbors(square, board) if board[L] is empty}\n", + " \n", + "def move(start: Point, steps: int, dir: Point) -> Point: \n", + " \"\"\"Starting at `start` square, move a number of `steps` in direction `dir`.\"\"\"\n", + " return (X(start) + steps * X(dir),\n", + " Y(start) + steps * Y(dir))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Small Example\n", + "\n", + "Here I create a small example with 8 tiles, and try to fill a board. You can see the boxes that were placed, and the names that are in each square:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, + "outputs": [], + "source": [ + "tiles8 = [('JAMES', 'EARL', 'JONES'), ('QUINCY', 'JONES'), ('QUINCY', 'ADAMS'), ('JOHN', 'ADAMS'), \n", + " ('JOHN', 'QUINCY', 'ADAMS'), ('HENRY', 'JAMES'), ('JOHN', 'HENRY'), ('EARL',)]\n", + "\n", + "board = place_tiles(tiles8, 7, 7)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", "text/plain": [ - "" + "[Box(start=(3, 3), dir=(0, 1), tile=('QUINCY', 'ADAMS')),\n", + " Box(start=(3, 2), dir=(1, 0), tile=('QUINCY', 'JONES')),\n", + " Box(start=(5, 4), dir=(-1, 0), tile=('JOHN', 'ADAMS')),\n", + " Box(start=(5, 0), dir=(0, 1), tile=('JAMES', 'EARL', 'JONES')),\n", + " Box(start=(0, 4), dir=(1, 0), tile=('JOHN', 'QUINCY', 'ADAMS')),\n", + " Box(start=(3, 0), dir=(1, 0), tile=('HENRY', 'JAMES')),\n", + " Box(start=(6, 4), dir=(0, 1), tile=('JOHN', 'HENRY')),\n", + " Box(start=(6, 1), dir=(1, 0), tile=('EARL',))]" ] }, + "execution_count": 5, "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "board.boxes" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{(3, 3): 'QUINCY',\n", + " (3, 4): 'ADAMS',\n", + " (3, 2): 'QUINCY',\n", + " (4, 2): 'JONES',\n", + " (5, 4): 'JOHN',\n", + " (4, 4): 'ADAMS',\n", + " (5, 0): 'JAMES',\n", + " (5, 1): 'EARL',\n", + " (5, 2): 'JONES',\n", + " (0, 4): 'JOHN',\n", + " (1, 4): 'QUINCY',\n", + " (2, 4): 'ADAMS',\n", + " (3, 0): 'HENRY',\n", + " (4, 0): 'JAMES',\n", + " (6, 4): 'JOHN',\n", + " (6, 5): 'HENRY',\n", + " (6, 1): 'EARL'}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "board" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plotting Pretty Output\n", + "\n", + "Technically, this is a solution. But it is not pretty to look at. \n", + "\n", + "I'll define `plot_board(board)` to plot each name in each tile and draw rectangles around them. I'll take care to make the font size appropriate for the length of each name, and I'll rotate the names according to the direction the tile is going in. The `fantasy` font is something like standard cartoon lettering.\n", + "\n", + "The `(x, y)` coordinates are taken to be the **center** of a square; names are centered on `(x, y)`. But the box is drawn a half-unit to each side of the center. Actually, we want it to be a biot less than a half-unit, becuase we want the outlines of the tiles to not-quite touch. In `plot_rectangle_around` we use 0.47 instead of 0.5 for this reason.\n", + "\n", + "One more trick: Randall has `\"Billy D. WIlliams\"` as a two-square name, not three, so I will write it as `\"Billy_D. Williams\"`, split that into two names, and only convert the `\"_\"` to a `\" \"` when plotting the text.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_board(board):\n", + " \"\"\"Plot each tile box, plus a big box around the whole board.\"\"\"\n", + " plt.figure(figsize=(board.width, board.height))\n", + " plt.axis('off'); plt.axis('equal')\n", + " print(f'{len(board.boxes)} tiles placed on {len(board)} squares')\n", + " for box in board.boxes:\n", + " squares = [move(box.start, i, box.dir) for i in range(len(box.tile))]\n", + " plot_rectangle_around(squares)\n", + " for (x, y), name in zip(squares, box.tile):\n", + " plt.text(x, y, name.replace('_', ' '), va='center', ha='center', \n", + " fontsize=fontsizes[len(name)], fontdict={'family': 'fantasy'}, \n", + " rotation=directions[box.dir])\n", + "\n", + "def plot_rectangle_around(squares, half=0.47):\n", + " \"\"\"Plot a rectangle around this list of squares.\"\"\"\n", + " Xs, Ys = transpose(squares)\n", + " x0, y0 = min(Xs) - half, min(Ys) - half\n", + " x1, y1 = max(Xs) + half, max(Ys) + half\n", + " plt.plot([x0, x1, x1, x0, x0], \n", + " [y0, y0, y1, y1, y0], \n", + " 'k-')\n", + " \n", + "def transpose(matrix) -> list: return list(zip(*matrix))\n", + "\n", + "fontsizes = (0, 15, 15, 15, 13, 11, 10, 9, 7, 7, 6, 6, 6, 6, 6) # Indexed by len(name)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8 tiles placed on 17 squares\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ - "plot_board(dominoes(tiles8, 6, 6))" + "plot_board(board)" ] }, { @@ -212,46 +318,56 @@ "# 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:" + " [explainxkcd](http://www.explainxkcd.com/wiki/index.php/1970:_Name_Dominoes), with a few typos corrected. " ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "271" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "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", + "def define_tiles(text) -> list:\n", + " \"Create a list of tiles from the text containing names.\"\n", + " return [Tile(name.strip().split()) 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", + "xkcdtiles = define_tiles(\"\"\"Christian Campbell, Neve Campbell, Joe McCarthy, Eugene McCarthy, \n", + " Gene Vincent, Gene Kelly, Kate Hudson, Rock Hudson, Gordon Brown, James Brown, John 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", + " 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", + " Warren Beatty, Elizabeth Warren, Earl Warren, Elizabeth Kolbert, Stephen Colbert, George Wallace,\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", + " Charlie Parker, Ray Parker_Jr., 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", + " 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", + " Kristen Stewart, Kristen Bell, Bell 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", @@ -265,138 +381,14 @@ " 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": [ + " Van Jones, James Cameron, Cam Newton, Cameron Diaz, Huey Newton, Huey Lewis, John Lewis, \n", + " Jenny Lewis, Ryan Lewis, Burt Reynolds, Alistair Cooke, Alistair Cookie, Cokie Roberts, \n", + " John Roberts, Robert Johnson, Robert E._Lee, Tommy Lee, Tommy Lee Jones, Etta James,\n", + " John Oliver, Ryan Reynolds, Alastair Reynolds\"\"\") \n", + "\n", "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, @@ -404,37 +396,126 @@ "outputs": [ { "data": { - "image/png": "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\n", "text/plain": [ - "" + "[('EVAN', 'TAYLOR', 'JONES'),\n", + " ('JOHN', 'LEWIS'),\n", + " ('RYAN', 'REYNOLDS'),\n", + " ('RAY', 'PARKER_JR.'),\n", + " ('FATS', 'DOMINO'),\n", + " ('ARETHA', 'FRANKLIN'),\n", + " ('CHRIS', 'PRATT'),\n", + " ('HENRY', 'JAMES'),\n", + " ('FAT', 'JOE'),\n", + " ('TOMMY', 'JOHN'),\n", + " ('JAMES', 'NEWTON', 'HOWARD'),\n", + " ('BARRY', 'WHITE')]" ] }, + "execution_count": 10, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "def best(boards): return max(boards, key=lambda board: len(board.boxes))\n", - "\n", - "plot_board(best(dominoes(xkcdtiles) for _ in range(100)))" + "random.sample(xkcdtiles, 12)" ] }, { "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", + "# Approximate Matches\n", "\n", - "[![](https://imgs.xkcd.com/comics/name_dominoes_2x.png)](https://xkcd.com/1970/)\n", + "Two names in adjacent squares 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, I will manually define a set of approximate matches (again courtesy of \n", + " [explainxkcd](http://www.explainxkcd.com/wiki/index.php/1970:_Name_Dominoes)) by making the global variable `synonyms` be a set of pairs of names that should match: `{('AMY', 'AIMEE'), ('COOK', 'COOKE'),...}`. I will also redefine the function `allowed` to say that synonyms are allowed.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def define_synonyms(text='', tiles=()) -> set: \n", + " \"\"\"Build a set of {(A, B),...} pairs, meaning that A and B are synonyms.\"\"\"\n", + " synsets = [synset.strip().split('=') for synset in text.split(',')]\n", + " return {(a, b) for syn in synsets for a in syn for b in syn}\n", + "\n", + "synonyms = define_synonyms(\"\"\"AMY=AIMEE, COOK=COOKE=COOKIE=COKIE, ALASTAIR=ALISTAIR=ALESTIER, \n", + " COLUMBO=COLUMBUS, SAFIRE=SAPPHIRE=GARNET, GARNET=RUBY, CHARLIE=CHARLES, SEAN=SHAWN,\n", + " JIMMY=JIM=JAMES, MAN=MANN, JACK=JOHN=JON=JOHN_F., TOM=TOMMY=THOMAS, HOOK=HOOKS, \n", + " ROBERT=ROBERTS=BOB, CAM=CAMERON, OLIVER=OLIVIA, EDWARD=EDWARDS, RICH=RICHARD, MEG=MEGYN, \n", + " CHRIS=CHRISTOPHER=CHRISTINE=TOPHER, FAT=FATS=FATTY, WALT=WALTER, HANK=HANKS, CROW=CROWE, \n", + " COLBERT=KOLBERT, LEE=E._LEE, KLINE=KLEIN, JOE=JOSEPH, GENE=EUGENE, KATE=KATHERINE, \n", + " FRANK=FRANCIS=FRANKLIN, WATT=WATTS, STEVE=STEPHEN, DEBBY=DEBBIE, STUART=STEWART, \n", + " WILL=WILLIAM=WILLIAMS=BILLY=BILLY_D.=WILLIAM_C., RUSS=RUSSELL, EVAN=EVANS\"\"\")\n", + "\n", + "def allowed(name, nbr_contents) -> bool: \n", + " \"\"\"A name is allowed next to an empty square, a square off the board, an exact match, or a synonym.\"\"\"\n", + " return nbr_contents in (name, empty, off) or (name, nbr_contents) in synonyms" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Final Result (after Multiple Tries)\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 names were placed):" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "152 tiles placed on 312 squares\n", + "CPU times: user 3min 56s, sys: 940 ms, total: 3min 57s\n", + "Wall time: 3min 59s\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%time plot_board(max((place_tiles(xkcdtiles) for _ in range(100)), key=len))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Note:* I used a 16×35 square board while the xkcd comic used 27×35, because 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](https://xkcd.com/1970/):\n", + "\n", + "![](https://imgs.xkcd.com/comics/name_dominoes_2x.png)\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" + "- See if a different strategy can fit more tiles on the board. \n", + " - Backtracking? \n", + " - Being smarter about which frontier square to try next? \n", + " - Being smarter about which tile to place on that frontier square?\n", + "- Make the dominoes black with white letters? Ever-so-slightly round the corners?\n", + "- Download a bunch of names from Wikipedia and fill a 200 × 300 board, then laser cut tham and hang them on your wall?\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", + "- What do you want to do?\n" ] } ], @@ -454,7 +535,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.3" + "version": "3.7.7" } }, "nbformat": 4,