diff --git a/ipynb/xkcd-Name-Dominoes.ipynb b/ipynb/xkcd-Name-Dominoes.ipynb index 15790aa..8f13dd7 100644 --- a/ipynb/xkcd-Name-Dominoes.ipynb +++ b/ipynb/xkcd-Name-Dominoes.ipynb @@ -9,10 +9,17 @@ "# `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 poeple 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 with the same number/name, and neither half is adjacent to any tile with a different number/name. (The very first tile played in a game has no adjacent tiles, so it can be placed anywhere.) I will write a function to lay out tiles in a random, legal array. I'll start with two key data structures:\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", - "- **`Tile`**: a tile is a 2-element tuple, like `('TIM', 'COOK')`, indicating the two halves.\n", - "- **`Board(w, h)`**: a [w × h] 2-dimensional array of locations; each location holds as a value one half of a tile, or it can be `empty`, or it can be a `border`, meaning nothing can be placed there." + "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 mapping of locations to names.\n", + "Initially, all width × height squares on the board are `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')`.\n", + "- **`Location`**: a location is an `(x, y)` pair of coordinates for a square on the board." ] }, { @@ -21,21 +28,27 @@ "metadata": {}, "outputs": [], "source": [ - "empty = ' '\n", - "border = '--'\n", + "empty = None # An empty square\n", "\n", - "class Board(list):\n", - " \"A board is a 2d array of values.\"\n", - " \n", - " def __init__(self, width=16, height=24): \n", - " \"Initialize a [width × height] array of `empty`, surrounded by `border`\"\n", - " def rows (r, val): \n", - " return [[border] + width * [val] + [border] for _ in range(r)]\n", - " self[:] = rows(1, border) + rows(height, empty) + rows(1, border)\n", - " \n", - " def get(self, loc): return self[loc[1]][loc[0]]\n", - " \n", - " def put(self, loc, value): self[loc[1]][loc[0]] = value" + "class Board(dict):\n", + " \"A mapping from location to name.\"\n", + " def __init__(self, width=16, height=24): self.width, self.height = width, height\n", + " def __missing__(self, loc): return empty" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "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 `loc`; 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." ] }, { @@ -43,106 +56,91 @@ "execution_count": 2, "metadata": {}, "outputs": [], - "source": [ - "Board(2, 3)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "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:\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 put 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 and the other half on an adjacent location; when found, `put` the tile there, and remove it from `tiles`.\n", - "- **`legal(value, loc, board)`**: a value can be placed if the location is empty, and the value matches all the neighboring location values.\n", - "- **`neighbors(loc)`**: returns the four neighbors of a location.\n", - "- **`put(board, loc0, loc1, tile, frontier)`**: places a tile on the board; it accomplishes this by making two calls to the board's `put` method, one for each half of the tile. The `put` function also updates 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." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], "source": [ "import random\n", "\n", "def dominoes(tiles, width=16, height=24):\n", - " \"Place as many tiles on board as possible, legally and randomly.\"\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(board, (m, m), (m, m + 1), tiles.pop(), frontier) # Place first tile\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 random tile on that location.\"\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 (v, w) in [tile, tile[::-1]]:\n", - " if legal(v, loc0, board):\n", - " for loc1 in shuffle(neighbors(loc0)):\n", - " if legal(w, loc1, board):\n", - " put(board, loc0, loc1, [v, w], frontier)\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(value, loc, board):\n", - " \"Is it legal to place this value on this location on board?\"\n", - " return (board.get(loc) is empty and\n", - " all(board.get(nbr) in (empty, border, value)\n", - " for nbr in neighbors(loc)))\n", - " \n", - "def neighbors(loc):\n", - " \"Neighbors of this location.\"\n", - " x, y = loc\n", - " return [(x, y+1), (x, y-1), (x+1, y), (x-1, y)]\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 put(board, loc0, loc1, tile, frontier): \n", + "def neighbors(loc, board):\n", + " \"Neighbors of this location on the board.\"\n", + " x, y = loc\n", + " nbrs = [(x, y+1), (x, y-1), (x+1, y), (x-1, y)]\n", + " return [(X, Y) for (X, Y) in nbrs\n", + " if 0 <= X < board.width and 0 <= Y < 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.put(loc0, tile[0])\n", - " board.put(loc1, tile[1])\n", + " board[loc0], board[loc1] = tile\n", " frontier -= {loc0, loc1}\n", - " frontier |= {loc for loc in neighbors(loc0) + neighbors(loc1)\n", - " if board.get(loc) is empty}\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": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[['--', '--', '--', '--', '--', '--', '--', '--'],\n", - " ['--', ' ', ' ', 'JA', 'BO', ' ', ' ', '--'],\n", - " ['--', ' ', 'RY', 'JA', ' ', ' ', ' ', '--'],\n", - " ['--', ' ', ' ', 'JA', ' ', ' ', ' ', '--'],\n", - " ['--', 'GR', 'KE', 'KE', 'KE', 'RY', ' ', '--'],\n", - " ['--', ' ', ' ', 'KE', ' ', ' ', ' ', '--'],\n", - " ['--', 'GR', 'JO', 'JO', ' ', ' ', ' ', '--'],\n", - " ['--', '--', '--', '--', '--', '--', '--', '--']]" + "{(0, 2): 'GR',\n", + " (0, 3): 'JO',\n", + " (1, 1): 'BO',\n", + " (1, 3): 'JO',\n", + " (1, 4): 'KE',\n", + " (2, 1): 'JA',\n", + " (2, 4): 'KE',\n", + " (2, 5): 'GR',\n", + " (3, 0): 'JA',\n", + " (3, 1): 'JA',\n", + " (3, 2): 'RY',\n", + " (3, 3): 'RY',\n", + " (3, 4): 'KE',\n", + " (4, 0): 'PO',\n", + " (4, 4): 'KE',\n", + " (5, 4): 'JA'}" ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "tiles1 = [('BO', 'JA'), ('JA', 'PO'), ('JA', 'RY'), ('RY', 'KE'), \n", + "tiles8 = [('BO', 'JA'), ('JA', 'PO'), ('JA', 'RY'), ('RY', 'KE'), \n", " ('GR', 'KE'), ('GR', 'JO'), ('JA', 'KE'), ('KE', 'JO')]\n", "\n", - "dominoes(tiles1, 6, 6)" + "dominoes(tiles8, 6, 6)" ] }, { @@ -151,70 +149,68 @@ "source": [ "# Pretty Output\n", "\n", - "There are two problems with this output. One, it is ugly. Two, I can't easily tell 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", + "There are two problems with this output. 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", "- Use `matplotlib` to plot a less-ugly display; encapsulate this in the function `plot_board(board)`.\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." + "- 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. A box is a 4-tuple, `(x0, y0, x1, y1)`, holding the `x, y` coordinates\n", + "of the upper-left and lower-right corners of a box. The function `plot_box(box)` plots the rectangle. Note that in the new last line of `put_tile`, I add just `0.94`, not `1.0` to the size of the box; this way two adjacent tiles won't quite touch (as in the xkcd comic)." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "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", "def plot_board(board, figsize=(16, 24)):\n", + " \"Plot the box and name for every tile, plus a big box around the board.\"\n", " plt.figure(figsize=figsize)\n", " plt.axis('off') \n", " plt.axis('equal')\n", - " plt.tight_layout()\n", - " for (x0, y0, x1, y1) in board.boxes:\n", - " plt.plot([x0, x1, x1, x0, x0], \n", - " [y0, y0, y1, y1, y0], 'k-')\n", - " for (y, row) in enumerate(board):\n", - " for (x, val) in enumerate(row):\n", - " if val is not border:\n", - " plt.text(x + 0.5, y + 0.3, val, ha='center', fontsize=8)\n", + " for box in board.boxes:\n", + " plot_box(box)\n", + " for (x, y) in board:\n", + " plt.text(x + 0.5, y + 0.3, board[x, y], ha='center', fontsize=8)\n", + " plot_box((-2*ϵ, -2*ϵ, figsize[0] + ϵ, figsize[1] + ϵ))\n", + "\n", + "def plot_box(box):\n", + " \"Plot a box.\"\n", + " x0, y0, x1, y1 = box\n", + " plt.plot([x0, x1, x1, x0, x0], \n", + " [y0, y0, y1, y1, y0], 'k-')\n", " \n", - "class Board(list):\n", - " \"A board is a 2d array of values.\"\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 __init__(self, width=20, height=36): \n", - " \"Initialize a [width × height] array of `empty`, surrounded by `border`\"\n", - " def rows (r, val): \n", - " return [[border] + width * [val] + [border] for _ in range(r)]\n", - " self[:] = rows(1, border) + rows(height, empty) + rows(1, border)\n", - " self.boxes = []\n", - " \n", - " def get(self, loc): return self[loc[1]][loc[0]]\n", - " \n", - " def put(self, loc, value): self[loc[1]][loc[0]] = value\n", - " \n", - " \n", - "def put(board, loc0, loc1, tile, frontier): \n", - " \"Place the tile across the two locations, and update frontier.\"\n", - " board.put(loc0, tile[0])\n", - " board.put(loc1, tile[1])\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) + neighbors(loc1)\n", - " if board.get(loc) is empty}\n", + " frontier |= {loc for loc in neighbors(loc0, board) + neighbors(loc1, board)\n", + " if board[loc] is empty}\n", " (x0, y0), (x1, y1) = loc0, loc1\n", - " board.boxes.append((min(x0, x1), min(y0, y1), max(x0, x1) + 0.94, max(y0, y1) + 0.94))" + " board.boxes.append((min(x0, x1), min(y0, y1), \n", + " max(x0, x1) + 1 - ϵ, max(y0, y1) + 1 - ϵ)) " ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -222,7 +218,7 @@ } ], "source": [ - "plot_board(dominoes(tiles1, 6, 6), (6, 6))" + "plot_board(dominoes(tiles8, 6, 6), (6, 6))" ] }, { @@ -237,7 +233,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -256,8 +252,8 @@ " 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, Kein James, Garfield, James Garfield, Warren Buffett, Jimmy Buffett, \n", - " Warren Beatty, Elizabeth Warren, Earl Warren, Eliabeth Kolbert, Stephen Colbert, George Wallace,\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, 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", @@ -266,7 +262,7 @@ " 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 Wasington, Wasington Irving, Martha Wasington, Ma Rainey, Jack Ma, Super Grover, \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", @@ -275,16 +271,16 @@ " 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 Felder, \n", - " Prince Harry, Harry Styles, John Dean, Benjamin Franklin, Harrold Lloyd, Harrold Ford, \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 Russel, Harry Fielder, Harry Truman, Harry Jon Benjamin, \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, Russel Crowe, Russ Smith, John Smith, \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 Crow, 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 Tayler Jones,\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", @@ -293,7 +289,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -302,7 +298,7 @@ "270" ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -313,24 +309,24 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[('RAY', 'ALLEN'),\n", - " ('HARVEY', 'MILK'),\n", - " ('LONG JOHN', 'SILVER'),\n", - " ('MARILYN', 'MONROE'),\n", - " ('', 'PRINCE'),\n", - " ('JON', 'BROWN'),\n", - " ('WAYNE', 'NEWTON'),\n", - " ('JOHN', 'CANDY'),\n", - " ('HENRY', 'JAMES')]" + "[('VAN', 'MORRISON'),\n", + " ('HARRY JON', 'BENJAMIN'),\n", + " ('AIMEE', 'MANN'),\n", + " ('JOE', 'MCCARTHY'),\n", + " ('JOHN', 'ADAMS'),\n", + " ('CHRIS', 'HEMSWORTH'),\n", + " ('EUGENE', 'MCCARTHY'),\n", + " ('OSCAR THE', 'GROUCH'),\n", + " ('SUPER', 'GROVER')]" ] }, - "execution_count": 9, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -355,7 +351,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -381,7 +377,7 @@ " 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\"\"\", xkcdtiles)" + " FAT=FATS=FATTY, WALT=WALTER, HANK=HANKS, CROW=CROWE\"\"\", xkcdtiles)" ] }, { @@ -390,25 +386,25 @@ "collapsed": true }, "source": [ - "To make this work, I update `legal` to call the new function `match_neighbor` for each neighbor; this checks for empties, borders, and exact matches just like before, but it also consults the `synsets` global variable for an approximate or partial match, and it disallows a match between two empty values, so you can't match the empty first name of \"PRINCE\" with the empty first name of \"DRAKE\"." + "To make this work, I update `legal` to call the new function `match_neighbor` for each neighbor; this checks for empties and exact matches just like before, but it also consults the `synsets` global variable for an approximate or partial match, and it disallows a match between the empty first name of \"PRINCE\" with the empty first name of \"DRAKE\"." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "def legal(value, loc, board):\n", + "def legal(name, loc, board):\n", " \"Is it legal to place this value on this location on board?\"\n", - " return (board.get(loc) is empty and\n", - " all(match_neighbor(value, board.get(nbr)) for nbr in neighbors(loc)))\n", + " return (board[loc] is empty and\n", + " all(match_neighbor(name, board[nbr]) for nbr in neighbors(loc, board)))\n", "\n", - "def match_neighbor(value, nbrval):\n", - " \"Does this value match the neighbor's value?\"\n", - " return (nbrval in (empty, border) or \n", - " nbrval == value != '' or\n", - " nbrval in synsets[value])" + "def match_neighbor(name, nbrval):\n", + " \"Does this name match the neighbor's value?\"\n", + " return (nbrval is empty or \n", + " nbrval == name != '' or\n", + " nbrval in synsets[name])" ] }, { @@ -422,7 +418,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -437,19 +433,19 @@ "source": [ "# Final Results\n", "\n", - "Let's see what we can generate, and compare it to the original comic. *Note:* By default, I'm using a 16×24 square board; the xkcd comic uses 27×35, but if I try to fit that many then each tile will be smaller, and the names overflow the sides of the dominoes too much. (As it is, only a few names, like \"OLIVIA NEWTON JOHN\" overflow.)" + "Let's see what we can generate, and compare it to the original comic. *Note:* By default, I'm using a 16×24 square board; the xkcd comic uses 27×35, but if I try to fit that many then each tile will be smaller, and the names overflow the sides of the dominoes too much. (As it is, only a few names overflow.)" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -466,9 +462,13 @@ "source": [ "![](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 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" ] } ],