Furthermore, mirroring of the board along the vertical and horizontal axis can also be done comparably fast. The only tradeoff is that rotations of a position cannot be computed easily. One solution for this problem could be, to always maintain two bit-boards: one for the original position and one for a rotated position by 90 degrees. For example, the remaining number of pegs can be computed with an efficient function that counts the number of set bits in a bit-field.
Since we are normally interested to count the remaining pegs after no move is possible any more, there are typically not too many pegs left and the following function computes the number very fast:.
If only three bits are set in a bit-field, above function would only require 3 iterations in order to count the set bits. Even more important is the method to compute all the possible moves for a given board position b. All possible moves in one direction in total 4 directions can simply be computed with:.
The variable mv contains all the target holes for the allowed moves in the specified direction. After all the possible moves in mv for a direction dir are known, each move can also be performed with a few bitwise operations. We can extract the next move, which should be performed with:. Undoing a move can be done accordingly.
All of these steps require only a few bitwise operations. A solver with an array-based data structure for the board would likely perform the moves slightly faster, but I suppose that the move generation itself which is commonly an expensive task is done much faster with this bit-board design.
It is as simple as that to find all possible moves in one direction. However, I added a few lines of code which allow a better move ordering, which is essential for finding a solution faster.
With a standard move ordering the search might take many days. Hence, it might be reasonable to spend some CPU time on sorting the moves a little, in order to try more promising moves first. For example, the move ordering defers moves which end up in the corners of the board, since it is typically not that easy to get out of the corner again. Also some other types of moves are ordered to the back of the list, if they do not appear promising.
When traversing the search tree many positions repeat since permutations of a move sequence can lead to identical positions. Furthermore, the Diamond board is symmetric, having mirror and rotation symmetries. The value of a position is the minimum number of remaining stones of the final state when an optimal move sequence is performed — starting from this particular position. For example if we know that position has a corresponding value of , then a position , which is identical to after rotation, will also have a value of.
If we had a possibility to store the already known values of positions, then we could save some computation time when we observe a symmetrically equivalent position again, by simply retrieving the stored value and returning it. With such an approach, we could prune the search tree significantly and avoid redundant calculations without loosing any information.
A common technique used for board games such as chess, checkers, etc. The idea is to define a suitable hash function which takes the board position and no historic information of the move sequence which led to this position and returns a hash value that can be mapped to an index in order to store the game-theoretic value of a position in a hash table.
When we observe a new position we can then simply calculate the corresponding hash and check if there is an entry in the hash table. If we find an entry, we are lucky and can stop the search for the current position and cut off the connected sub-tree. If not, then we have to traverse the connected sub tree and then store the retrieved value afterwards in the table.
For our problem, an entry in the table could look like this:. Since we are not performing an Alpha-Beta search or similar, there is no need to store further information rather than a key and a value.
Note that we also have to store a key, which in this case is simply the position itself, since many board positions will map to the same hash table index. This is due to the fact that the hash function itself is typically not injective as well as the modulo operation required to break down the hash value to an index.
Since it is not possible to prevent collisions it is always necessary to compare the key of the stored element with the current board position. From this problem another question arises: What do we do, if we want to store a key-value pair in the transposition table, but the corresponding slot is already occupied by another position?
The answer for our case is simple: We simply overwrite the older entry in the table. This approach is often sub-optimal, since we might destroy valuable information especially the values of positions located close to the root node were expensive to compute and could be replaced by those of positions which are very close to a leaf node of the tree , but in our case it still worked decently. Commonly, the size of the hash table is chosen to be a power of two, since the modulo operation to map a hash value to an table index turns out to be simply a bitwise AND:.
One last detail has to be mentioned: How do we define the hash function? Typically, for many board games the so called Zobrist keys are used. Create an account. Edit this Article. We use cookies to make wikiHow great. By using our site, you agree to our cookie policy. Cookie Settings. Learn why people trust wikiHow. Download Article Explore this Article parts.
Tips and Warnings. Related Articles. Article Summary. Part 1. Learn the rules. Like checkers, the point of the game is to jump pegs and remove them from the game. The rules are simple: [1] X Research source To jump a peg, it must have an empty space next to it. You can use any peg as a jumper, as long as the peg you jump is directly adjacent to it and has an open space next to it. Every peg you jump must be removed.
You win when there is only one peg left. Understand the board. Each space on the board has a number from 1 to The top point of the triangle is position 1, and the bottom right is position Learn the theory behind the puzzle. This isn't all necessary to win the game, but there are some highlights to keep in mind that will help you solve the puzzle. That means that after just two bad moves, the puzzle becomes impossible to solve.
Make your moves count! Plan your moves carefully. All those solutions, however, are just modifications of two main solution patterns. Part 2. Begin the game. Start with position 1 empty. This would be the top point of the triangle. There are other methods of solving the puzzle, but this one is the most common and easiest.
Make the diamond shape. This basic pattern can be repeated throughout the board, helping you win the game. It will then be in position 1. Use the peg in position 6 to jump position 5. It will now be in position 4. Use the peg in position 1 to jump position 3. It will now be in position 6.
These moves will give you the diamond base. Make two groups of pegs. As you'll see, the next set of moves will divide the pegs into two groups, one on each side of the triangle. Move the peg in position 7 to position 2, jumping position 4. Move peg 13 to position 4. Next, move peg 10 to position 8. You should now have two groups of pegs, with 5 pegs on the left side and 3 on the right. Separate the triangle in two.
This next set of steps will make a curved line across the triangle, dividing it into two parts. Move peg 2 to position 7. Then take that same peg and move it to position 9. Next, move peg 15 to position Move your last pegs to the bottom row. These moves will leave you with three final pegs, all in the bottom row. Move peg 12 into position Next move peg 6 to position You should now just have three pegs left in the bottom row.
He or she may remove a 6 peg, or a 1 and 5 pegs, or a 1, 2, and 3 pegs. The player keeps rolling until until he rolls a number which cannot be taken off, or all the pegs are gone. Any number may play. We note that the peg solitaire board has 33 holes. Each hole can either be empty or it can contain a peg. Most of these combinations can not occur in a standard game. Klondike Solitaire — Winning Strategy Turn up the first card off the deck before making any other moves.
Always move an Ace or Deuce to the foundation whenever it is possible. Expose hidden cards. Hold off the moves that are not important. Do not empty a tableau pile if you do not have a King to put it in. For your first move, draw a card from the deck to give yourself more options.
Play aces and twos right away. If there are options, move cards from the column with the most face-down cards.
0コメント