diff --git a/ipynb/Coin Flip.ipynb b/ipynb/Coin Flip.ipynb
index 820a8c7..000af0e 100644
--- a/ipynb/Coin Flip.ipynb
+++ b/ipynb/Coin Flip.ipynb
@@ -6,97 +6,114 @@
"source": [
"# The Devil and the Coin Flip Game\n",
"\n",
- "If the Devil ever challenges me to a [fiddle contest](https://en.wikipedia.org/wiki/The_Devil_Went_Down_to_Georgia), I'm going down. But I heard about a contest where I'd have a better chance:\n",
+ "If the Devil ever challenges me to a [fiddle contest](https://en.wikipedia.org/wiki/The_Devil_Went_Down_to_Georgia), I'm going down. But here is a contest where I'd have a better chance:\n",
"\n",
- "> *You're playing a game with the devil, with your soul at stake. You're sitting at a circular table which has 4 coins, arranged in a diamond, at the 12, 3, 6, and 9 o'clock positions. You are blindfolded, and can never see the coins or the table.*\n",
+ "> *You're playing a game with the Devil, with your soul at stake. You're sitting at a circular table which has 4 coins, arranged in a diamond, at the 12, 3, 6, and 9 o'clock positions. You are blindfolded, and can never see the coins or the table.*\n",
"\n",
- "> *Your goal is to get all 4 coins showing heads, by telling the devil the position(s) of some coins to flip. We call this a \"move\" on your part. The devil must faithfully perform the requested flips, but may first sneakily rotate the table any number of quarter-turns, so that the coins are in different positions. You keep making moves, and the devil keeps rotating and flipping, until all 4 coins show heads.*\n",
+ "> *Your goal is to get all 4 coins showing heads, by telling the devil the position(s) of some coins to flip. We call this a \"move\" on your part. The Devil must faithfully perform the requested flips, but may first sneakily rotate the table any number of quarter-turns, so that the coins are in different positions. You keep making moves, and the Devil keeps rotating and flipping, until all 4 coins show heads.*\n",
"\n",
- "> *Example: You tell the devil the 12 o'clock and 6 o'clock positions. The devil could leave the table unrotated (or could rotate it a half-turn), and then flip the two coins that you specified. Or the devil could rotate the table a quarter turn in either direction, and then flip the coins that are now in the 12 o'clock and 6 o'clock positions (which were formerly at 3 o'clock and 9 o'clock). You won't know which of these actions the devil took.*\n",
+ "> *Example: You tell the Devil to flip the 12 o'clock and 6 o'clock positions. The devil might rotate the table a quarter turn clockwiae, and then flip the coins that have moved into the 12 o'clock and 6 o'clock positions (which were formerly at 3 o'clock and 9 o'clock). Or the Devil could have made any other rotation before flipping.*\n",
"\n",
- "> *What is a shortest sequence of moves that is *guaranteed* to win, no matter what the initial state of the coins, and no matter what rotations the devil applies?*\n",
+ "> *What is a shortest sequence of moves that is **guaranteed** to win, no matter what the initial state of the coins, and no matter what rotations the Devil applies?*\n",
"\n",
"# Analysis\n",
"\n",
"- We're looking for a \"shortest sequence of moves\" that reaches a goal. That's a [shortest path search problem](https://en.wikipedia.org/wiki/Shortest_path_problem). I've done that before.\n",
"- Since the Devil gets to make moves too, you might think that this is a [minimax](https://en.wikipedia.org/wiki/Minimax) problem: that we should choose the move that leads to the shortest path, given that the Devil has the option of making moves that lead to the longest path.\n",
- "- In fact, the Devil would do well to determine his best move using a minimax search.\n",
- "- However, the player can't do that, because minimax only works when you know what moves the opponent is making. Here the player is blinfolded; that makes it a [partially observable problem](https://en.wikipedia.org/wiki/Partially_observable_system) (in this case, not observable at all, but we still say \"partially\").\n",
- "- In such problems, we don't know for sure the true state of the world before or after any move. So we should represent what *is* known: *the set of states that we believe to be possible*. We call this a *belief state*. At the start of the game, each of the four coins could be either heads or tails, so that's 24 = 16 possibilities in the belief state:\n",
+ "- But minimax only works when you know what moves the opponent is making: he did *that*, so I'll do *this*. In this problem the player is blinfolded; that makes it a [partially observable problem](https://en.wikipedia.org/wiki/Partially_observable_system) (in this case, not observable at all, but we still say \"partially\").\n",
+ "- In such problems, we don't know for sure the true state of the world before or after any move. So we should represent what *is* known: *the set of states that we believe to be possible*. We call this a *belief state*. At the start of the game, each of the four coins could be either heads or tails, so that's 24 = 16 possibilities in the initial belief state:\n",
" {HHHH, HHHT, HHTH, HHTT, HTHH, HTHT, HTTH, HTTT, \n",
" THHH, THHT, THTH, THTT, TTHH, TTHT, TTTH, TTTT}\n",
"- So we have a single-agent shortest path search in the space of belief states (not the space of physical states of the coins). We search for a path from the inital belief state to the goal belief state, which is `{HHHH}`.\n",
- "- A move updates the belief state as follows: for every four-coin sequence in the current belief state, rotate it in every possible way, and then flip the coins specified by the position(s) in the move. Collect all these results together to form the new belief state. The search space is small (just 216 possible belief states), so run time will be fast; the only issue is specifying the domain correctly. \n",
- "- To increase the chance of getting it right, I won't do anything fancy, such as noticing rotational symmetry (although we'll come back to that later).\n",
+ "- A move updates the belief state as follows: for every four-coin sequence in the current belief state, rotate it in every possible way, and then flip the coins specified by the position(s) in the move. Collect all these results together to form the new belief state. The search space is small (just 216 possible belief states), so run time will be fast. \n",
+ "- I'll Keep It Simple, and not worry about rotational symmetry (although we'll come back to that later).\n",
"\n",
"\n",
- "# Vocabulary and Implementation Choices\n",
+ "# Basic Data Structures and Functions\n",
"\n",
- "- `Coins`: a *coin sequence* (on the table) is represented as a `str` of four characters, such as `'HTTT'`. \n",
- "- `Belief`: a *belief state* is represented as a `frozenset` of `Coins` (frozen so that it can be hashed).\n",
+ "What data structures will I be dealing with?\n",
+ "\n",
+ "- `Coins`: a *coin sequence* (four coins, in order, on the table) is represented as a `str` of four characters, such as `'HTTT'`. \n",
+ "- `Belief`: a *belief state* is a `frozenset` of `Coins` (frozen so it can be hashed), like `{'HHHT', 'TTTH'}`.\n",
"- `Position`: an integer index into the coin sequence; position `0` selects the `H` in `'HTTT'`\n",
"and corresponds to the 12 o'clock position; position 1 corresponds to 3 o'clock, and so on.\n",
"- `Move`: a set of positions to flip, such as `{0, 2}`. \n",
- "- `Strategy`: an ordered list of moves. Since there is no feedback while playing\n",
- "(blindfolded) there are no decision points in the strategy. \n",
- "- `winning(strategy)`: a winning strategy is one that takes us from the initial state to the goal, regardless\n",
- "of what rotations the Devil chooses.\n",
- "- `all_moves()`: returns a list of every possible move a player can make.\n",
- "- `all_coins()`: returns a belief state consisting of the set of all 16 possible coin sequences: `{'HHHH', 'HHHT', ...}`.\n",
- "- `rotations(coins)`: returns a set of all 4 rotations of the coin sequence.\n",
- "- `flip(coins, move)`: flips the specified positions within the coin sequence.\n",
- " (But don't flip `'HHHH'`, because the game would have already ended if this were the coin sequence.)\n",
- "- `update(belief, move)`: returns an updated belief state: all the coin sequences that could result from any rotation followed by the specified flips.\n"
+ "- `Strategy`: an ordered list of moves. A\n",
+ "blindfolded player has no feedback, there thus no decision points in the strategy. "
]
},
{
"cell_type": "code",
"execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from collections import deque\n",
+ "from itertools import product, combinations, chain\n",
+ "import random\n",
+ "\n",
+ "Coins = ''.join # A coin sequence; a str: 'HHHT'.\n",
+ "Belief = frozenset # A set of possible coin sequences: {'HHHT', 'TTTH'}.\n",
+ "Position = int # An index into a coin sequence.\n",
+ "Move = set # A set of positions to flip: {0, 2}\n",
+ "Strategy = list # A list of Moves: [{0, 1, 2, 3}, {0, 2}, ...]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "What basic functions do I need to manipulate these data structures?\n",
+ "\n",
+ "- `all_moves()`: returns a list of every possible move a player can make.\n",
+ "- `all_coins()`: returns a belief state consisting of the set of all 16 possible coin sequences: `{'HHHH', 'HHHT', ...}`.\n",
+ "- `rotations(coins)`: returns a belief set of all 4 rotations of the coin sequence.\n",
+ "- `flip(coins, move)`: flips the specified positions within the coin sequence.\n",
+ " (But leave `'HHHH'` alone, because it ends the game.)\n",
+ "- `update(belief, move)`: returns an updated belief state: all the coin sequences that could result from any rotation followed by the specified flips.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
- "from collections import deque\n",
- "from itertools import product, combinations\n",
- "import random\n",
- "\n",
- "Coins = ''.join # A coin sequence; a str: 'HHHT'.\n",
- "Belief = frozenset # A set of possible coin sequences: {'HHHT', 'TTTH'}\n",
- "Move = set # A set of positions to flip: {0, 2}\n",
- "Strategy = list # A list of Moves: [{0, 1, 2, 3}, {0, 2}, ...]\n",
- "\n",
- "# TODO: winning(strategy)\n",
- "\n",
- "def all_moves(): return powerset(range(4))\n",
- "\n",
- "def powerset(sequence): \n",
- " \"All subsets of a sequence.\"\n",
- " return [set(c) \n",
- " for r in range(len(sequence) + 1)\n",
- " for c in combinations(sequence, r)]\n",
+ "def all_moves() -> [Move]: \n",
+ " \"List of all possible moves.\"\n",
+ " return [set(m) for m in powerset(range(4))]\n",
"\n",
"def all_coins() -> Belief:\n",
- " \"Return the belief set consisting of all possible coin sequences.\"\n",
+ " \"The belief set consisting of all possible coin sequences.\"\n",
" return Belief(map(Coins, product('HT', repeat=4)))\n",
"\n",
"def rotations(coins) -> {Coins}: \n",
- " \"A list of all possible rotations of a coin sequence.\"\n",
+ " \"A set of all possible rotations of a coin sequence.\"\n",
" return {coins[r:] + coins[:r] for r in range(4)}\n",
"\n",
"def flip(coins, move) -> Coins:\n",
" \"Flip the coins in the positions specified by the move (but leave 'HHHH' alone).\"\n",
- " if 'T' in coins: \n",
- " coins = list(coins) # Need a mutable sequence\n",
- " for i in move:\n",
- " coins[i] = ('H' if coins[i] == 'T' else 'T')\n",
+ " if 'T' not in coins: return coins # Don't flip 'HHHH'\n",
+ " coins = list(coins) # Need a mutable sequence\n",
+ " for i in move:\n",
+ " coins[i] = ('H' if coins[i] == 'T' else 'T')\n",
" return Coins(coins)\n",
"\n",
"def update(belief, move) -> Belief:\n",
" \"Update belief: consider all possible rotations, then flip.\"\n",
" return Belief(flip(c, move)\n",
" for coins in belief\n",
- " for c in rotations(coins))"
+ " for c in rotations(coins))\n",
+ "\n",
+ "flatten = chain.from_iterable\n",
+ "\n",
+ "def powerset(iterable): \n",
+ " \"powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)\"\n",
+ " # https://docs.python.org/3/library/itertools.html#itertools-recipes\n",
+ " s = list(iterable)\n",
+ " return flatten(combinations(s, r) for r in range(len(s) + 1))"
]
},
{
@@ -108,7 +125,7 @@
},
{
"cell_type": "code",
- "execution_count": 2,
+ "execution_count": 3,
"metadata": {},
"outputs": [
{
@@ -132,40 +149,13 @@
" {0, 1, 2, 3}]"
]
},
- "execution_count": 2,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "all_moves()"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "[set(),\n",
- " {'a'},\n",
- " {'b'},\n",
- " {'c'},\n",
- " {'a', 'b'},\n",
- " {'a', 'c'},\n",
- " {'b', 'c'},\n",
- " {'a', 'b', 'c'}]"
- ]
- },
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
- "powerset('abc')"
+ "all_moves()"
]
},
{
@@ -284,6 +274,26 @@
"update(all_coins(), {0, 1, 2, 3})"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "list(powerset([1,2,3]))"
+ ]
+ },
{
"cell_type": "markdown",
"metadata": {},
@@ -304,7 +314,7 @@
},
{
"cell_type": "code",
- "execution_count": 8,
+ "execution_count": 9,
"metadata": {
"collapsed": true
},
@@ -336,7 +346,7 @@
},
{
"cell_type": "code",
- "execution_count": 9,
+ "execution_count": 10,
"metadata": {},
"outputs": [
{
@@ -359,7 +369,7 @@
" {0, 1, 2, 3}]"
]
},
- "execution_count": 9,
+ "execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
@@ -376,23 +386,25 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "That's a 15-move strategy that is guaranteed to lead to a win. **Stop here** if all you want is the answer to the puzzle. Or you can continue on ...\n",
+ "That's a 15-move strategy that is guaranteed to lead to a win. **Stop here** if all you want is the answer to the puzzle. \n",
"\n",
"----\n",
"\n",
+ "Or you can continue on ...\n",
+ "\n",
"# Verifying the Winning Strategy\n",
"\n",
- "I don't have a proof, but I have some evidence that the strategy inevitably leads to the goal:\n",
- "- Exploring with paper and pencil, it does appear to work. \n",
+ "I don't have a proof, but I have some evidence that this strategy works:\n",
+ "- Exploring with paper and pencil, it looks good. \n",
"- A colleague did the puzzle and got the same answer. \n",
"- It passes the `winning` test below.\n",
"\n",
- "The function `winning` takes a strategy and plays it against a Devil that chooses rotations at random, repeating play 10,000 times (by default) for each possible starting coin sequence. Note this is dealing with concrete, individual states of the world, like `HTHH`, not belief states."
+ "The call `winning(strategy, k)` plays the strategy *k* times against a Devil that chooses starting positions and rotations at random. Note this is dealing with concrete, individual states of the world, like `HTHH`, not belief states. If `winning` returns `False`, then the strategy is *definitely* flawed. If it returns `True`, then the strategy is *probably* good—it won *k* times in a row—but that does not prove it will win every time (and either way `winning` makes no claims about being a *shortest* strategy)."
]
},
{
"cell_type": "code",
- "execution_count": 10,
+ "execution_count": 11,
"metadata": {},
"outputs": [
{
@@ -401,23 +413,24 @@
"True"
]
},
- "execution_count": 10,
+ "execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
- "def winning(strategy, repeat=10000):\n",
+ "def winning(strategy, k=100000) -> bool:\n",
" \"Is this a winning strategy? A probabilistic algorithm.\"\n",
- " return all(play(coins, strategy) == 'HHHH'\n",
- " for coins in all_coins() for _ in range(repeat))\n",
+ " return all(play(strategy) == 'HHHH'\n",
+ " for _ in range(k))\n",
"\n",
- "def play(coins, strategy):\n",
- " \"Play strategy against a random Devil; return final state of coins.\"\n",
+ "def play(strategy, starting_coins=list(all_coins())) -> Coins:\n",
+ " \"Play strategy for one game against a random Devil; return final state of coins.\"\n",
+ " coins = random.choice(starting_coins)\n",
" for move in strategy:\n",
- " if 'T' in coins:\n",
- " coins = random.choice(list(rotations(coins)))\n",
- " coins = flip(coins, move)\n",
+ " if 'T' not in coins: return coins\n",
+ " coins = random.choice(list(rotations(coins)))\n",
+ " coins = flip(coins, move)\n",
" return coins\n",
"\n",
"winning(strategy=coin_search())"
@@ -427,38 +440,45 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "This says that we played 16 × 10,000 games, and the strategy won every time. It does not say it will always win against other rotation choices, and it does not make any claims about being a shortest strategy.\n",
+ "\n",
"\n",
"# Canonical Coin Sequences\n",
"\n",
- "Consider these coin sequences: `{'HHHT', 'HHTH', 'HTHH', 'THHH'}`. In a sense, these are all the same: they all denote the same sequence of coins with the table rotated to different degrees. Since the devil is free to rotate the table any amount at any time, we could be justified in treating all four of these as equivalent, and collapsing them into one representative member (we could arbitrarily choose the one that comes first in alphabetical order, `'HHHT'`). I will redefine `Belief` as a function that returns a `frozenset`, just like before, but makes it a set of `canonical` coin sequences."
+ "Consider these coin sequences: `{'HHHT', 'HHTH', 'HTHH', 'THHH'}`. In a sense, these are all the same: they all denote the same sequence of coins with the table rotated to different degrees. Since the devil is free to rotate the table any amount at any time, we could be justified in treating all four of these as equivalent, and collapsing them into one representative member. I will redefine `Coins` so that is stil takes an iterable of `'H'` or `'T'` characters and joins them into a `str`, but I will make it consider all possible rotations of the string and (arbitraily) choose the one that comes first in alphabetical order (which would be `'HHHT'` for the four coin sequences mentioned here)."
]
},
{
"cell_type": "code",
- "execution_count": 11,
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def Coins(coins) -> str: \n",
+ " \"The canonical representation (after rotation) of the 'H'/'T' sequence.\"\n",
+ " return min(rotations(''.join(coins)))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
- "def canonical(coins): return min(rotations(coins))\n",
- "\n",
- "def Belief(coin_collection): \n",
- " \"A set of all the coin sequences in this collection, canonicalized.\"\n",
- " return frozenset(map(canonical, coin_collection))"
+ "assert Coins('HHHT') == Coins('HHTH') == Coins('HTHH') == Coins('THHH') == 'HHHT'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "With `Belief` redefined, the result of calling `all_coins` will be different:"
+ "With `Coins` redefined, the result of `all_coins()` is different:"
]
},
{
"cell_type": "code",
- "execution_count": 12,
+ "execution_count": 14,
"metadata": {},
"outputs": [
{
@@ -467,7 +487,7 @@
"frozenset({'HHHH', 'HHHT', 'HHTT', 'HTHT', 'HTTT', 'TTTT'})"
]
},
- "execution_count": 12,
+ "execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
@@ -487,7 +507,7 @@
},
{
"cell_type": "code",
- "execution_count": 13,
+ "execution_count": 15,
"metadata": {},
"outputs": [
{
@@ -510,7 +530,7 @@
" {0, 1, 2, 3}]"
]
},
- "execution_count": 13,
+ "execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
@@ -527,19 +547,19 @@
"\n",
"What if there are 3 coins on the table arranged in a triangle? Or 6 coins in a hexagon? To answer that, I'll generalize all the functions that have a \"4\" in them: `all_moves, all_coins`, `rotations` and `coin_search`.\n",
"\n",
- "To compute `all_moves()` for 4 coins, I previously used `powerset(range(4))`, and got 16 possible moves. Now I want the set of all *canonicalized* moves for any *N*: the moves `{0}` and `{1}` should be considered the same, since they both say \"flip one coin.\" Look at the canonicalized set of `all_coins(N)`, and for each one pull out the set of positions that have an `H` in them and flip those positions. (The positions with a `T` should be symmetric, so we don't need them as well.)"
+ "Computing `all_coins(N)` is easy; just take the product, and canonicalize each one with the new definition of `Coins`. For `all_moves(N)` I want canonicalized moves: the moves `{0}` and `{1}` should be considered the same, since they both say \"flip one coin.\" To get that, look at the canonicalized set of `all_coins(N)`, and for each one pull out the set of positions that have an `H` in them and flip those positions. (The positions with a `T` should be symmetric, so we don't need them as well.)"
]
},
{
"cell_type": "code",
- "execution_count": 14,
+ "execution_count": 16,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"def all_moves(N=4) -> [Move]:\n",
- " \"All rotationally invariant moves for a sequence of N coins.\"\n",
+ " \"All canonical moves for a sequence of N coins.\"\n",
" return [set(i for i in range(N) if coins[i] == 'H')\n",
" for coins in sorted(all_coins(N))]\n",
"\n",
@@ -565,18 +585,23 @@
},
{
"cell_type": "code",
- "execution_count": 15,
- "metadata": {},
+ "execution_count": 17,
+ "metadata": {
+ "collapsed": true
+ },
"outputs": [],
"source": [
"assert all_moves(3) == [{0, 1, 2}, {0, 1}, {0}, set()]\n",
"assert all_moves(4) == [{0, 1, 2, 3}, {0, 1, 2}, {0, 1}, {0, 2}, {0}, set()]\n",
+ "\n",
"assert all_coins(4) == {'HHHH', 'HHHT', 'HHTT', 'HTHT', 'HTTT', 'TTTT'}\n",
"assert all_coins(5) == {'HHHHH','HHHHT', 'HHHTT','HHTHT','HHTTT', 'HTHTT', 'HTTTT', 'TTTTT'}\n",
+ "\n",
"assert rotations('HHHHHT') == {'HHHHHT', 'HHHHTH', 'HHHTHH', 'HHTHHH', 'HTHHHH', 'THHHHH'}\n",
"assert update({'TTTTTTT'}, {3}) == {'HTTTTTT'}\n",
"assert (update(rotations('HHHHHT'), {0}) == update({'HHTHHH'}, {1}) == update({'THHHHH'}, {2})\n",
" == {'HHHHHH', 'HHHHTT', 'HHHTHT', 'HHTHHT'})\n",
+ "\n",
"assert coin_search(4) == [\n",
" {0, 1, 2, 3},\n",
" {0, 2},\n",
@@ -604,7 +629,7 @@
},
{
"cell_type": "code",
- "execution_count": 17,
+ "execution_count": 18,
"metadata": {},
"outputs": [
{
@@ -624,7 +649,7 @@
" 12: 352}"
]
},
- "execution_count": 17,
+ "execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
@@ -645,7 +670,7 @@
},
{
"cell_type": "code",
- "execution_count": 18,
+ "execution_count": 19,
"metadata": {},
"outputs": [
{
@@ -674,7 +699,7 @@
" 7: None}"
]
},
- "execution_count": 18,
+ "execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
@@ -689,7 +714,9 @@
"source": [
"Too bad; there are no winning strategies for N = 3, 5, 6, or 7. \n",
"\n",
- "There *are* winning strategies for N = 1, 2, 4; they have lengths 1, 3, 15, respectively. That suggests the conjecture: \n",
+ "There *are* winning strategies for N = 1, 2, 4; they have lengths 1, 3, 15, respectively. Hmm. That suggests ...\n",
+ "\n",
+ "# A Conjecture\n",
"\n",
"> For every *N* that is a power of 2, there will be a shortest winning strategy of length 2*N* - 1.\n",
"\n",
@@ -702,15 +729,15 @@
},
{
"cell_type": "code",
- "execution_count": 19,
+ "execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "CPU times: user 1min 22s, sys: 250 ms, total: 1min 22s\n",
- "Wall time: 1min 23s\n"
+ "CPU times: user 1min 18s, sys: 118 ms, total: 1min 18s\n",
+ "Wall time: 1min 18s\n"
]
}
],
@@ -720,7 +747,7 @@
},
{
"cell_type": "code",
- "execution_count": 20,
+ "execution_count": 21,
"metadata": {},
"outputs": [
{
@@ -729,7 +756,7 @@
"255"
]
},
- "execution_count": 20,
+ "execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
@@ -742,7 +769,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Eureka! That's evidence in favor of the conjecture. But not proof. And it leaves many questions unanswered:\n",
+ "**Eureka!** That's evidence in favor of the conjecture. But not proof. And it leaves many questions unanswered:\n",
"- Can you show there are no winning strategies for *N* = 9, 10, 11, ...?\n",
"- Can you prove there are no winning strategies for any *N* that is not a power of 2?\n",
"- Can you find a winning strategy of length 65,535 for *N* = 16 and verify that it works?\n",
@@ -762,7 +789,7 @@
},
{
"cell_type": "code",
- "execution_count": 21,
+ "execution_count": 22,
"metadata": {
"collapsed": true
},
@@ -772,40 +799,39 @@
" \"For each move, print the move number, move, and belief state.\"\n",
" belief = all_coins(N)\n",
" order = sorted(belief)\n",
- " show_line(0, {}, belief, order, N)\n",
" for (i, move) in enumerate(moves, 1):\n",
" belief = update(belief, move)\n",
- " show_line(i, move, belief, order, N)\n",
+ " print('{:3} | {:8} | {}'.format(\n",
+ " i, movestr(move, N), beliefstr(belief, order)))\n",
"\n",
- "def show_line(i, move, belief, order, N):\n",
- " \"Print the move number, move, and belief state.\"\n",
- " ordered_belief = [(coins if coins in belief else ' ' * len(coins))\n",
- " for coins in order]\n",
- " print('{:3} | {:8} | {}'\n",
- " .format(i, movestr(move, N), join(ordered_belief, ' ')))\n",
+ "def beliefstr(belief, order) -> str: \n",
+ " return join(((coins if coins in belief else ' ' * len(coins))\n",
+ " for coins in order), ' ')\n",
+ "\n",
+ "def movestr(move, N) -> str: \n",
+ " return join((i if i in move else ' ') \n",
+ " for i in range(N))\n",
" \n",
- "def movestr(move, N): return join((i if i in move else ' ') for i in range(N))\n",
- " \n",
- "def join(items, sep='') -> str: return sep.join(map(str, items))"
+ "def join(items, sep='') -> str: \n",
+ " return sep.join(map(str, items))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "The following table shows the move number, the move (e.g. \"01\" to flip positions 0 and 1), and all the canonical coin sequences in the belief state after the move:"
+ "The following tables shows how moves change the belief state:"
]
},
{
"cell_type": "code",
- "execution_count": 22,
+ "execution_count": 23,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- " 0 | | HH HT TT\n",
" 1 | 01 | HH HT \n",
" 2 | 0 | HH TT\n",
" 3 | 01 | HH \n"
@@ -818,14 +844,13 @@
},
{
"cell_type": "code",
- "execution_count": 23,
+ "execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- " 0 | | HHHH HHHT HHTT HTHT HTTT TTTT\n",
" 1 | 0123 | HHHH HHHT HHTT HTHT HTTT \n",
" 2 | 0 2 | HHHH HHHT HHTT HTTT TTTT\n",
" 3 | 0123 | HHHH HHHT HHTT HTTT \n",
@@ -859,22 +884,21 @@
},
{
"cell_type": "code",
- "execution_count": 24,
+ "execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- " 1: HHTH rot: HTHH flip: 0123 => THTT\n",
- " 2: THTT rot: HTTT flip: 0 2 => TTHT\n",
- " 3: TTHT rot: THTT flip: 0123 => HTHH\n",
- " 4: HTHH rot: THHH flip: 01 => HTHH\n",
- " 5: HTHH rot: HHHT flip: 0123 => TTTH\n",
- " 6: TTTH rot: HTTT flip: 0 2 => TTHT\n",
- " 7: TTHT rot: THTT flip: 0123 => HTHH\n",
- " 8: HTHH rot: HHHT flip: 012 => TTTT\n",
- " 9: TTTT rot: TTTT flip: 0123 => HHHH\n"
+ " 1: HHTH rot: HHHT flip: 0123 => HTTT\n",
+ " 2: HTTT rot: TTTH flip: 0 2 => HHHT\n",
+ " 3: HHHT rot: HTHH flip: 0123 => HTTT\n",
+ " 4: HTTT rot: HTTT flip: 01 => HTTT\n",
+ " 5: HTTT rot: TTHT flip: 0123 => HHHT\n",
+ " 6: HHHT rot: THHH flip: 0 2 => HHHT\n",
+ " 7: HHHT rot: THHH flip: 0123 => HTTT\n",
+ " 8: HTTT rot: TTTH flip: 012 => HHHH\n"
]
},
{
@@ -883,7 +907,7 @@
"'HHHH'"
]
},
- "execution_count": 24,
+ "execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
@@ -893,13 +917,13 @@
" \"Play strategy against a random Devil; return final state of coins.\"\n",
" N = len(coins)\n",
" for i, move in enumerate(strategy, 1):\n",
- " if 'T' in coins: \n",
- " coins0 = coins\n",
- " coins1 = random.choice(list(rotations(coins)))\n",
- " coins = flip(coins1, move)\n",
- " if verbose: \n",
- " print('{:4d}: {} rot: {} flip: {} => {}'.format(\n",
- " i, coins0, coins1, movestr(move, N), coins))\n",
+ " if 'T' not in coins: return coins\n",
+ " coins0 = coins\n",
+ " coins1 = random.choice(list(rotations(coins)))\n",
+ " coins = flip(coins1, move)\n",
+ " if verbose: \n",
+ " print('{:4d}: {} rot: {} flip: {} => {}'.format(\n",
+ " i, coins0, coins1, movestr(move, N), coins))\n",
" return coins\n",
"\n",
"play('HHTH', coin_search(4), True)"
@@ -907,243 +931,268 @@
},
{
"cell_type": "code",
- "execution_count": 25,
+ "execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- " 1: HTTHTTHT rot: TTHTTHTH flip: 01234567 => HHTHHTHT\n",
- " 2: HHTHHTHT rot: THTHHTHH flip: 0 2 4 6 => HHHHTTTH\n",
- " 3: HHHHTTTH rot: HHHHTTTH flip: 01234567 => TTTTHHHT\n",
- " 4: TTTTHHHT rot: HHHTTTTT flip: 01 45 => TTHTHHTT\n",
- " 5: TTHTHHTT rot: THHTTTTH flip: 01234567 => HTTHHHHT\n",
- " 6: HTTHHHHT rot: THTTHHHH flip: 0 2 4 6 => HHHTTHTH\n",
- " 7: HHHTTHTH rot: TTHTHHHH flip: 01234567 => HHTHTTTT\n",
- " 8: HHTHTTTT rot: THTTTTHH flip: 012 456 => HTHTHHTH\n",
- " 9: HTHTHHTH rot: HHTHHTHT flip: 01234567 => TTHTTHTH\n",
- " 10: TTHTTHTH rot: HTTHTHTT flip: 0 2 4 6 => TTHHHHHT\n",
- " 11: TTHHHHHT rot: THHHHHTT flip: 01234567 => HTTTTTHH\n",
- " 12: HTTTTTHH rot: TTTHHHTT flip: 01 45 => HHTHTTTT\n",
- " 13: HHTHTTTT rot: THTTTTHH flip: 01234567 => HTHHHHTT\n",
- " 14: HTHHHHTT rot: TTHTHHHH flip: 0 2 4 6 => HTTTTHTH\n",
- " 15: HTTTTHTH rot: TTHTHHTT flip: 01234567 => HHTHTTHH\n",
- " 16: HHTHTTHH rot: THHHHTHT flip: 0123 => HTTTHTHT\n",
- " 17: HTTTHTHT rot: HTHTHTTT flip: 01234567 => THTHTHHH\n",
- " 18: THTHTHHH rot: HTHTHTHH flip: 0 2 4 6 => TTTTTTTH\n",
- " 19: TTTTTTTH rot: TTTTTTTH flip: 01234567 => HHHHHHHT\n",
- " 20: HHHHHHHT rot: THHHHHHH flip: 01 45 => HTHHTTHH\n",
- " 21: HTHHTTHH rot: HHTHHTTH flip: 01234567 => TTHTTHHT\n",
- " 22: TTHTTHHT rot: THHTTTHT flip: 0 2 4 6 => HHTTHTTT\n",
- " 23: HHTTHTTT rot: HTTTHHTT flip: 01234567 => THHHTTHH\n",
- " 24: THHHTTHH rot: THHTHHHT flip: 012 456 => HTTTTTTT\n",
- " 25: HTTTTTTT rot: TTTTTHTT flip: 01234567 => HHHHHTHH\n",
- " 26: HHHHHTHH rot: HHTHHHHH flip: 0 2 4 6 => THHHTHTH\n",
- " 27: THHHTHTH rot: HTHTHTHH flip: 01234567 => THTHTHTT\n",
- " 28: THTHTHTT rot: TTHTHTHT flip: 01 45 => HHHTTHHT\n",
- " 29: HHHTTHHT rot: TTHHTHHH flip: 01234567 => HHTTHTTT\n",
- " 30: HHTTHTTT rot: HTTTHHTT flip: 0 2 4 6 => TTHTTHHT\n",
- " 31: TTHTTHHT rot: HTTHHTTT flip: 01234567 => THHTTHHH\n",
- " 32: THHTTHHH rot: HTTHHHTH flip: 01234 6 => THHTTHHH\n",
- " 33: THHTTHHH rot: TTHHHTHH flip: 01234567 => HHTTTHTT\n",
- " 34: HHTTTHTT rot: TTHHTTTH flip: 0 2 4 6 => HTTHHTHH\n",
- " 35: HTTHHTHH rot: TTHHTHHH flip: 01234567 => HHTTHTTT\n",
- " 36: HHTTHTTT rot: HTTHTTTH flip: 01 45 => THTHHHTH\n",
- " 37: THTHHHTH rot: HTHTHHHT flip: 01234567 => THTHTTTH\n",
- " 38: THTHTTTH rot: HTHTTTHT flip: 0 2 4 6 => TTTTHTTT\n",
- " 39: TTTTHTTT rot: THTTTTTT flip: 01234567 => HTHHHHHH\n",
- " 40: HTHHHHHH rot: HHHHHHTH flip: 012 456 => TTTHTTHH\n",
- " 41: TTTHTTHH rot: TTHTTHHT flip: 01234567 => HHTHHTTH\n",
- " 42: HHTHHTTH rot: THHTTHHH flip: 0 2 4 6 => HHTTHHTH\n",
- " 43: HHTTHHTH rot: HHHTTHHT flip: 01234567 => TTTHHTTH\n",
- " 44: TTTHHTTH rot: HHTTHTTT flip: 01 45 => TTTTTHTT\n",
- " 45: TTTTTHTT rot: TTTTTTHT flip: 01234567 => HHHHHHTH\n",
- " 46: HHHHHHTH rot: HHHHHHHT flip: 0 2 4 6 => THTHTHTT\n",
- " 47: THTHTHTT rot: THTHTTTH flip: 01234567 => HTHTHHHT\n",
- " 48: HTHTHHHT rot: HTHHHTHT flip: 0123 => THTTHTHT\n",
- " 49: THTTHTHT rot: TTHTHTTH flip: 01234567 => HHTHTHHT\n",
- " 50: HHTHTHHT rot: THTHHTHH flip: 0 2 4 6 => HHHHTTTH\n",
- " 51: HHHHTTTH rot: HHHHTTTH flip: 01234567 => TTTTHHHT\n",
- " 52: TTTTHHHT rot: TTHHHTTT flip: 01 45 => HHHHTHTT\n",
- " 53: HHHHTHTT rot: TTHHHHTH flip: 01234567 => HHTTTTHT\n",
- " 54: HHTTTTHT rot: THHTTTTH flip: 0 2 4 6 => HHTTHTHH\n",
- " 55: HHTTHTHH rot: HHTTHTHH flip: 01234567 => TTHHTHTT\n",
- " 56: TTHHTHTT rot: TTTTHHTH flip: 012 456 => HHHTTTHH\n",
- " 57: HHHTTTHH rot: HHHHTTTH flip: 01234567 => TTTTHHHT\n",
- " 58: TTTTHHHT rot: TTTTTHHH flip: 0 2 4 6 => HTHTHHTH\n",
- " 59: HTHTHHTH rot: THHTHHTH flip: 01234567 => HTTHTTHT\n",
- " 60: HTTHTTHT rot: THTHTTHT flip: 01 45 => HTTHHHHT\n",
- " 61: HTTHHHHT rot: THTTHHHH flip: 01234567 => HTHHTTTT\n",
- " 62: HTHHTTTT rot: TTHTHHTT flip: 0 2 4 6 => HTTTTHHT\n",
- " 63: HTTTTHHT rot: HHTHTTTT flip: 01234567 => TTHTHHHH\n",
- " 64: TTHTHHHH rot: TTHTHHHH flip: 012345 => HHTHTTHH\n",
- " 65: HHTHTTHH rot: TTHHHHTH flip: 01234567 => HHTTTTHT\n",
- " 66: HHTTTTHT rot: THTHHTTT flip: 0 2 4 6 => HHHHTTHT\n",
- " 67: HHHHTTHT rot: THTHHHHT flip: 01234567 => HTHTTTTH\n",
- " 68: HTHTTTTH rot: THTTTTHH flip: 01 45 => HTTTHHHH\n",
- " 69: HTTTHHHH rot: TTTHHHHH flip: 01234567 => HHHTTTTT\n",
- " 70: HHHTTTTT rot: TTTTTHHH flip: 0 2 4 6 => HTHTHHTH\n",
- " 71: HTHTHHTH rot: HHTHHTHT flip: 01234567 => TTHTTHTH\n",
- " 72: TTHTTHTH rot: TTHTHTTH flip: 012 456 => HHTTTHHH\n",
- " 73: HHTTTHHH rot: TTHHHHHT flip: 01234567 => HHTTTTTH\n",
- " 74: HHTTTTTH rot: TTTTHHHT flip: 0 2 4 6 => HTHTTHTT\n",
- " 75: HTHTTHTT rot: TTHTHTTH flip: 01234567 => HHTHTHHT\n",
- " 76: HHTHTHHT rot: HTHHTHTH flip: 01 45 => THHHHTTH\n",
- " 77: THHHHTTH rot: THTHHHHT flip: 01234567 => HTHTTTTH\n",
- " 78: HTHTTTTH rot: TTTTHHTH flip: 0 2 4 6 => HTHTTHHH\n",
- " 79: HTHTTHHH rot: HTTHHHHT flip: 01234567 => THHTTTTH\n",
- " 80: THHTTTTH rot: TTTHTHHT flip: 0123 => HHHTTHHT\n",
- " 81: HHHTTHHT rot: HTHHHTTH flip: 01234567 => THTTTHHT\n",
- " 82: THTTTHHT rot: TTHHTTHT flip: 0 2 4 6 => HTTHHTTT\n",
- " 83: HTTHHTTT rot: TTTHTTHH flip: 01234567 => HHHTHHTT\n",
- " 84: HHHTHHTT rot: THHTTHHH flip: 01 45 => HTHTHTHH\n",
- " 85: HTHTHTHH rot: HTHHHTHT flip: 01234567 => THTTTHTH\n",
- " 86: THTTTHTH rot: THTHTHTT flip: 0 2 4 6 => HHHHHHHT\n",
- " 87: HHHHHHHT rot: HHHHHHTH flip: 01234567 => TTTTTTHT\n",
- " 88: TTTTTTHT rot: THTTTTTT flip: 012 456 => HTHTHHHT\n",
- " 89: HTHTHHHT rot: HHTHTHTH flip: 01234567 => TTHTHTHT\n",
- " 90: TTHTHTHT rot: TTHTHTHT flip: 0 2 4 6 => HTTTTTTT\n",
- " 91: HTTTTTTT rot: TTTTTHTT flip: 01234567 => HHHHHTHH\n",
- " 92: HHHHHTHH rot: HHHTHHHH flip: 01 45 => TTHTTTHH\n",
- " 93: TTHTTTHH rot: THTTTHHT flip: 01234567 => HTHHHTTH\n",
- " 94: HTHHHTTH rot: HTTHHTHH flip: 0 2 4 6 => TTHHTTTH\n",
- " 95: TTHHTTTH rot: HHTTTHTT flip: 01234567 => TTHHHTHH\n",
- " 96: TTHHHTHH rot: HTHHTTHH flip: 01234 6 => THTTHTTH\n",
- " 97: THTTHTTH rot: HTTHTHTT flip: 01234567 => THHTHTHH\n",
- " 98: THHTHTHH rot: HHTHTHHT flip: 0 2 4 6 => THHHHHTT\n",
- " 99: THHHHHTT rot: HHHHHTTT flip: 01234567 => TTTTTHHH\n",
- " 100: TTTTTHHH rot: TTTHHHTT flip: 01 45 => HHTHTTTT\n",
- " 101: HHTHTTTT rot: HTHTTTTH flip: 01234567 => THTHHHHT\n",
- " 102: THTHHHHT rot: THTHHHHT flip: 0 2 4 6 => HHHHTHTT\n",
- " 103: HHHHTHTT rot: HTHTTHHH flip: 01234567 => THTHHTTT\n",
- " 104: THTHHTTT rot: TTTTHTHH flip: 012 456 => HHHTTHTH\n",
- " 105: HHHTTHTH rot: TTHTHHHH flip: 01234567 => HHTHTTTT\n",
- " 106: HHTHTTTT rot: HHTHTTTT flip: 0 2 4 6 => THHHHTHT\n",
- " 107: THHHHTHT rot: HHHTHTTH flip: 01234567 => TTTHTHHT\n",
- " 108: TTTHTHHT rot: TTTHTHHT flip: 01 45 => HHTHHTHT\n",
- " 109: HHTHHTHT rot: HHTHTHHT flip: 01234567 => TTHTHTTH\n",
- " 110: TTHTHTTH rot: THTHTTHT flip: 0 2 4 6 => HHHHHTTT\n",
- " 111: HHHHHTTT rot: HTTTHHHH flip: 01234567 => THHHTTTT\n",
- " 112: THHHTTTT rot: TTTTTHHH flip: 0123 => HHHHTHHH\n",
- " 113: HHHHTHHH rot: HTHHHHHH flip: 01234567 => THTTTTTT\n",
- " 114: THTTTTTT rot: THTTTTTT flip: 0 2 4 6 => HHHTHTHT\n",
- " 115: HHHTHTHT rot: HHTHTHTH flip: 01234567 => TTHTHTHT\n",
- " 116: TTHTHTHT rot: HTHTHTTT flip: 01 45 => THHTTHTT\n",
- " 117: THHTTHTT rot: THTTTHHT flip: 01234567 => HTHHHTTH\n",
- " 118: HTHHHTTH rot: HHTHHHTT flip: 0 2 4 6 => THHHTHHT\n",
- " 119: THHHTHHT rot: THHHTHHT flip: 01234567 => HTTTHTTH\n",
- " 120: HTTTHTTH rot: THHTTTHT flip: 012 456 => HTTTHHTT\n",
- " 121: HTTTHHTT rot: HHTTHTTT flip: 01234567 => TTHHTHHH\n",
- " 122: TTHHTHHH rot: HTHHHTTH flip: 0 2 4 6 => TTTHTTHH\n",
- " 123: TTTHTTHH rot: THHTTTHT flip: 01234567 => HTTHHHTH\n",
- " 124: HTTHHHTH rot: HHTTHHHT flip: 01 45 => TTTTTTHT\n",
- " 125: TTTTTTHT rot: TTTTTHTT flip: 01234567 => HHHHHTHH\n",
- " 126: HHHHHTHH rot: HHHHHHTH flip: 0 2 4 6 => THTHTHHH\n",
- " 127: THTHTHHH rot: THHHTHTH flip: 01234567 => HTTTHTHT\n",
- " 128: HTTTHTHT rot: TTHTHTHT flip: 0123456 => HHTHTHTT\n",
- " 129: HHTHTHTT rot: HTHTTHHT flip: 01234567 => THTHHTTH\n",
- " 130: THTHHTTH rot: THTHTHHT flip: 0 2 4 6 => HHHHHHTT\n",
- " 131: HHHHHHTT rot: TTHHHHHH flip: 01234567 => HHTTTTTT\n",
- " 132: HHTTTTTT rot: THHTTTTT flip: 01 45 => HTHTHHTT\n",
- " 133: HTHTHHTT rot: TTHTHTHH flip: 01234567 => HHTHTHTT\n",
- " 134: HHTHTHTT rot: THTTHHTH flip: 0 2 4 6 => HHHTTHHH\n",
- " 135: HHHTTHHH rot: THHHHHHT flip: 01234567 => HTTTTTTH\n",
- " 136: HTTTTTTH rot: TTTTTHHT flip: 012 456 => HHHTHTTT\n",
- " 137: HHHTHTTT rot: HTHTTTHH flip: 01234567 => THTHHHTT\n",
- " 138: THTHHHTT rot: TTTHTHHH flip: 0 2 4 6 => HTHHHHTH\n",
- " 139: HTHHHHTH rot: HTHHTHHH flip: 01234567 => THTTHTTT\n",
- " 140: THTTHTTT rot: TTHTTHTT flip: 01 45 => HHHTHTTT\n",
- " 141: HHHTHTTT rot: HHTHTTTH flip: 01234567 => TTHTHHHT\n",
- " 142: TTHTHHHT rot: THTHHHTT flip: 0 2 4 6 => HHHHTHHT\n",
- " 143: HHHHTHHT rot: HTHHTHHH flip: 01234567 => THTTHTTT\n",
- " 144: THTTHTTT rot: HTTHTTTT flip: 0123 => THHTTTTT\n",
- " 145: THHTTTTT rot: THHTTTTT flip: 01234567 => HTTHHHHH\n",
- " 146: HTTHHHHH rot: HHHTTHHH flip: 0 2 4 6 => THTTHHTH\n",
- " 147: THTTHHTH rot: HTHTTHHT flip: 01234567 => THTHHTTH\n",
- " 148: THTHHTTH rot: THTHTHHT flip: 01 45 => HTTHHTHT\n",
- " 149: HTTHHTHT rot: HHTHTHTT flip: 01234567 => TTHTHTHH\n",
- " 150: TTHTHTHH rot: HTTHTHTH flip: 0 2 4 6 => TTHHHHHH\n",
- " 151: TTHHHHHH rot: HHHTTHHH flip: 01234567 => TTTHHTTT\n",
- " 152: TTTHHTTT rot: TTHHTTTT flip: 012 456 => HHTHHHHT\n",
- " 153: HHTHHHHT rot: HTHHHHTH flip: 01234567 => THTTTTHT\n",
- " 154: THTTTTHT rot: HTTHTTTT flip: 0 2 4 6 => TTHHHTHT\n",
- " 155: TTHHHTHT rot: HHHTHTTT flip: 01234567 => TTTHTHHH\n",
- " 156: TTTHTHHH rot: THTHHHTT flip: 01 45 => HTTHTTTT\n",
- " 157: HTTHTTTT rot: THTTHTTT flip: 01234567 => HTHHTHHH\n",
- " 158: HTHHTHHH rot: THHTHHHH flip: 0 2 4 6 => HHTTTHTH\n",
- " 159: HHTTTHTH rot: HHHTTTHT flip: 01234567 => TTTHHHTH\n",
- " 160: TTTHHHTH rot: HTHTTTHH flip: 01234 6 => THTHHTTH\n",
- " 161: THTHHTTH rot: HTHHTTHT flip: 01234567 => THTTHHTH\n",
- " 162: THTTHHTH rot: HTHTTHHT flip: 0 2 4 6 => TTTTHHTT\n",
- " 163: TTTTHHTT rot: TTHHTTTT flip: 01234567 => HHTTHHHH\n",
- " 164: HHTTHHHH rot: HHHHTTHH flip: 01 45 => TTHHHHHH\n",
- " 165: TTHHHHHH rot: HHHHHTTH flip: 01234567 => TTTTTHHT\n",
- " 166: TTTTTHHT rot: HTTTTTTH flip: 0 2 4 6 => TTHTHTHH\n",
- " 167: TTHTHTHH rot: THHTTHTH flip: 01234567 => HTTHHTHT\n",
- " 168: HTTHHTHT rot: TTHHTHTH flip: 012 456 => HHTHHTHH\n",
- " 169: HHTHHTHH rot: THHTHHHH flip: 01234567 => HTTHTTTT\n",
- " 170: HTTHTTTT rot: TTTHTTHT flip: 0 2 4 6 => HTHHHTTT\n",
- " 171: HTHHHTTT rot: TTTHTHHH flip: 01234567 => HHHTHTTT\n",
- " 172: HHHTHTTT rot: TTHHHTHT flip: 01 45 => HHHHTHHT\n",
+ " 1: HTTHTTHT rot: TTHTHTTH flip: 01234567 => HHTHHTHT\n",
+ " 2: HHTHHTHT rot: HHTHTHHT flip: 0 2 4 6 => HHHHHTTT\n",
+ " 3: HHHHHTTT rot: TTHHHHHT flip: 01234567 => HHHTTTTT\n",
+ " 4: HHHTTTTT rot: HTTTTTHH flip: 01 45 => HHHHTHTT\n",
+ " 5: HHHHTHTT rot: HTHTTHHH flip: 01234567 => HHTTTTHT\n",
+ " 6: HHTTTTHT rot: TTTHTHHT flip: 0 2 4 6 => HHHHTTHT\n",
+ " 7: HHHHTTHT rot: TTHTHHHH flip: 01234567 => HHTHTTTT\n",
+ " 8: HHTHTTTT rot: THHTHTTT flip: 012 456 => HHTHTTTT\n",
+ " 9: HHTHTTTT rot: THHTHTTT flip: 01234567 => HHHHTTHT\n",
+ " 10: HHHHTTHT rot: TTHTHHHH flip: 0 2 4 6 => HHTTTTHT\n",
+ " 11: HHTTTTHT rot: HTHHTTTT flip: 01234567 => HHHHTHTT\n",
+ " 12: HHHHTHTT rot: HTTHHHHT flip: 01 45 => HTHTTHTT\n",
+ " 13: HTHTTHTT rot: THTTHTTH flip: 01234567 => HHTHHTHT\n",
+ " 14: HHTHHTHT rot: THHTHTHH flip: 0 2 4 6 => HHHTTTTT\n",
+ " 15: HHHTTTTT rot: TTTTTHHH flip: 01234567 => HHHHHTTT\n",
+ " 16: HHHHHTTT rot: HHHTTTHH flip: 0123 => HHTTTHTT\n",
+ " 17: HHTTTHTT rot: HHTTTHTT flip: 01234567 => HHHTHHTT\n",
+ " 18: HHHTHHTT rot: HHHTHHTT flip: 0 2 4 6 => HHTTHTTT\n",
+ " 19: HHTTHTTT rot: TTHTTTHH flip: 01234567 => HHHTTHHT\n",
+ " 20: HHHTTHHT rot: HHHTTHHT flip: 01 45 => HTHTHTTT\n",
+ " 21: HTHTHTTT rot: TTHTHTHT flip: 01234567 => HHHTHTHT\n",
+ " 22: HHHTHTHT rot: HHHTHTHT flip: 0 2 4 6 => HTTTTTTT\n",
+ " 23: HTTTTTTT rot: TTTTTTTH flip: 01234567 => HHHHHHHT\n",
+ " 24: HHHHHHHT rot: HHHHHHHT flip: 012 456 => HTTTTTTT\n",
+ " 25: HTTTTTTT rot: TTTTTHTT flip: 01234567 => HHHHHHHT\n",
+ " 26: HHHHHHHT rot: HHHHHHHT flip: 0 2 4 6 => HTHTHTTT\n",
+ " 27: HTHTHTTT rot: THTTTHTH flip: 01234567 => HHHTHTHT\n",
+ " 28: HHHTHTHT rot: HHHTHTHT flip: 01 45 => HHTTTHTT\n",
+ " 29: HHTTTHTT rot: TTHHTTTH flip: 01234567 => HHHTHHTT\n",
+ " 30: HHHTHHTT rot: TTHHHTHH flip: 0 2 4 6 => HHTTHTTT\n",
+ " 31: HHTTHTTT rot: HTTHTTTH flip: 01234567 => HHHTTHHT\n",
+ " 32: HHHTTHHT rot: TTHHTHHH flip: 01234 6 => HHHTTHHT\n",
+ " 33: HHHTTHHT rot: THHHTTHH flip: 01234567 => HHTTHTTT\n",
+ " 34: HHTTHTTT rot: TTTHHTTH flip: 0 2 4 6 => HHHTHHTT\n",
+ " 35: HHHTHHTT rot: HTTHHHTH flip: 01234567 => HHTTTHTT\n",
+ " 36: HHTTTHTT rot: TTHHTTTH flip: 01 45 => HHHHHHHT\n",
+ " 37: HHHHHHHT rot: HTHHHHHH flip: 01234567 => HTTTTTTT\n",
+ " 38: HTTTTTTT rot: HTTTTTTT flip: 0 2 4 6 => HTHTHTTT\n",
+ " 39: HTHTHTTT rot: THTHTTTH flip: 01234567 => HHHTHTHT\n",
+ " 40: HHHTHTHT rot: HHHTHTHT flip: 012 456 => HTTTTTTT\n",
+ " 41: HTTTTTTT rot: TTTTTTTH flip: 01234567 => HHHHHHHT\n",
+ " 42: HHHHHHHT rot: HHTHHHHH flip: 0 2 4 6 => HHHTHTHT\n",
+ " 43: HHHTHTHT rot: HTHHHTHT flip: 01234567 => HTHTHTTT\n",
+ " 44: HTHTHTTT rot: HTHTHTTT flip: 01 45 => HHTTHTTT\n",
+ " 45: HHTTHTTT rot: TTHTTTHH flip: 01234567 => HHHTTHHT\n",
+ " 46: HHHTTHHT rot: HTTHHTHH flip: 0 2 4 6 => HHTTTHTT\n",
+ " 47: HHTTTHTT rot: THTTHHTT flip: 01234567 => HHHTHHTT\n",
+ " 48: HHHTHHTT rot: HHTHHTTH flip: 0123 => HTHTTHTT\n",
+ " 49: HTHTTHTT rot: TTHTTHTH flip: 01234567 => HHTHHTHT\n",
+ " 50: HHTHHTHT rot: THTHHTHH flip: 0 2 4 6 => HHHHHTTT\n",
+ " 51: HHHHHTTT rot: HTTTHHHH flip: 01234567 => HHHTTTTT\n",
+ " 52: HHHTTTTT rot: TTHHHTTT flip: 01 45 => HHHHTHTT\n",
+ " 53: HHHHTHTT rot: HHHHTHTT flip: 01234567 => HHTTTTHT\n",
+ " 54: HHTTTTHT rot: TTTTHTHH flip: 0 2 4 6 => HHTHTTTT\n",
+ " 55: HHTHTTTT rot: THTTTTHH flip: 01234567 => HHHHTTHT\n",
+ " 56: HHHHTTHT rot: HHTTHTHH flip: 012 456 => HTHTTHTT\n",
+ " 57: HTHTTHTT rot: THTTHTTH flip: 01234567 => HHTHHTHT\n",
+ " 58: HHTHHTHT rot: HHTHTHHT flip: 0 2 4 6 => HHHHHTTT\n",
+ " 59: HHHHHTTT rot: HHTTTHHH flip: 01234567 => HHHTTTTT\n",
+ " 60: HHHTTTTT rot: TTTTHHHT flip: 01 45 => HHTTTTHT\n",
+ " 61: HHTTTTHT rot: HTTTTHTH flip: 01234567 => HHHHTHTT\n",
+ " 62: HHHHTHTT rot: THHHHTHT flip: 0 2 4 6 => HHTHTTTT\n",
+ " 63: HHTHTTTT rot: THTTTTHH flip: 01234567 => HHHHTTHT\n",
+ " 64: HHHHTTHT rot: HHHTTHTH flip: 012345 => HHTTHTTT\n",
+ " 65: HHTTHTTT rot: HTTHTTTH flip: 01234567 => HHHTTHHT\n",
+ " 66: HHHTTHHT rot: TTHHTHHH flip: 0 2 4 6 => HHHTHHTT\n",
+ " 67: HHHTHHTT rot: HHTHHTTH flip: 01234567 => HHTTTHTT\n",
+ " 68: HHTTTHTT rot: THTTHHTT flip: 01 45 => HTTTTTTT\n",
+ " 69: HTTTTTTT rot: TTTTTTHT flip: 01234567 => HHHHHHHT\n",
+ " 70: HHHHHHHT rot: HHHTHHHH flip: 0 2 4 6 => HTHTHTTT\n",
+ " 71: HTHTHTTT rot: TTHTHTHT flip: 01234567 => HHHTHTHT\n",
+ " 72: HHHTHTHT rot: HTHHHTHT flip: 012 456 => HTHTHTTT\n",
+ " 73: HTHTHTTT rot: TTHTHTHT flip: 01234567 => HHHTHTHT\n",
+ " 74: HHHTHTHT rot: HTHTHTHH flip: 0 2 4 6 => HTTTTTTT\n",
+ " 75: HTTTTTTT rot: TTTTHTTT flip: 01234567 => HHHHHHHT\n",
+ " 76: HHHHHHHT rot: HHTHHHHH flip: 01 45 => HHTTTHTT\n",
+ " 77: HHTTTHTT rot: HTTTHTTH flip: 01234567 => HHHTHHTT\n",
+ " 78: HHHTHHTT rot: HHTTHHHT flip: 0 2 4 6 => HHTTHTTT\n",
+ " 79: HHTTHTTT rot: HHTTHTTT flip: 01234567 => HHHTTHHT\n",
+ " 80: HHHTTHHT rot: HTHHHTTH flip: 0123 => HTHTTHTT\n",
+ " 81: HTHTTHTT rot: THTTHTTH flip: 01234567 => HHTHHTHT\n",
+ " 82: HHTHHTHT rot: HHTHHTHT flip: 0 2 4 6 => HHHTTTTT\n",
+ " 83: HHHTTTTT rot: TTHHHTTT flip: 01234567 => HHHHHTTT\n",
+ " 84: HHHHHTTT rot: TTHHHHHT flip: 01 45 => HHHHTTHT\n",
+ " 85: HHHHTTHT rot: HTTHTHHH flip: 01234567 => HHTHTTTT\n",
+ " 86: HHTHTTTT rot: HTTTTHHT flip: 0 2 4 6 => HHTTTTHT\n",
+ " 87: HHTTTTHT rot: TTTTHTHH flip: 01234567 => HHHHTHTT\n",
+ " 88: HHHHTHTT rot: THHHHTHT flip: 012 456 => HTHTTHTT\n",
+ " 89: HTHTTHTT rot: THTTHTTH flip: 01234567 => HHTHHTHT\n",
+ " 90: HHTHHTHT rot: THTHHTHH flip: 0 2 4 6 => HHHHHTTT\n",
+ " 91: HHHHHTTT rot: TTTHHHHH flip: 01234567 => HHHTTTTT\n",
+ " 92: HHHTTTTT rot: HHHTTTTT flip: 01 45 => HHTTTTHT\n",
+ " 93: HHTTTTHT rot: TTHTHHTT flip: 01234567 => HHHHTHTT\n",
+ " 94: HHHHTHTT rot: HHTHTTHH flip: 0 2 4 6 => HHHHTTHT\n",
+ " 95: HHHHTTHT rot: TTHTHHHH flip: 01234567 => HHTHTTTT\n",
+ " 96: HHTHTTTT rot: TTHHTHTT flip: 01234 6 => HHHTHHTT\n",
+ " 97: HHHTHHTT rot: TTHHHTHH flip: 01234567 => HHTTTHTT\n",
+ " 98: HHTTTHTT rot: TTHTTHHT flip: 0 2 4 6 => HHTTHTTT\n",
+ " 99: HHTTHTTT rot: THTTTHHT flip: 01234567 => HHHTTHHT\n",
+ " 100: HHHTTHHT rot: THHTHHHT flip: 01 45 => HTHTHTTT\n",
+ " 101: HTHTHTTT rot: THTHTTTH flip: 01234567 => HHHTHTHT\n",
+ " 102: HHHTHTHT rot: HTHTHTHH flip: 0 2 4 6 => HTTTTTTT\n",
+ " 103: HTTTTTTT rot: TTTTTHTT flip: 01234567 => HHHHHHHT\n",
+ " 104: HHHHHHHT rot: HHHHHHHT flip: 012 456 => HTTTTTTT\n",
+ " 105: HTTTTTTT rot: TTTHTTTT flip: 01234567 => HHHHHHHT\n",
+ " 106: HHHHHHHT rot: HHHHHHHT flip: 0 2 4 6 => HTHTHTTT\n",
+ " 107: HTHTHTTT rot: THTHTHTT flip: 01234567 => HHHTHTHT\n",
+ " 108: HHHTHTHT rot: HTHTHTHH flip: 01 45 => HHHTHHTT\n",
+ " 109: HHHTHHTT rot: TTHHHTHH flip: 01234567 => HHTTTHTT\n",
+ " 110: HHTTTHTT rot: HTTTHTTH flip: 0 2 4 6 => HHTTHTTT\n",
+ " 111: HHTTHTTT rot: TTTHHTTH flip: 01234567 => HHHTTHHT\n",
+ " 112: HHHTTHHT rot: HHHTTHHT flip: 0123 => HHTTTTHT\n",
+ " 113: HHTTTTHT rot: TTHTHHTT flip: 01234567 => HHHHTHTT\n",
+ " 114: HHHHTHTT rot: HHTHTTHH flip: 0 2 4 6 => HHHHTTHT\n",
+ " 115: HHHHTTHT rot: HHHHTTHT flip: 01234567 => HHTHTTTT\n",
+ " 116: HHTHTTTT rot: HTTTTHHT flip: 01 45 => HTHTTHTT\n",
+ " 117: HTHTTHTT rot: THTHTTHT flip: 01234567 => HHTHHTHT\n",
+ " 118: HHTHHTHT rot: HHTHHTHT flip: 0 2 4 6 => HHHTTTTT\n",
+ " 119: HHHTTTTT rot: HHTTTTTH flip: 01234567 => HHHHHTTT\n",
+ " 120: HHHHHTTT rot: TTTHHHHH flip: 012 456 => HHHHHTTT\n",
+ " 121: HHHHHTTT rot: HTTTHHHH flip: 01234567 => HHHTTTTT\n",
+ " 122: HHHTTTTT rot: HHHTTTTT flip: 0 2 4 6 => HTHTTHTT\n",
+ " 123: HTHTTHTT rot: THTTHTHT flip: 01234567 => HHTHHTHT\n",
+ " 124: HHTHHTHT rot: THHTHHTH flip: 01 45 => HHTHTTTT\n",
+ " 125: HHTHTTTT rot: HHTHTTTT flip: 01234567 => HHHHTTHT\n",
+ " 126: HHHHTTHT rot: THHHHTTH flip: 0 2 4 6 => HHHHTHTT\n",
+ " 127: HHHHTHTT rot: THHHHTHT flip: 01234567 => HHTTTTHT\n",
+ " 128: HHTTTTHT rot: HTTTTHTH flip: 0123456 => HHHHTHHT\n",
+ " 129: HHHHTHHT rot: THHTHHHH flip: 01234567 => HTTHTTTT\n",
+ " 130: HTTHTTTT rot: TTHTTTTH flip: 0 2 4 6 => HHHTTTHT\n",
+ " 131: HHHTTTHT rot: THHHTTTH flip: 01234567 => HHHTHTTT\n",
+ " 132: HHHTHTTT rot: THHHTHTT flip: 01 45 => HHHTTTHT\n",
+ " 133: HHHTTTHT rot: TTTHTHHH flip: 01234567 => HHHTHTTT\n",
+ " 134: HHHTHTTT rot: HTTTHHHT flip: 0 2 4 6 => HTTHTTTT\n",
+ " 135: HTTHTTTT rot: TTTTHTTH flip: 01234567 => HHHHTHHT\n",
+ " 136: HHHHTHHT rot: HHHTHHTH flip: 012 456 => HHTTTTTT\n",
+ " 137: HHTTTTTT rot: TTHHTTTT flip: 01234567 => HHHHHHTT\n",
+ " 138: HHHHHHTT rot: HHTTHHHH flip: 0 2 4 6 => HHTTHTHT\n",
+ " 139: HHTTHTHT rot: HTHTHHTT flip: 01234567 => HHTHTHTT\n",
+ " 140: HHTHTHTT rot: THTTHHTH flip: 01 45 => HHTTTTTT\n",
+ " 141: HHTTTTTT rot: TTTHHTTT flip: 01234567 => HHHHHHTT\n",
+ " 142: HHHHHHTT rot: TTHHHHHH flip: 0 2 4 6 => HHTTHTHT\n",
+ " 143: HHTTHTHT rot: TTHTHTHH flip: 01234567 => HHTHTHTT\n",
+ " 144: HHTHTHTT rot: HTTHHTHT flip: 0123 => HHTHTHTT\n",
+ " 145: HHTHTHTT rot: TTHHTHTH flip: 01234567 => HHTTHTHT\n",
+ " 146: HHTTHTHT rot: HHTTHTHT flip: 0 2 4 6 => HHTTTTTT\n",
+ " 147: HHTTTTTT rot: TTHHTTTT flip: 01234567 => HHHHHHTT\n",
+ " 148: HHHHHHTT rot: HHHHHHTT flip: 01 45 => HHTTTTTT\n",
+ " 149: HHTTTTTT rot: TTTTHHTT flip: 01234567 => HHHHHHTT\n",
+ " 150: HHHHHHTT rot: HHHHTTHH flip: 0 2 4 6 => HHTTHTHT\n",
+ " 151: HHTTHTHT rot: THTHHTTH flip: 01234567 => HHTHTHTT\n",
+ " 152: HHTHTHTT rot: HHTHTHTT flip: 012 456 => HHHTHTTT\n",
+ " 153: HHHTHTTT rot: THTTTHHH flip: 01234567 => HHHTTTHT\n",
+ " 154: HHHTTTHT rot: HHTTTHTH flip: 0 2 4 6 => HHHHTHHT\n",
+ " 155: HHHHTHHT rot: THHTHHHH flip: 01234567 => HTTHTTTT\n",
+ " 156: HTTHTTTT rot: TTHTTTTH flip: 01 45 => HHHHTHHT\n",
+ " 157: HHHHTHHT rot: HHTHHHHT flip: 01234567 => HTTHTTTT\n",
+ " 158: HTTHTTTT rot: TTTHTTHT flip: 0 2 4 6 => HHHTTTHT\n",
+ " 159: HHHTTTHT rot: HHHTTTHT flip: 01234567 => HHHTHTTT\n",
+ " 160: HHHTHTTT rot: TTHHHTHT flip: 01234 6 => HHTTTTTT\n",
+ " 161: HHTTTTTT rot: TTHHTTTT flip: 01234567 => HHHHHHTT\n",
+ " 162: HHHHHHTT rot: HHHHHTTH flip: 0 2 4 6 => HHTHTHTT\n",
+ " 163: HHTHTHTT rot: THTTHHTH flip: 01234567 => HHTTHTHT\n",
+ " 164: HHTTHTHT rot: TTHTHTHH flip: 01 45 => HHHHHHTT\n",
+ " 165: HHHHHHTT rot: HHTTHHHH flip: 01234567 => HHTTTTTT\n",
+ " 166: HHTTTTTT rot: HHTTTTTT flip: 0 2 4 6 => HHTHTHTT\n",
+ " 167: HHTHTHTT rot: THTHTTHH flip: 01234567 => HHTTHTHT\n",
+ " 168: HHTTHTHT rot: HTHHTTHT flip: 012 456 => HHHTTTHT\n",
+ " 169: HHHTTTHT rot: TTTHTHHH flip: 01234567 => HHHTHTTT\n",
+ " 170: HHHTHTTT rot: TTHHHTHT flip: 0 2 4 6 => HTTHTTTT\n",
+ " 171: HTTHTTTT rot: TTTTHTTH flip: 01234567 => HHHHTHHT\n",
+ " 172: HHHHTHHT rot: HTHHTHHH flip: 01 45 => HHHHTHHT\n",
" 173: HHHHTHHT rot: THHTHHHH flip: 01234567 => HTTHTTTT\n",
- " 174: HTTHTTTT rot: THTTHTTT flip: 0 2 4 6 => HHHTTTHT\n",
- " 175: HHHTTTHT rot: HHHTTTHT flip: 01234567 => TTTHHHTH\n",
- " 176: TTTHHHTH rot: HTHTTTHH flip: 0123 => THTHTTHH\n",
- " 177: THTHTTHH rot: HTTHHTHT flip: 01234567 => THHTTHTH\n",
- " 178: THHTTHTH rot: THHTTHTH flip: 0 2 4 6 => HHTTHHHH\n",
- " 179: HHTTHHHH rot: HHTTHHHH flip: 01234567 => TTHHTTTT\n",
- " 180: TTHHTTTT rot: HHTTTTTT flip: 01 45 => TTTTHHTT\n",
- " 181: TTTTHHTT rot: TTHHTTTT flip: 01234567 => HHTTHHHH\n",
- " 182: HHTTHHHH rot: THHHHHHT flip: 0 2 4 6 => HHTHTHTT\n",
- " 183: HHTHTHTT rot: HTTHHTHT flip: 01234567 => THHTTHTH\n",
- " 184: THHTTHTH rot: HHTTHTHT flip: 012 456 => TTHTTHTT\n",
- " 185: TTHTTHTT rot: TTTTHTTH flip: 01234567 => HHHHTHHT\n",
- " 186: HHHHTHHT rot: HTHHTHHH flip: 0 2 4 6 => TTTHHHTH\n",
- " 187: TTTHHHTH rot: TTTHHHTH flip: 01234567 => HHHTTTHT\n",
- " 188: HHHTTTHT rot: THHHTTTH flip: 01 45 => HTHHHHTH\n",
- " 189: HTHHHHTH rot: HTHHHHTH flip: 01234567 => THTTTTHT\n",
- " 190: THTTTTHT rot: HTTHTTTT flip: 0 2 4 6 => TTHHHTHT\n",
- " 191: TTHHHTHT rot: TTTHHHTH flip: 01234567 => HHHTTTHT\n",
- " 192: HHHTTTHT rot: THHHTTTH flip: 012345 => HTTTHHTH\n",
- " 193: HTTTHHTH rot: THHTTTHH flip: 01234567 => HTTHHHTT\n",
- " 194: HTTHHHTT rot: HHTTHTTH flip: 0 2 4 6 => THHTTTHH\n",
- " 195: THHTTTHH rot: THHTTTHH flip: 01234567 => HTTHHHTT\n",
- " 196: HTTHHHTT rot: THTTHHHT flip: 01 45 => HTTTTTHT\n",
- " 197: HTTTTTHT rot: TTTHTHTT flip: 01234567 => HHHTHTHH\n",
- " 198: HHHTHTHH rot: THHHHHTH flip: 0 2 4 6 => HHTHTHHH\n",
- " 199: HHTHTHHH rot: HHTHTHHH flip: 01234567 => TTHTHTTT\n",
- " 200: TTHTHTTT rot: TTTTTHTH flip: 012 456 => HHHTHTHH\n",
- " 201: HHHTHTHH rot: HHTHTHHH flip: 01234567 => TTHTHTTT\n",
- " 202: TTHTHTTT rot: HTTTTTHT flip: 0 2 4 6 => TTHTHTTT\n",
- " 203: TTHTHTTT rot: TTTTHTHT flip: 01234567 => HHHHTHTH\n",
- " 204: HHHHTHTH rot: HHHTHTHH flip: 01 45 => TTHTTHHH\n",
- " 205: TTHTTHHH rot: TTHTTHHH flip: 01234567 => HHTHHTTT\n",
- " 206: HHTHHTTT rot: TTHHTHHT flip: 0 2 4 6 => HTTHHHTT\n",
- " 207: HTTHHHTT rot: HHTTHTTH flip: 01234567 => TTHHTHHT\n",
- " 208: TTHHTHHT rot: THHTHHTT flip: 0123 => HTTHHHTT\n",
- " 209: HTTHHHTT rot: HTTHTTHH flip: 01234567 => THHTHHTT\n",
- " 210: THHTHHTT rot: TTTHHTHH flip: 0 2 4 6 => HTHHTTTH\n",
- " 211: HTHHTTTH rot: HTTTHHTH flip: 01234567 => THHHTTHT\n",
- " 212: THHHTTHT rot: HTTHTTHH flip: 01 45 => THTHHHHH\n",
- " 213: THTHHHHH rot: HHTHTHHH flip: 01234567 => TTHTHTTT\n",
- " 214: TTHTHTTT rot: THTHTTTT flip: 0 2 4 6 => HHHHHTHT\n",
- " 215: HHHHHTHT rot: HHHTHTHH flip: 01234567 => TTTHTHTT\n",
- " 216: TTTHTHTT rot: TTTHTHTT flip: 012 456 => HHHHHTHT\n",
- " 217: HHHHHTHT rot: HHHHTHTH flip: 01234567 => TTTTHTHT\n",
- " 218: TTTTHTHT rot: TTTTHTHT flip: 0 2 4 6 => HTHTTTTT\n",
- " 219: HTHTTTTT rot: TTTHTHTT flip: 01234567 => HHHTHTHH\n",
- " 220: HHHTHTHH rot: HHTHTHHH flip: 01 45 => TTTHHTHH\n",
- " 221: TTTHHTHH rot: TTTHHTHH flip: 01234567 => HHHTTHTT\n",
- " 222: HHHTTHTT rot: HTTHTTHH flip: 0 2 4 6 => TTHHHTTH\n",
- " 223: TTHHHTTH rot: HTTHTTHH flip: 01234567 => THHTHHTT\n",
- " 224: THHTHHTT rot: TTHHTHHT flip: 01234 6 => HHTTHHTT\n",
- " 225: HHTTHHTT rot: THHTTHHT flip: 01234567 => HTTHHTTH\n",
- " 226: HTTHHTTH rot: HHTTHHTT flip: 0 2 4 6 => THHTTHHT\n",
- " 227: THHTTHHT rot: HTTHHTTH flip: 01234567 => THHTTHHT\n",
- " 228: THHTTHHT rot: HTTHHTTH flip: 01 45 => THTHTHTH\n",
- " 229: THTHTHTH rot: THTHTHTH flip: 01234567 => HTHTHTHT\n",
- " 230: HTHTHTHT rot: THTHTHTH flip: 0 2 4 6 => HHHHHHHH\n"
+ " 174: HTTHTTTT rot: TTHTTHTT flip: 0 2 4 6 => HHHTHTTT\n",
+ " 175: HHHTHTTT rot: THTTTHHH flip: 01234567 => HHHTTTHT\n",
+ " 176: HHHTTTHT rot: HHHTTTHT flip: 0123 => HTTHTTTT\n",
+ " 177: HTTHTTTT rot: TTHTTTTH flip: 01234567 => HHHHTHHT\n",
+ " 178: HHHHTHHT rot: HHTHHTHH flip: 0 2 4 6 => HHHTTTHT\n",
+ " 179: HHHTTTHT rot: HHHTTTHT flip: 01234567 => HHHTHTTT\n",
+ " 180: HHHTHTTT rot: TTTHHHTH flip: 01 45 => HHHTHTTT\n",
+ " 181: HHHTHTTT rot: HTTTHHHT flip: 01234567 => HHHTTTHT\n",
+ " 182: HHHTTTHT rot: HHTTTHTH flip: 0 2 4 6 => HHHHTHHT\n",
+ " 183: HHHHTHHT rot: THHHHTHH flip: 01234567 => HTTHTTTT\n",
+ " 184: HTTHTTTT rot: HTTTTHTT flip: 012 456 => HHTHTHTT\n",
+ " 185: HHTHTHTT rot: THHTHTHT flip: 01234567 => HHTTHTHT\n",
+ " 186: HHTTHTHT rot: HTTHTHTH flip: 0 2 4 6 => HHHHHHTT\n",
+ " 187: HHHHHHTT rot: TTHHHHHH flip: 01234567 => HHTTTTTT\n",
+ " 188: HHTTTTTT rot: TTTTTTHH flip: 01 45 => HHHHHHTT\n",
+ " 189: HHHHHHTT rot: HHHHHTTH flip: 01234567 => HHTTTTTT\n",
+ " 190: HHTTTTTT rot: HHTTTTTT flip: 0 2 4 6 => HHTHTHTT\n",
+ " 191: HHTHTHTT rot: HTHTTHHT flip: 01234567 => HHTTHTHT\n",
+ " 192: HHTTHTHT rot: HTHTHHTT flip: 012345 => HTHTTTTT\n",
+ " 193: HTHTTTTT rot: HTHTTTTT flip: 01234567 => HHHHHTHT\n",
+ " 194: HHHHHTHT rot: THHHHHTH flip: 0 2 4 6 => HHHHHTHT\n",
+ " 195: HHHHHTHT rot: HTHTHHHH flip: 01234567 => HTHTTTTT\n",
+ " 196: HTHTTTTT rot: TTTTHTHT flip: 01 45 => HHTHHTTT\n",
+ " 197: HHTHHTTT rot: HTHHTTTH flip: 01234567 => HHHTTHTT\n",
+ " 198: HHHTTHTT rot: HTTHHHTT flip: 0 2 4 6 => HHTHHTTT\n",
+ " 199: HHTHHTTT rot: THHTHHTT flip: 01234567 => HHHTTHTT\n",
+ " 200: HHHTTHTT rot: HTTHHHTT flip: 012 456 => HHHTTHTT\n",
+ " 201: HHHTTHTT rot: HHHTTHTT flip: 01234567 => HHTHHTTT\n",
+ " 202: HHTHHTTT rot: HTHHTTTH flip: 0 2 4 6 => HHTHHTTT\n",
+ " 203: HHTHHTTT rot: TTTHHTHH flip: 01234567 => HHHTTHTT\n",
+ " 204: HHHTTHTT rot: TTHTTHHH flip: 01 45 => HHHHHTHT\n",
+ " 205: HHHHHTHT rot: HHHHHTHT flip: 01234567 => HTHTTTTT\n",
+ " 206: HTHTTTTT rot: TTHTHTTT flip: 0 2 4 6 => HTHTTTTT\n",
+ " 207: HTHTTTTT rot: TTTHTHTT flip: 01234567 => HHHHHTHT\n",
+ " 208: HHHHHTHT rot: THHHHHTH flip: 0123 => HHTHHTTT\n",
+ " 209: HHTHHTTT rot: HTTTHHTH flip: 01234567 => HHHTTHTT\n",
+ " 210: HHHTTHTT rot: TTHHHTTH flip: 0 2 4 6 => HHHTTHTT\n",
+ " 211: HHHTTHTT rot: HTTHHHTT flip: 01234567 => HHTHHTTT\n",
+ " 212: HHTHHTTT rot: TTTHHTHH flip: 01 45 => HHHHHTHT\n",
+ " 213: HHHHHTHT rot: HHHHHTHT flip: 01234567 => HTHTTTTT\n",
+ " 214: HTHTTTTT rot: THTHTTTT flip: 0 2 4 6 => HHHHHTHT\n",
+ " 215: HHHHHTHT rot: THTHHHHH flip: 01234567 => HTHTTTTT\n",
+ " 216: HTHTTTTT rot: HTTTTTHT flip: 012 456 => HHTHHTTT\n",
+ " 217: HHTHHTTT rot: THHTTTHH flip: 01234567 => HHHTTHTT\n",
+ " 218: HHHTTHTT rot: THTTHHHT flip: 0 2 4 6 => HHHTTHTT\n",
+ " 219: HHHTTHTT rot: TTHTTHHH flip: 01234567 => HHTHHTTT\n",
+ " 220: HHTHHTTT rot: THHTHHTT flip: 01 45 => HTHTTTTT\n",
+ " 221: HTHTTTTT rot: TTHTHTTT flip: 01234567 => HHHHHTHT\n",
+ " 222: HHHHHTHT rot: HHHTHTHH flip: 0 2 4 6 => HTHTTTTT\n",
+ " 223: HTHTTTTT rot: TTTTHTHT flip: 01234567 => HHHHHTHT\n",
+ " 224: HHHHHTHT rot: THTHHHHH flip: 01234 6 => HHTHTTHT\n",
+ " 225: HHTHTTHT rot: HTHTTHTH flip: 01234567 => HHTHTTHT\n",
+ " 226: HHTHTTHT rot: HTTHTHHT flip: 0 2 4 6 => HHHHTTTT\n",
+ " 227: HHHHTTTT rot: HHTTTTHH flip: 01234567 => HHHHTTTT\n",
+ " 228: HHHHTTTT rot: TTHHHHTT flip: 01 45 => HHHHTTTT\n",
+ " 229: HHHHTTTT rot: TTHHHHTT flip: 01234567 => HHHHTTTT\n",
+ " 230: HHHHTTTT rot: TTHHHHTT flip: 0 2 4 6 => HHTHTTHT\n",
+ " 231: HHTHTTHT rot: HHTHTTHT flip: 01234567 => HHTHTTHT\n",
+ " 232: HHTHTTHT rot: HHTHTTHT flip: 012 456 => HHHHTTTT\n",
+ " 233: HHHHTTTT rot: TTHHHHTT flip: 01234567 => HHHHTTTT\n",
+ " 234: HHHHTTTT rot: TTHHHHTT flip: 0 2 4 6 => HHTHTTHT\n",
+ " 235: HHTHTTHT rot: TTHTHHTH flip: 01234567 => HHTHTTHT\n",
+ " 236: HHTHTTHT rot: THTHHTHT flip: 01 45 => HHTHTTHT\n",
+ " 237: HHTHTTHT rot: THTHHTHT flip: 01234567 => HHTHTTHT\n",
+ " 238: HHTHTTHT rot: TTHTHHTH flip: 0 2 4 6 => HHHHTTTT\n",
+ " 239: HHHHTTTT rot: TTTHHHHT flip: 01234567 => HHHHTTTT\n",
+ " 240: HHHHTTTT rot: TTTHHHHT flip: 0123 => HHHTHHHT\n",
+ " 241: HHHTHHHT rot: HHHTHHHT flip: 01234567 => HTTTHTTT\n",
+ " 242: HTTTHTTT rot: TTHTTTHT flip: 0 2 4 6 => HTTTHTTT\n",
+ " 243: HTTTHTTT rot: HTTTHTTT flip: 01234567 => HHHTHHHT\n",
+ " 244: HHHTHHHT rot: HHTHHHTH flip: 01 45 => HTTTHTTT\n",
+ " 245: HTTTHTTT rot: TTHTTTHT flip: 01234567 => HHHTHHHT\n",
+ " 246: HHHTHHHT rot: HHHTHHHT flip: 0 2 4 6 => HTTTHTTT\n",
+ " 247: HTTTHTTT rot: THTTTHTT flip: 01234567 => HHHTHHHT\n",
+ " 248: HHHTHHHT rot: HHTHHHTH flip: 012 456 => HHTTHHTT\n",
+ " 249: HHTTHHTT rot: HHTTHHTT flip: 01234567 => HHTTHHTT\n",
+ " 250: HHTTHHTT rot: HHTTHHTT flip: 0 2 4 6 => HHTTHHTT\n",
+ " 251: HHTTHHTT rot: HHTTHHTT flip: 01234567 => HHTTHHTT\n",
+ " 252: HHTTHHTT rot: THHTTHHT flip: 01 45 => HTHTHTHT\n",
+ " 253: HTHTHTHT rot: HTHTHTHT flip: 01234567 => HTHTHTHT\n",
+ " 254: HTHTHTHT rot: HTHTHTHT flip: 0 2 4 6 => TTTTTTTT\n",
+ " 255: TTTTTTTT rot: TTTTTTTT flip: 01234567 => HHHHHHHH\n"
]
},
{
@@ -1152,7 +1201,7 @@
"'HHHHHHHH'"
]
},
- "execution_count": 25,
+ "execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}