Programmer Puzzle: Encoding a chess board state throughout a game

前端 未结 30 1531
闹比i
闹比i 2021-01-29 17:16

Not strictly a question, more of a puzzle...

Over the years, I\'ve been involved in a few technical interviews of new employees. Other than asking the standard \"do you

相关标签:
30条回答
  • 2021-01-29 17:37

    Update: I liked this topic so much I wrote Programming Puzzles, Chess Positions and Huffman Coding. If you read through this I've determined that the only way to store a complete game state is by storing a complete list of moves. Read on for why. So I use a slightly simplified version of the problem for piece layout.

    The Problem

    This image illustrates the starting Chess position. Chess occurs on an 8x8 board with each player starting with an identical set of 16 pieces consisting of 8 pawns, 2 rooks, 2 knights, 2 bishops, 1 queen and 1 king as illustrated here:

    Positions are generally recorded as a letter for the column followed by the number for the row so White’s queen is at d1. Moves are most often stored in algebraic notation, which is unambiguous and generally only specifies the minimal information necessary. Consider this opening:

    1. e4 e5
    2. Nf3 Nc6

    which translates to:

    1. White moves king’s pawn from e2 to e4 (it is the only piece that can get to e4 hence “e4”);
    2. Black moves the king’s pawn from e7 to e5;
    3. White moves the knight (N) to f3;
    4. Black moves the knight to c6.

    The board looks like this:

    An important ability for any programmer is to be able to correctly and unambiguously specify the problem.

    So what’s missing or ambiguous? A lot as it turns out.

    Board State vs Game State

    The first thing you need to determine is whether you’re storing the state of a game or the position of pieces on the board. Encoding simply the positions of the pieces is one thing but the problem says “all subsequent legal moves”. The problem also says nothing about knowing the moves up to this point. That’s actually a problem as I’ll explain.

    Castling

    The game has proceeded as follows:

    1. e4 e5
    2. Nf3 Nc6
    3. Bb5 a6
    4. Ba4 Bc5

    The board looks as follows:

    later opening

    White has the option of castling. Part of the requirements for this are that the king and the relevant rook can never have moved, so whether the king or either rook of each side has moved will need to be stored. Obviously if they aren’t on their starting positions, they have moved otherwise it needs to be specified.

    There are several strategies that can be used for dealing with this problem.

    Firstly, we could store an extra 6 bits of information (1 for each rook and king) to indicate whether that piece had moved. We could streamline this by only storing a bit for one of these six squares if the right piece happens to be in it. Alternatively we could treat each unmoved piece as another piece type so instead of 6 piece types on each side (pawn, rook, knight, bishop, queen and king) there are 8 (adding unmoved rook and unmoved king).

    En Passant

    Another peculiar and often-neglected rule in Chess is En Passant.

    The game has progressed.

    1. e4 e5
    2. Nf3 Nc6
    3. Bb5 a6
    4. Ba4 Bc5
    5. O-O b5
    6. Bb3 b4
    7. c4

    Black’s pawn on b4 now has the option of moving his pawn on b4 to c3 taking the White pawn on c4. This only happens on the first opportunity meaning if Black passes on the option now he can’t take it next move. So we need to store this.

    If we know the previous move we can definitely answer if En Passant is possible. Alternatively we can store whether each pawn on its 4th rank has just moved there with a double move forward. Or we can look at each possible En Passant position on the board and have a flag to indicate whether its possible or not.

    Promotion

    It is White’s move. If White moves his pawn on h7 to h8 it can be promoted to any other piece (but not the king). 99% of the time it is promoted to a Queen but sometimes it isn’t, typically because that may force a stalemate when otherwise you’d win. This is written as:

    1. h8=Q

    This is important in our problem because it means we can’t count on there being a fixed number of pieces on each side. It is entirely possible (but incredibly unlikely) for one side to end up with 9 queens, 10 rooks, 10 bishops or 10 knights if all 8 pawns get promoted.

    Stalemate

    When in a position from which you cannot win your best tactic is to try for a stalemate. The most likely variant is where you cannot make a legal move (usually because any move when put your king in check). In this case you can claim a draw. This one is easy to cater for.

    The second variant is by threefold repetition. If the same board position occurs three times in a game (or will occur a third time on the next move), a draw can be claimed. The positions need not occur in any particular order (meaning it doesn’t have to the same sequence of moves repeated three times). This one greatly complicates the problem because you have to remember every previous board position. If this is a requirement of the problem the only possible solution to the problem is to store every previous move.

    Lastly, there is the fifty move rule. A player can claim a draw if no pawn has moved and no piece has been taken in the previous fifty consecutive moves so we would need to store how many moves since a pawn was moved or a piece taken (the latest of the two. This requires 6 bits (0-63).

    Whose Turn Is It?

    Of course we also need to know whose turn it is and this is a single bit of information.

    Two Problems

    Because of the stalemate case, the only feasible or sensible way to store the game state is to store all the moves that led to this position. I’ll tackle that one problem. The board state problem will be simplified to this: store the current position of all pieces on the board ignoring castling, en passant, stalemate conditions and whose turn it is.

    Piece layout can be broadly handled in one of two ways: by storing the contents of each square or by storing the position of each piece.

    Simple Contents

    There are six piece types (pawn, rook, knight, bishop, queen and king). Each piece can be White or Black so a square may contain one of 12 possible pieces or it may be empty so there are 13 possibilities. 13 can be stored in 4 bits (0-15) So the simplest solution is to store 4 bits for each square times 64 squares or 256 bits of information.

    The advantage of this method is that manipulation is incredibly easy and fast. This could even be extended by adding 3 more possibilities without increasing the storage requirements: a pawn that has moved 2 spaces on the last turn, a king that hasn’t moved and a rook that hasn’t moved, which will cater for a lot of previously mentioned issues.

    But we can do better.

    Base 13 Encoding

    It is often helpful to think of the board position as a very large number. This is often done in computer science. For example, the halting problem treats a computer program (rightly) as a large number.

    The first solution treats the position as a 64 digit base 16 number but as demonstrated there is redundancy in this information (being the 3 unused possibilities per “digit”) so we can reduce the number space to 64 base 13 digits. Of course this can’t be done as efficiently as base 16 can but it will save on storage requirements (and minimizing storage space is our goal).

    In base 10 the number 234 is equivalent to 2 x 102 + 3 x 101 + 4 x 100.

    In base 16 the number 0xA50 is equivalent to 10 x 162 + 5 x 161 + 0 x 160 = 2640 (decimal).

    So we can encode our position as p0 x 1363 + p1 x 1362 + ... + p63 x 130 where pi represents the contents of square i.

    2256 equals approximately 1.16e77. 1364 equals approximately 1.96e71, which requires 237 bits of storage space. That saving of a mere 7.5% comes at a cost of significantly increased manipulation costs.

    Variable Base Encoding

    In legal boards certain pieces can’t appear in certain squares. For example, pawns cannot occur at in the first or eighth ranks, reducing the possibilities for those squares to 11. That reduces the possible boards to 1116 x 1348 = 1.35e70 (approximately), requiring 233 bits of storage space.

    Actually encoding and decoding such values to and from decimal (or binary) is a little more convoluted but it can be done reliably and is left as an exercise to the reader.

    Variable Width Alphabets

    The previous two methods can both be described as fixed-width alphabetic encoding. Each of the 11, 13 or 16 members of the alphabet is substituted for another value. Each “character” is the same width but the efficiency can be improved when you consider that each character is not equally likely.

    morse code

    Consider Morse code (pictured above). Characters in a message are encoded as a sequence of dashes and dots. Those dashes and dots are transferred over radio (typically) with a pause between them to delimit them.

    Notice how the letter E (the most common letter in English) is a single dot, the shortest possible sequence, whereas Z (the least frequent) is two dashes and two beeps.

    Such a scheme can significantly reduce the size of an expected message but comes at the cost of increasing the size of a random character sequence.

    It should be noted that Morse code has another inbuilt feature: dashes are as long as three dots so the above code is created with this in mind to minimize the use of dashes. Since 1s and 0s (our building blocks) don’t have this problem, it’s not a feature we need to replicate.

    Lastly, there are two kinds of rests in Morse code. A short rest (the length of a dot) is used to distinguish between dots and dashes. A longer gap (the length of a dash) is used to delimit characters.

    So how does this apply to our problem?

    Huffman Coding

    There is an algorithm for dealing with variable length codes called Huffman coding. Huffman coding creates a variable length code substitution, typically uses expected frequency of the symbols to assign shorter values to the more common symbols.

    Huffman code tree

    In the above tree, the letter E is encoded as 000 (or left-left-left) and S is 1011. It should be clear that this encoding scheme is unambiguous.

    This is an important distinction from Morse code. Morse code has the character separator so it can do otherwise ambiguous substitution (eg 4 dots can be H or 2 Is) but we only have 1s and 0s so we choose an unambiguous substitution instead.

    Below is a simple implementation:

    private static class Node {
      private final Node left;
      private final Node right;
      private final String label;
      private final int weight;
    
      private Node(String label, int weight) {
        this.left = null;
        this.right = null;
        this.label = label;
        this.weight = weight;
      }
    
      public Node(Node left, Node right) {
        this.left = left;
        this.right = right;
        label = "";
        weight = left.weight + right.weight;
      }
    
      public boolean isLeaf() { return left == null && right == null; }
    
      public Node getLeft() { return left; }
    
      public Node getRight() { return right; }
    
      public String getLabel() { return label; }
    
      public int getWeight() { return weight; }
    }
    

    with static data:

    private final static List<string> COLOURS;
    private final static Map<string, integer> WEIGHTS;
    
    static {
      List<string> list = new ArrayList<string>();
      list.add("White");
      list.add("Black");
      COLOURS = Collections.unmodifiableList(list);
      Map<string, integer> map = new HashMap<string, integer>();
      for (String colour : COLOURS) {
        map.put(colour + " " + "King", 1);
        map.put(colour + " " + "Queen";, 1);
        map.put(colour + " " + "Rook", 2);
        map.put(colour + " " + "Knight", 2);
        map.put(colour + " " + "Bishop";, 2);
        map.put(colour + " " + "Pawn", 8);
      }
      map.put("Empty", 32);
      WEIGHTS = Collections.unmodifiableMap(map);
    }
    

    and:

    private static class WeightComparator implements Comparator<node> {
      @Override
      public int compare(Node o1, Node o2) {
        if (o1.getWeight() == o2.getWeight()) {
          return 0;
        } else {
          return o1.getWeight() < o2.getWeight() ? -1 : 1;
        }
      }
    }
    
    private static class PathComparator implements Comparator<string> {
      @Override
      public int compare(String o1, String o2) {
        if (o1 == null) {
          return o2 == null ? 0 : -1;
        } else if (o2 == null) {
          return 1;
        } else {
          int length1 = o1.length();
          int length2 = o2.length();
          if (length1 == length2) {
            return o1.compareTo(o2);
          } else {
            return length1 < length2 ? -1 : 1;
          }
        }
      }
    }
    
    public static void main(String args[]) {
      PriorityQueue<node> queue = new PriorityQueue<node>(WEIGHTS.size(),
          new WeightComparator());
      for (Map.Entry<string, integer> entry : WEIGHTS.entrySet()) {
        queue.add(new Node(entry.getKey(), entry.getValue()));
      }
      while (queue.size() > 1) {
        Node first = queue.poll();
        Node second = queue.poll();
        queue.add(new Node(first, second));
      }
      Map<string, node> nodes = new TreeMap<string, node>(new PathComparator());
      addLeaves(nodes, queue.peek(), &quot;&quot;);
      for (Map.Entry<string, node> entry : nodes.entrySet()) {
        System.out.printf("%s %s%n", entry.getKey(), entry.getValue().getLabel());
      }
    }
    
    public static void addLeaves(Map<string, node> nodes, Node node, String prefix) {
      if (node != null) {
        addLeaves(nodes, node.getLeft(), prefix + "0");
        addLeaves(nodes, node.getRight(), prefix + "1");
        if (node.isLeaf()) {
          nodes.put(prefix, node);
        }
      }
    }
    

    One possible output is:

             White    Black
    Empty          0 
    Pawn       110      100
    Rook     11111    11110
    Knight   10110    10101
    Bishop   10100    11100
    Queen   111010   111011
    King    101110   101111
    

    For a starting position this equates to 32 x 1 + 16 x 3 + 12 x 5 + 4 x 6 = 164 bits.

    State Difference

    Another possible approach is to combine the very first approach with Huffman coding. This is based on the assumption that most expected Chess boards (rather than randomly generated ones) are more likely than not to, at least in part, resemble a starting position.

    So what you do is XOR the 256 bit current board position with a 256 bit starting position and then encode that (using Huffman coding or, say, some method of run length encoding). Obviously this will be very efficient to start with (64 0s probably corresponding to 64 bits) but increase in storage required as the game progresses.

    Piece Position

    As mentioned, another way of attacking this problem is to instead store the position of each piece a player has. This works particularly well with endgame positions where most squares will be empty (but in the Huffman coding approach empty squares only use 1 bit anyway).

    Each side will have a king and 0-15 other pieces. Because of promotion the exact make up of those pieces can vary enough that you can’t assume the numbers based on the starting positions are maxima.

    The logical way to divide this up is store a Position consisting of two Sides (White and Black). Each Side has:

    • A king: 6 bits for the location;
    • Has pawns: 1 (yes), 0 (no);
    • If yes, number of pawns: 3 bits (0-7+1 = 1-8);
    • If yes, the location of each pawn is encoded: 45 bits (see below);
    • Number of non-pawns: 4 bits (0-15);
    • For each piece: type (2 bits for queen, rook, knight, bishop) and location (6 bits)

    As for the pawn location, the pawns can only be on 48 possible squares (not 64 like the others). As such, it is better not to waste the extra 16 values that using 6 bits per pawn would use. So if you have 8 pawns there are 488 possibilities, equalling 28,179,280,429,056. You need 45 bits to encode that many values.

    That’s 105 bits per side or 210 bits total. The starting position is the worst case for this method however and it will get substantially better as you remove pieces.

    It should be pointed out that there are less than 488 possibilities because the pawns can’t all be in the same square  The first has 48 possibilities, the second 47 and so on. 48 x 47 x … x 41 = 1.52e13 = 44 bits storage.

    You can further improve this by eliminating the squares that are occupied by other pieces (including the other side) so you could first place the white non-pawns then the black non-pawns, then the white pawns and lastly the black pawns. On a starting position this reduces the storage requirements to 44 bits for White and 42 bits for Black.

    Combined Approaches

    Another possible optimization is that each of these approaches has its strength and weaknesses. You could, say, pick the best 4 and then encode a scheme selector in the first two bits and then the scheme-specific storage after that.

    With the overhead that small, this will by far be the best approach.

    Game State

    I return to the problem of storing a game rather than a position. Because of the threefold repetition we have to store the list of moves that have occurred to this point.

    Annotations

    One thing you have to determine is are you simply storing a list of moves or are you annotating the game? Chess games are often annotated, for example:

    1. Bb5!! Nc4?

    White’s move is marked by two exclamation points as brilliant whereas Black’s is viewed as a mistake. See Chess punctuation.

    Additionally you could also need to store free text as the moves are described.

    I am assuming that the moves are sufficient so there will be no annotations.

    Algebraic Notation

    We could simply store the the text of the move here (“e4”, “Bxb5”, etc). Including a terminating byte you’re looking at about 6 bytes (48 bits) per move (worst case). That’s not particularly efficient.

    The second thing to try is to store the starting location (6 bits) and end location (6 bits) so 12 bits per move. That is significantly better.

    Alternatively we can determine all the legal moves from the current position in a predictable and deterministic way and state which we’ve chosen. This then goes back to the variable base encoding mentioned above. White and Black have 20 possible moves each on their first move, more on the second and so on.

    Conclusion

    There is no absolutely right answer to this question. There are many possible approaches of which the above are just a few.

    What I like about this and similar problems is that it demands abilities important to any programmer like considering the usage pattern, accurately determining requirements and thinking about corner cases.

    Chess positions taken as screenshots from Chess Position Trainer.

    0 讨论(0)
  • 2021-01-29 17:37

    I'd try to use Huffman encoding. The theory behind this is - in every chess game there will be some pieces that will move around a lot, and some that don't move much or get eliminated early. If the starting position has some pieces already removed - all the better. The same goes for squares - some squares get to see all action, while some don't get touched much.

    Thus I'd have two Huffman tables - one for pieces, other for squares. They will be generated by looking at the actual game. I could have one large table for every piece-square pair, but I think that would be pretty inefficient because there aren't many instances of the same piece moving on the same square again.

    Every piece would have an assigned ID. Since there are 32 different pieces, I would need just 5 bits for the piece ID. The piece IDs are not changing from game to game. The same goes for square IDs, for which I would need 6 bits.

    The Huffman trees would be encoded by writing each node down as they are traversed in inorder (that is, first the node is output, then its children from left to right). For every node there will be one bit specifiying whether it's a leaf node or a branch node. If it's a leaf node, it will be followed by the bits giving the ID.

    The starting position will simply be given by a series of piece-location pairs. After that there will be one piece-location pair for every move. You can find the end of the starting position descriptor (and the start of the moves descriptor) simply by finding the first piece that is mentioned twice. In case a pawn gets promoted there will be 2 extra bits specifying what it becomes, but the piece ID won't change.

    To account for the possibility that a pawn is promoted at the start of the game there will also be a "promotion table" between the huffman trees and the data. At first there will be 4 bits specifying how many pawns are upgraded. Then for each pawn there will be its huffman-encoded ID and 2 bits specifying what it has become.

    The huffman trees will be generated by taking into account all the data (both the starting position and the moves) and the promotion table. Although normally the promotion table will be empty or have just a few entries.

    To sum it up in graphical terms:

    <Game> := <Pieces huffman tree> <squares huffman tree> <promotion table> <initial position> (<moves> | <1 bit for next move - see Added 2 below>)
    
    <Pieces huffman tree> := <pieces entry 1> <pieces entry 2> ... <pieces entry N>
    <pieces entry> := "0" | "1" <5 bits with piece ID>
    
    <squares huffman tree> := <squares entry 1> <squares entry 2> ... <squares entry N>
    <Squares entry> := "0" | "1" <6 bits with square ID>
    
    <promotion table> := <4 bits with count of promotions> <promotion 1> <promotion 2> ... <promotion N>
    <promotion> := <huffman-encoded piece ID> <2 bits with what it becomes>
    
    <initial position> := <position entry 1> <position entry 2> ... <position entry N>
    <moves> := <position entry 1> <position entry 2> ... <position entry N>
    <position entry> := <huffman-encoded piece ID> <huffman-encoded squre ID> (<2 bits specifying the upgrade - optional>)
    

    Added: This could still be optimized. Every piece only has a few legal moves. Instead of simply encoding the target square one could give 0-based IDs for the possible moves of every piece. The same IDs would get reused for every piece, so in total there would be no more than 21 different IDs (the queen can have at most 21 diffferent possible move options). Put this in a huffman table instead of the fields.

    This would however present a difficulty in representing the original state. One might generate a series of moves to put each piece in its place. In this case it would be necessary to somehow mark the end of the initial state and start of the moves.

    Alternatively they could be placed by using uncompressed 6-bit square IDs.

    Whether this would present an overall decrease in size - I don't know. Probably, but should experiment a bit.

    Added 2: One more special case. If the game state has NO moves it becomes important to distinguish who moves next. Add one more bit at the end for that. :)

    0 讨论(0)
  • 2021-01-29 17:37

    Possible improvement on the starting position in Yacoby's solution

    No legal position has more than 16 pieces of each color. The number of ways to place up to 16 black and 16 white pieces on 64 squares is about 3.63e27. Log2(3.63e27)=91.55. This means you can encode the position and color of all pieces in 92 bits. This is less than the 64 bits for position + up to 32 bits for color that Yacoby's solution requires. You can save 4 bits in the worst case at the expense of considerable complexity in the encoding.

    On the other hand, it increases the size for positions with 5 or more pieces missing. These positions represent only <4% of all positions, but they are probably a majority of the cases where you want to record a starting position different than the inital position.

    This leads to the complete solution

    1. Encode the position and color of pieces according to the method above. 92 bits.
    2. To specify the type of each piece, use a Huffman Code: pawn: '0', rook: '100', knight: '101', bishop: '110', queen: '1110', king: '1111'. This requires (16*1 + 12*3 + 4*4) = 68 bits for a full set of pieces. The full board position can be encoded in 92 + 68 = 160 bits maximum.
    3. Additional game state shoud be added: turn: 1 bit, which castling is possible: 4 bits, “en passant” possible: up to 4 bits (1 bit tells it is the case and 3 bits tell which one). The starting position is encoded in = 160 + 9 = 169 bits
    4. For the list of moves, enumerate all possible moves for a given position and store the position of the move in the list. The list of moves includes all special cases (castling, en passant, and resigning). Use only as many bits as necessary to store the highest position. On average it shouldn't exceed 7 bits per move (16 possible pieces and 8 legal moves per piece on average). In some case, when a move is forced, it requires only 1 bit (move or resign).
    0 讨论(0)
  • 2021-01-29 17:38

    In the base case of the initial board plus subsequent moves, consider the following.

    Use a chess program to assign probabilities to all possible moves. For example, 40% for e2-e4 20% for d2-d4, and so on. If some moves are legal but not considered by that program, give them some low probability. Use arithmetic coding to save which choice was taken, which will be some number between 0 and 0.4 for the first move, 0.4 and 0.6 for the second, and so on.

    Do the same for the other side. For example, if there is a 50% chance of e7-e5 as the response to e2-e4 then the encoded number will be between 0 and 0.2. Repeat until the game is done. The result is a potentially very small range. Find the binary fraction with the smallest base which fits in that range. That's arithmetic coding.

    This is better than Huffman because it can be thought of as fractional bit encoding (plus some at the end of the game to round up to a whole bit).

    The result should be more compact than Huffman, and there are no special cases for promotion, en passant, the 50 rule move, and other details because they are handled by the chess evaluation program.

    To replay, again use the chess program to evaluate the board and assign all probabilities to each move. Use the arithmetic encoded value to determine which move was actually played. Repeat until done.

    If your chess program is good enough, you can get better compression with a two-state encoder, where the probabilities are defined based on moves for both black and white. In the most extreme case of some 200+ states, this encodes the entire set of all possible chess games, and is therefore not feasible.

    This is pretty much a different way of saying what Darius already wrote, only with a bit of example of how arithmetic coding might work, and a real example of using an existing chess program to help evaluate the probability of the next move(s).

    0 讨论(0)
  • 2021-01-29 17:40

    If computational time is not an issue then you could use a deterministic possible position generator to assign unique ids to a given position.

    From a given position first generate number of possible positions in a deterministic manor, e.g. starting bottom left moving to top right. That determines how many bits you'll need for the next move, some situations it could be as little as one. Then when the move is made store just the unique id for that move.

    Promotion and other rules simply count as valid moves as long as they are handled in a deterministic way, e.g. to queen, to rook, to bishop each count as a separate move.

    The initial position is hardest and could generate around 250 million possible positions (I think) which would require about 28 bits plus an extra bit to determine whose move it is.

    Assuming we know who's turn it is (each turn flips from white to black) the deterministic generator would look something like:

    for each row
        for each column
            add to list ( get list of possible moves( current piece, players turn) )
    

    'get list of possible moves' would do something like:

    if current piece is not null 
        if current piece color is the same as the players turn
            switch( current piece type )
                king - return list of possible king moves( current piece )
                queen - return list of possible queen moves( current piece )
                rook - return list of possible rook moves( current piece )
                etc.
    

    If the king is in check then each 'list of possible xxx moves' only returns valid moves that change the check situation.

    0 讨论(0)
  • 2021-01-29 17:41

    I'd use a run length encoding. Some pieces are unique (or exist only twice), so I can omit the length after them. Like cletus, I need 13 unique states, so I can use a nibble (4 bits) to encode the piece. The initial board would then look like this:

    White Rook, W. Knight, W. Bishop, W. Queen, W. King, W. Bishop, W. Knight, W. Rook,
    W. Pawn, 8,
    Empty, 16, Empty, 16
    B. Pawn, 8,
    B. Rook, B. Knight, B. Bishop, B. Queen, B. King, B. Bishop, B. Knight, B. Rook
    

    which leaves me with 8+2+4+2+8 nibbles = 24 nibbles = 96 bits. I can't encode 16 with a nibble but since "Empty, 0" doesn't make sense, I can treat "0" as "16".

    If the board is empty but for a single pawn in the upper left corner, I get "Pawn, 1, Empty, 16, Empty, 16, Empty 16, Empty, 15" = 10 nibbles = 40 bits.

    The worst case is when I have an empty square between each piece. But for the encoding of the piece, I just need 13 out of 16 values, so maybe I can use another one to say "Empty1". Then, I need 64 nibbles == 128bits.

    For the movements, I need 3 bits for the piece (the color is given by the fact that white always moves first) plus 5 bits (0..63) for the new position = one byte per movement. Most of the time, I don't need the old position since only a single piece will be within range. For the odd case, I must use the single unused code (I just need 7 codes to encode the piece) and then 5 bits for the old and 5 bits for the new position.

    This allows me to encode castling in 13 bites (I can move the King towards the Rook which is enough to say what I intend).

    [EDIT] If you allow a smart encoder, then I need 0 bits for the initial setup (because it doesn't have to be encoded in any way: It's static) plus one byte per move.

    [EDIT2] Which leaves the pawn transformation. If a pawn reaches the last row, I can move it in place to say "transforms" and then add the 3 bits for the piece it is replaced with (you don't have to use a queen; you can replace the pawn with anything but the King).

    0 讨论(0)
提交回复
热议问题