Viết một thuật toán hoặc chương trình có thể mã hóa và giải mã một bàn cờ. Mục tiêu là tạo ra một đại diện nhỏ nhất của bàn cờ có thể được sử dụng (một lần được giải mã) để xác định tất cả các khả năng di chuyển cho người chơi trong lượt đó.

Mã hóa phải có khả năng hiển thị:

• Nó biến của ai
• Cho dù người chơi có thể lâu đài ở mỗi bên.
• Liệu người chơi có thể thực hiện một en-passant không, và nếu vậy, con tốt nào của họ?
• Vị trí của tất cả các mảnh.

Lưu ý quan trọng về việc ném đá: Nếu màu trắng di chuyển vua của họ một lượt, và sau đó di chuyển nó trở lại tiếp theo, thì rõ ràng là họ không thể lâu đài ở hai bên sau đó. Tương tự sẽ đi nếu họ di chuyển rook trái hoặc phải của họ. Mặc dù bảng đang ở trạng thái trực quan giống như hai lượt trước, trạng thái trò chơi đã thay đổi. Thêm thông tin ở đây: http://en.wikipedia.org/wiki/Chess#Castling

Lưu ý quan trọng về en-passant: Đây cũng là một nước đi nhạy cảm. Đọc các quy tắc để biết thêm. http://en.wikipedia.org/wiki/Chess#En_passant

Xác định đầu vào và đầu ra khi cần thiết. Đạo cụ chính cho bất cứ ai có thể nén nó nhiều nhất!

Điểm của bạn được xác định trong trường hợp xấu nhất - kích thước tối đa có thể tính bằng bit. Hãy chắc chắn rằng bạn cho thấy cách bạn tính toán số đó và những gì bạn chiếm. Bắn cho trường hợp xấu nhất nhỏ nhất!

Tối thiểu: 12 bit
Tối đa:
Trung bình:

Có và nghĩ đêm qua rằng tôi có thể làm cho nó thậm chí còn nhỏ hơn.

x   Colour to play next (0 -> Black, 1-> White)
1   Only King left?

00000 Position of White King (0 -> A1 ... 63 -> H8)
00000 Position of Black King

01 00000 11111  WK:A1, BK:H2 (Black to play)
11 00000 11111  WK:A1, BK:H2 (White to play)

Kết quả là kích thước ấn tượng 12 bit !

Vậy còn K +1 loại mảnh nào khác?

x
 0
   0
     000  +Pawn
     001  +Rook   
     010  +Knight
     011  +Bishop
     100  +Queen

Có 2 cách sắp xếp của cây phụ.

   /\      /\
  +  K    K  +

Cả hai kết quả trong cùng một kích thước bit cho tất cả các mảnh. Vì vậy, nó không có gì khác biệt mà chúng tôi sử dụng, tôi sẽ chọn cái đầu tiên.

x
 0
  0
   000
      1011001110000000000000000000000000000000000000000000000000000000000000
(+ 000) En-Passant (if >= 2 pawn & pawn in en-passant positions)
(+ 00 ) Castlings  (if >= 1 rook)
Min: 75 bit
Max: 109 bits

Vì vậy, trên King +2 loại mảnh khác

x
 0
  1
   PRBNQ
   00011  +N +Q
   00101  +B +Q
   00110  +B +N
   01001  +R +Q
   01010  +R +N
   01100  +R +B
   10001  +P +Q
   10010  +P +N
   10100  +P +B
   11000  +P +R

Có 5 cây con có thể (Tôi sẽ sử dụng 1 và 2 để chỉ ra những mảnh nào.)

   /\          /\       /\         /\          /\
  /  \        /  \     /  \       /  \        /  \
 K   /\      /\   2   /\   \     1   /\      /\   \
    1  2    K  1     K  2   1       K  2    1  2   K

Vì vậy, chúng tôi sẽ yêu cầu 3 bit để mã hóa cây con nào sẽ sử dụng.

x
 0
  1
   PRBNQ
         000  Sub Tree used

Min:= 11 = Header 
       6 = 2 * 3
       4 = 1 * 4
       4 = 1 * 4
      60 = 60    Empty
      --
      85 bits

Max:=  11 = Header
        4 =  2 * 4 Kings
       48 = 16 * 3 Pawns
       12 =  4 * 3 Rook
       42 = 42 * 1 Empty
        3 =  1 * 3 En-Passant
        2 =  1 * 2 Castlings
      ---
      122 bits

Vẫn đang phân tích cho nhiều mảnh hơn

+3 Khác

x
 0
  1
   PRBNQ
         0000  Sub Tree used (of 14 possible)

+4 Khác

x
 0
  1
   PRBNQ
         000000  Sub Tree used (of 42 possible)

+5 Khác

x
 0
  1
   PRBNQ
         0000000  Sub Tree used (of 132 possible)
 (+000)
 (+00)

Tối đa: 208?

Có thể mã hóa tất cả các cây con này thành 9 bit không?

Nếu chúng ta tổng cộng tất cả các cây con có thể, chúng ta sẽ có 392 cây con có thể.

 1  0
 2  2
 3  5
 4  14
 5  42
 6  132
    ---
    392  <= 2^9

Sử dụng ID Freq

Kể từ đó có 164603 tần số mảnh duy nhất .

Log2( 164603) = 17.3286110452
             ~ 18 bits

0
 0000 0000 0000 0000 00  Freq ID

(+000) (Pool) Castling

Tối đa: = 204 bit

vòng 3

Tối thiểu: 82 Tối đa: 199 Trung bình: 160

Cuối cùng có một số phân tích để tìm kích thước bit tối đa. Với mã hóa huffman tối ưu cho mỗi tần số mảnh duy nhất .

               0   Player
              00  Castling
               0  En-Passant Possible
            ?000  En-Passant column (include if En-Passant Possible = 1
  0000 0000 0000  Tree Encoding ID
[Board Encoding]  Between 66 .. 180 bits 

Lưu ý đây là kích thước tồi tệ nhất có thể, mà cột En-Passant bit nếu số lượng con tốt hơn một con. Không phân biệt màu sắc và vị trí của những con tốt đó, có khả năng một số bảng nhỏ hơn 3 bit.

Ngoài ra, chỉ có 144 kích cỡ khác nhau (trường hợp xấu nhất) cho kích thước của bảng.

_{75 - 216 bit (v2) v1 Kích thước tối thiểu là 98 bit (12,25 byte), chỉ có hai vị vua trên bảng.}

Kích thước tối đa chỉ là 216 bit (27 byte.) Trong phần không thích: -

  9 x Queens
  1 x King
  2 x Rooks
  2 x Knights
  2 x Bishops
on each side.

Trung bình kích thước sẽ vào khoảng 157 bit (19.625 byte).

Miếng

Để mã hóa bảng tôi đang sử dụng sơ đồ mã hóa cây nhị phân. Một hình vuông trống là thường xuyên nhất từ ​​bất kỳ nơi nào từ 32 đến 62 lần xuất hiện. Tiếp theo là những con tốt, sau đó là Rooks, Hiệp sĩ, Giám mục và ít thường xuyên nhất là Nữ hoàng và Vua.

0 - left node
1 - righ node

     /\
    e  \    e:= Empty Square
      B/\W  B:= Black ; W:= White
      /  \
     /    \
    /      \
   /\      /\
  p  \    p  \  p:= Pawn
     /\      /\
    /  \    /  \
   /\  /\  /\  /\
  r  b n \ r b n \  r:= Rook; b:= Bishop; n:= Knight
         /\      /\ 
        q  k    q  k  q:= Queen ; k:= King

Bảng khởi đầu có thể được mã hóa chỉ trong 166 bit (20,75 byte)

  A     B     C      D      E     F     G     H
-----+-----+-----+------+------+-----+-----+------+
10100 10101 10110 101110 101111 10110 10101 10100 | 8 
  100   100   100    100    100   100   100   100 | 7
    0     0     0      0      0     0     0     0 | 6
    0     0     0      0      0     0     0     0 | 5
    0     0     0      0      0     0     0     0 | 4
    0     0     0      0      0     0     0     0 | 3
  110   110   110    110    110   110   110   110 | 2
11100 11101 11110 111110 111111 11110 11101 11100 | 1

Để chỉ ra ai đang di chuyển, chỉ mất một bit

0-> Black , 1-> White

Castling có thể được mã hóa trong 4 bit.

 B  W
LR LR
00 00

Vì vậy, tôi đã sử dụng 171 bit (21.375 byte)

En-Passe có thể được mã hóa thành 16 bit (2 byte)

Vì vậy, trong tổng số đó là 187 bit (23.375 byte).

Bố trí

  bits    Encodes
 0 -  15  En-Passe
16 -  19  Castling
      20  Move 
21 -  23  Unused
24 -> ..  Board

Chưa viết bất kỳ mã nào.

Lưu ý rằng 3 trong số các bit không được sử dụng. Vậy tối đa là 213 bitcoin .

Những cải tiến có thể

1) Giảm dạng khối tiêu đề 24 xuống 8 bit (với đề xuất @Peter Taylor)

0 - 2 En-Passant
    3 Move
4 - 7 Castling
8 ... Board Pieces 

2) Tiêu đề chiều dài thay đổi

Một tiêu đề cố định nhỏ 4 bit

0 0 0 0
| | | |
| | | +-> En-Passant Block Present?
| | | 
| | +---> Pawns on board?
| |
| +-----> Castling still possible?
|                
+-------> Who's move? 0-Black 
                      1-White

Khối bit tiếp theo (Nếu vẫn còn có thể sử dụng)

00 00
|| ||
|| |+-> White Castle Right
|| +--> White Castle Left
||
|+----> Black Castle Right
+-----> Black Castle Left

Khối bit tiếp theo (nếu có pawns)

000--> En-Passant column Position

Vì vậy, bây giờ tôi có một tiêu đề có độ dài thay đổi 4 - 11 bit

3) Sử dụng sơ đồ mã hóa khác nhau tùy thuộc vào những phần còn lại trên bảng.

Bằng cách thay đổi mã hóa cây tùy thuộc vào những mảnh trên bảng và tần số.

Một mã hóa có thể có cho trạng thái trò chơi kết thúc (Không có dấu chân)

        /\            
       e /\           
  Black /  \ White
       /    \
      /      \
     /        \       
    /\        /\
   /  \      /  \     
  /   /\    /   /\
 /\  / /\  /\  / /\   
r b n q k  r b n q k

Đó là khoảng ~ 4 bit mỗi mảnh.

Những loại mảnh có mặt trên bảng?

RBNQK Permutation
11111 (11111)

Hoán vị là độ dài biến 0-5 bit. Nếu chỉ còn một loại mảnh thì đừng bao gồm nó.

Những hoán vị của những mảnh để sử dụng cho cây? Đây là giai thừa của số lượng các mảnh trong ví dụ trên, nó là 5 mảnh để 120 hoán vị có thể được mã hóa.

 #    !  bit 
 6  720  10  (If pawn included)
 5  120   6
 4   24   5
 3    6   3
 2    2   1  Don't include as of equal size.
 1    1   0  Don't include as its not needed.

Hãy nhớ rằng có các bit bổ sung cho các ô vuông và màu trống.

Ví dụ

Hãy cho một ví dụ về chỉ QK còn lại

RBNKQ
00011

  /\
 s  \
    /\
  B/  \W
  /\  /\
q  k q  k

101 100  0 x 60 110 111 ==> 60 + (2 x 6) = 60 + 12 = 72 bits for the board

0000 00011 Header ==> 9 bits

Tổng cộng 81 bit

Hãy cho và ví dụ về chỉ các vị vua còn lại

 RBNQK
 00001 

  /\
 s  k
   / \
  B   W

 10 0 0 0 0 0 0 0   K... ....
  0 0 0 0 0 0 0 0   .... ....
  0 0 0 0 0 0 0 0   .... ....
  0 0 0 0 0 0 0 0   .... ....
  0 0 0 0 0 0 0 0   .... ....
  0 0 0 0 0 0 0 0   .... ....
  0 0 0 0 0 0 0 0   .... ....
  0 0 0 0 0 0 0 11  .... ...k

Đặt tất cả lại với nhau

 header  4   0 0 0 0
 pieces  5   0 0 0 0 1
 perm    0   - - - - - -
  board 66   10 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 11

Vì vậy, tôi tính toán mã hóa nhỏ nhất cho bảng ở 75 bit (9 bit 3 bit)

Vẫn chưa tính toán làm thế nào sơ đồ mã hóa này ảnh hưởng đến kích thước tối đa.

Cải thiện 4

Giảm số lượng bit để đúc xuống chỉ còn 2 bit. Chỉ cần ném cho người chơi đến lượt nó.

 0 Castling possible (from header block)
 LR 
 00

Nghĩ về nó, có lẽ tốt hơn là chỉ bao gồm 2 bit bên trong khối tiêu đề.

192 bit (trường hợp xấu nhất)

Đây là sơ đồ lưu trữ rất đơn giản để đối phó với các chương trình khuyến mãi cầm đồ tùy ý và không bao giờ yêu cầu nhiều hơn 64 + 4 × 32 = 192 bit:

• 64 bit đầu tiên lưu trữ một bitboard cho biết các mảnh đó ở đâu (nhưng không phải là những gì chúng). Nghĩa là, chúng tôi lưu trữ một bit cho mỗi ô vuông của bàn cờ (bắt đầu từ ô vuông a1, sau đó là b1, c1, v.v. đến ô vuông h8) sao cho ô vuông trống được biểu thị bằng 0 và ô vuông chiếm 1.

• Tiếp theo, đối với mỗi hình vuông được đánh dấu là chiếm trên bảng bit, chúng tôi lưu trữ một mẩu 4 bit mã hóa mảnh trên hình vuông đó. Đầu tiên trong bốn bit mã hóa màu của mảnh (0 = trắng, 1 = đen), trong khi ba bit còn lại mã hóa loại mảnh:

  +-----+-----+-----+-----+
  |Black|   Piece Type    |
  +-----+-----+-----+-----+
     4     3     2     1    Bits
  

  Loại mảnh

  0 = (bình thường) cầm đồ
  1 = (bình thường) rook
  2 = hiệp sĩ
  3 = giám mục
  4 = nữ hoàng
  5 = vua (của người chơi để di chuyển tiếp theo)
  6 = vua (của người chơi khác)

  Lưu ý hai bảng mã cho nhà vua, được sử dụng để xác định lượt người chơi sẽ di chuyển. (Trên thực tế, vì luôn có hai vị vua trên bảng, cho phép bốn tổ hợp mã 5 và 6, chúng ta có thể dễ dàng mã hóa một chút thông tin thứ hai ở đây.)

  Black Type Description
  +----+----+--------------------------------+
  |  0 | 5  | White King; White to move next |
  +----+----+--------------------------------+
  |  0 | 6  | White King                     |
  +----+----+--------------------------------+
  |  1 | 5  | Black King; Black to move next |
  +----+----+--------------------------------+
  |  1 | 6  | Black King                     |
  +----+----+--------------------------------+
  

  Để mã hóa thông tin bổ sung cần thiết cho quy tắc en passant và castling, chúng tôi giới thiệu một loại mảnh bổ sung, biểu thị một con tốt hoặc một rook tùy thuộc vào hàng xuất hiện trên:

  7 (trên hàng 1 và 8) = một rook chưa bao giờ di chuyển, và vua của họ cũng chưa bao giờ di chuyển, và do đó đủ điều kiện để ném
  7 (trên hàng 4 và 5) = một con tốt vừa mới tiến lên hai hình vuông, và do đó có thể bị bắt en passant

Để tất cả chúng cùng nhau:

     Hex Description
    +---+---------------------------------------------+
    | 0 | White Pawn (normal)                         |
    | 1 | White Rook (has moved)                      |
    | 2 | White Knight                                |
    | 3 | White Bishop                                |
    | 4 | White Queen                                 |
    | 5 | White King; White to move next              |
    | 6 | White King                                  |
    | 7 | White Rook (pre castle) / Pawn (en Passant) |
    | 8 | Black Pawn (normal)                         |
    | 9 | Black Rook (has moved)                      |
    | A | Black Knight                                |
    | B | Black Bishop                                |
    | C | Black Queen                                 |
    | D | Black King; Black to move next              |
    | E | Black King                                  |
    | F | Black Rook (pre castle) / Pawn (en Passant) |
    +---+---------------------------------------------+

Do đó, tổng số bit cần thiết để mã hóa trạng thái của bảng là 64 + 4 × # các mảnh trên bảng. Vì không bao giờ có thể có hơn 32 miếng trên bảng, độ dài tối đa của mã hóa này là 192 bit.

Ví dụ: sử dụng mã hóa được mô tả ở trên, trạng thái ban đầu của bảng sẽ được mã hóa dưới dạng (khoảng trắng được chèn để dễ đọc):

1111 1111 1111 1111 0000 0000 0000 0000 0000 0000 0000 0000 1111 1111 1111 1111
0111 0010 0011 0100 0101 0011 0010 0111 0000 0000 0000 0000 0000 0000 0000 0000
1000 1000 1000 1000 1000 1000 1000 1000 1111 1010 1011 1100 1110 1011 1010 1111

hoặc, trong hệ thập lục phân:

FFFF 0000 0000 FFFF 7234 5327 0000 0000 8888 8888 FABC EBAF

Trường hợp xấu nhất 160 bit

Sau khi đăng câu trả lời trước đó của tôi 22 byte, tôi bắt đầu tự hỏi liệu chúng ta có thể giảm xuống còn 21 byte không. Tuy nhiên, khi tôi thấy 166 byte tuyệt vời của Peter Taylor, tôi đã nghĩ rằng "Hãy chờ, có vẻ như có thể có năm từ 32 bit!"

Vì vậy, sau khi suy nghĩ khá nhiều, tôi đã nghĩ ra điều này: 159.91936391 byte (phù hợp khá chặt chẽ!) Mức nén này sẽ cần một chương trình khá phức tạp nhưng tôi đã nghĩ về cách làm cho nó chạy trong thời gian hợp lý.

Đây sẽ là một bài viết dài, vì vậy hãy đồng ý với tôi, tôi sẽ đăng những gì tôi có thể hôm nay và thêm một vài đoạn mã sớm.

Vì vậy, đây là cách để làm điều đó:

En Passant và castling được mã hóa bởi các vị trí bất hợp pháp (0 bit)

En Passant

Như đã đề cập trong các câu trả lời khác, có tối đa 5 ô vuông có thể có trên đó một con tốt dễ bị tổn thương bởi người qua đường có thể đứng. Đây là những ô vuông bên cạnh những con tốt của người chơi đến lượt nó.

Để mã hóa điều này, con tốt dễ bị tấn công bởi người qua đường được trao đổi với bất cứ thứ gì nằm trên một trong các ô vuông ở hàng đầu tiên hoặc cuối cùng. Đây có thể là một người đàn ông hoặc một hình vuông trống. Điều này tạo ra một vị trí bất hợp pháp, vì những con tốt không thể ở trên những hàng này. Bộ giải mã phải trả lại cầm đồ về đúng vị trí của nó, trích xuất thông tin en passant.

Để điều này không can thiệp vào mã hóa castling, điều quan trọng là các ô vuông mà các vị vua đứng ở đầu trò chơi không bị xáo trộn và quy trình mã hóa en passant không đặt các vị vua cạnh nhau, đó sẽ là một vị trí vua bất hợp pháp. Để thỏa mãn điểm thứ hai trong số các điểm này, bộ mã hóa có hai sự lựa chọn là nó sẽ trao đổi hình vuông của người thụ động. Hình vuông lựa chọn đầu tiên cho mỗi trong số tối đa 5 con tốt là A8, B8, C8, G8, H8. Lựa chọn thứ hai: A1, B1, C1, G1, H1.

Đúc

Một vị vua được phép vào lâu đài theo định nghĩa, vẫn còn trên quảng trường ban đầu của mình. Với vị vua trắng trên quảng trường ban đầu của mình, có tổng cộng 63 ô vuông mà vị vua đen có thể đứng, 58 trong số đó là hợp pháp (anh ta không được phép di chuyển ngay bên cạnh vị vua trắng vì anh ta sẽ tự kiểm tra.) Nếu vua trắng được phép vào lâu đài, anh ta hoặc được phép vào lâu đài với tân binh trái, tân binh phải hoặc cả hai. Do đó, có 3x58 = 174 khả năng trong đó vua trắng có thể xây lâu đài, một 174 khác trong đó vua đen có thể xây lâu đài và thêm 3x3 = 9 trong đó cả hai có thể xây lâu đài, tổng cộng là 357.

Có 420 sự sắp xếp bất hợp pháp của hai vị vua nơi họ ở trên các ô vuông liền kề: 3x4 = 12 khi vua trắng ở trong góc, 5x24 = 120 khi anh ta ở rìa và 8x36 = 288 khi anh ta ở trên một hình vuông khác. Do đó, có thể dễ dàng có đủ các vị trí bất hợp pháp để mã hóa tất cả các khả năng đúc có thể.

Nếu ít nhất một vị vua được phép vào lâu đài, bộ mã hóa sẽ tra cứu dữ liệu đúc và dữ liệu vị trí của những vị vua không được phép đặt lâu đài trong một bảng (hoặc cách khác, sử dụng thuật toán mà tôi sẽ không chỉ định ở đây) và tạo ra bất hợp pháp vị trí của hai vị vua. Sau đó, nó sẽ trao đổi các vị vua với bất cứ điều gì xảy ra trên các ô vuông này.

Điều quan trọng là điều này được mã hóa sau và giải mã trước en passant, nếu không, có một số can thiệp tiềm năng.

So sánh

Vì vậy, cho đến nay tôi đã không sử dụng bit! Nhìn vào câu trả lời của Peter, tôi vẫn có những điều sau đây để mã hóa:

Whose turn is it?                                   1.000 bits
Which squares are occupied by men of which colour? 91.552 bits 
Subtotal                                          *92.552 bits* 
For the two colours, which men and which order?   *68.613 bits* 
GRAND TOTAL                                       161.165 bits

Đây là trường hợp xấu nhất của 29 người đàn ông (xem câu trả lời của Peter.) Dưới đây tôi sẽ chỉ ra cách tôi cải thiện biên (ít nhất là đối với trường hợp 29 người) trên cả hai điểm được đánh dấu trong **.

Những hình vuông được chiếm / lần lượt là của ai?

Cách dễ dàng để mã hóa các ô vuông bị chiếm dụng là với lưới 64 bit. Điều này cũng cho chúng ta biết có bao nhiêu hình vuông bị chiếm đóng. Tuy nhiên nó hơi lãng phí vì không thể có hơn 32 ô vuông bị chiếm đóng. Giải pháp của tôi là sử dụng 1 'để mã hóa cho các ô vuông bị chiếm khi đến lượt của Trắng và 0 để mã hóa cho các ô vuông bị chiếm khi đến lượt của Đen. Bây giờ tất cả các kết hợp được sử dụng và không có chất thải.

Do đó, chúng tôi tiết kiệm một chút để lưu trữ lượt chơi: dưới 32 1 giây, đến lượt trắng, hơn 32 1 giây, đến lượt đen. Trường hợp mơ hồ duy nhất là khi tất cả những người đàn ông ở trên bảng và có 32 1 và 32 0. Do đó, chỉ cần thêm một chút cho trường hợp này. Vì không thể có chương trình khuyến mãi nào cho đến khi bắt giữ xảy ra, bit thừa này không ảnh hưởng đến trường hợp xấu nhất nói chung (xảy ra với 3 người đàn ông bị bắt và 29 người còn lại.)

Màu sắc của những người đàn ông chiếm các hình vuông

Chúng tôi biết từ trên có bao nhiêu người đàn ông. Đoạn trích sau đây về tam giác của Pascal cho biết có bao nhiêu khả năng cho các phân phối khác nhau của đen và trắng. Ví dụ: đối với 3 nam, các khả năng là: 3 nam đen (1 hoán vị) 2 đen, 1 trắng, (3 hoán vị), 1 đen, 2 trắng (3 hoán vị), 3 trắng (1 hoán vị.) Tổng cộng là 2 ³ = 8. Nói chung, đối với số lượng nam giới thấp hơn, có 2 ⁿ khả năng. Tuy nhiên, tất cả các khả năng đen và trắng đều là bất hợp pháp (ít nhất là vua của mỗi bên phải ở trên bảng), vì vậy số lượng hoán vị pháp lý thực tế là 2 ⁿ -2 (bỏ qua 1 trên tam giác Pascals.)

Đối với hơn 16 tổng số nam giới, có một hạn chế bổ sung trong đó có thể có không quá 16 người đàn ông của mỗi màu trên bảng. Do đó, khi tất cả 32 người đàn ông ở trên bảng thì phải có 16 người và tổng số khả năng là 601080490, khá ít hơn 2 ³² .

1   1    1    1      1     1      1       1       1        1        1         1         1         1          1          1          1 
1   2    3    4     5      6      7       8       9       10       11        12        13        14         15         16         17
1   3    6   10    15     21     28      36      45       55       66        78        91       105        120        136        153
1   4   10   20    35     56     84     120     165      220      286       364       455       560        680        816        969
1   5   15   35    70    126    210     330     495      715     1001      1365      1820      2380       3060       3876       4845
1   6   21   56   126    252    462     792    1287     2002     3003      4368      6188      8568      11628      15504      20349
1   7   28   84   210    462    924    1716    3003     5005     8008     12376     18564     27132      38760      54264      74613
1   8   36  120   330    792   1716    3432    6435    11440    19448     31824     50388     77520     116280     170544     245157
1   9   45  165   495   1287   3003    6435   12870    24310    43758     75582    125970    203490     319770     490314     735471
1  10   55  220   715   2002   5005   11440   24310    48620    92378    167960    293930    497420     817190    1307504    2042975
1  11   66  286  1001   3003   8008   19448   43758    92378   184756    352716    646646   1144066    1961256    3268760    5311735
1  12   78  364  1365   4368  12376   31824   75582   167960   352716    705432   1352078   2496144    4457400    7726160   13037895
1  13   91  455  1820   6188  18564   50388  125970   293930   646646   1352078   2704156   5200300    9657700   17383860   30421755
1  14  105  560  2380   8568  27132   77520  203490   497420  1144066   2496144   5200300  10400600   20058300   37442160   67863915
1  15  120  680  3060  11628  38760  116280  319770   817190  1961256   4457400   9657700  20058300   40116600   77558760  145422675
1  16  136  816  3876  15504  54264  170544  490314  1307504  3268760   7726160  17383860  37442160   77558760  155117520  300540195
1  17  153  969  4845  20349  74613  245157  735471  2042975  5311735  13037895  30421755  67863915  145422675  300540195  601080390

Số lượng khả năng có thể được tìm thấy bằng cách tính tổng các "hàng" của trích xuất tam giác pascal này (ý tôi là các đường chéo NE-SW của bảng, vì tôi đã xoay tam giác 45 độ ngược chiều kim đồng hồ để trình bày thuận tiện. Do đó, để mã hóa lượt, các ô vuông và màu sắc chiếm đóng của người đàn ông như sau:

Tối đa 25 nam: ít hơn 64+ (số nam)
Dành cho hơn 25 nam:

men permutations  bits required  occupied sq+turn   
    of colours                   (bits required)  total bits
26   55791790     25.7335495      64              89.7335495
27  100960110     26.58921015     64              90.58921015
28  175844430     27.3897244      64              91.3897244
29  290845350     28.115677       64              92.115677   
30  445962870     28.73234836     64              92.73234836
31  601080390     29.16298271     64              93.16298271
32  601080390     29.16298271     65              94.16298271

Cho hai màu, đàn ông nào và theo thứ tự nào?

Theo các câu trả lời trước đó, không có con tốt nào có thể được thăng cấp cho đến khi việc bắt giữ xảy ra, bởi vì mỗi con tốt bị chặn bởi một con tốt của màu đối diện trên cùng một cột. Câu trả lời của Peter đã xem xét (như một giới hạn trên) rằng mỗi lần chụp có thể dẫn đến một khuyến mãi cho bên bị bắt và hai cho bên bị bắt. Tuy nhiên chúng ta có thể chia điều này thành nhiều trường hợp:

1. Cầm đồ đen chụp cầm đồ trắng: Bây giờ cầm đồ bắt được tự do quảng bá như bây giờ trên một cột khác. Đồng nghiệp của anh ấy trên cùng một cột cũng có thể thúc đẩy. Con tốt màu đen trên cột ban đầu của con tốt trắng cũng có thể thúc đẩy. Đây là trường hợp duy nhất cho phép 3 chương trình khuyến mãi.

2. Cầm đồ đen đi qua cầm đồ trắng trên cột liền kề và sau đó chụp mảnh trắng (trừ cầm đồ) phía sau. Điều này cho phép cầm đồ bắt và cầm đồ trắng trên cột ban đầu để quảng bá. Một khuyến mãi cho mỗi bên.

3. Cầm đồ trắng được chụp bằng mảnh (trừ cầm đồ.) Điều này thường sẽ chỉ cho phép một khuyến mãi cho Đen. Ngoại lệ duy nhất là khi nó giải phóng một đội hình cầm đồ đã bị chặn do một số cảnh bắt giữ di chuyển trên cùng một cột.

Vì vậy, như một trường hợp cơ bản, chúng tôi có thể xem xét rằng mỗi lần chụp cho phép một lần quảng cáo cho cả hai bên. Trong trường hợp người đàn ông bị bắt là một con tốt, có thể có một khuyến mãi bổ sung cho phía bắt giữ.

Tôi đã viết một chương trình tương tự như của Peter. Nó là một phần mềm, nhưng nó có một bổ sung quan trọng: nó có thể tính toán số lượng hoán vị có thể có khi người chơi bắt đầu với ít hơn 8 con tốt thông thường. Đây là một số dữ liệu được tạo ra bởi chương trình:

Max promotions   0            1            2             3             4              5 
8 PAWNS 
13 men    18725850    146911050    567991710    1373480394    2297173164     2902775304
14 men    36756720    339459120   1555313760    4501448952    9021804792    13325103792
15 men    60810750    660810150   3555401850   12144582450   28834205400    50030580600
16 men    64864800    843242400   5383778400   21810428640   61514893440    1.26476E+11
7 PAWNS                         
13 men    17760600    141003720    546949260    1321302840    2200401060     2761730400
14 men    30270240    287567280   1331890560    3852728880    7641553920    11068817760
15 men    32432400    372972600   2075673600    7209001800   17135118000    29315286000
6PAWNS                          
13 men    14054040    114594480    447026580    1069488420    1739577840     2113185360
14 men    15135120    151351200    718918200    2087805720    4073028960     5697051360                         
5 PAWNS                         
13 men     6486480     55135080    217297080     510630120     794233440      910235040

Chúng ta có thể thấy rằng đối với một trường hợp như 8 pawns, 15 nam, 0 khuyến mãi, số lượng hoán vị chỉ ít hơn một chút so với 8 pawns 16 nam, 0 khuyến mãi. Tuy nhiên, nếu chúng ta xem xét một trường hợp như 7 con tốt, 15 người đàn ông, 0 chương trình khuyến mãi (tương tự như xem xét rằng người đàn ông bị bắt chắc chắn là một con tốt), chúng ta nhận được khoảng một nửa số hoán vị.

Vì vậy, đối với trường hợp khi Đen có 16 nam và trắng có 15 nam, chúng ta có thể xem xét ước tính giới hạn trên của 2 khuyến mãi cho Đen và một khuyến mãi cho Trắng:

5383778400 x 660810150 = 3.55766E+18 possibilities

Tuy nhiên chúng tôi có thể làm tốt hơn nếu chúng tôi tiến hành như sau.

A. Hãy xem xét một khuyến mãi cho mỗi Đen và Trắng khi cho rằng người đàn ông Trắng đã mất có thể thuộc bất kỳ loại nào:

843242400 x 660810150 = 5.57223E+17 possibilities

B. Hãy xem xét các khả năng bổ sung cho Đen nếu anh ta có hai chương trình khuyến mãi, nhân với chỉ những khả năng đó cho Trắng mà anh ta đã mất một con tốt.

(5383778400-843242400) x 372972600 = 1.6935 E+18 possibilities.

Cộng hai số này lại với nhau, chúng ta sẽ có 2.25072E + 18, một con số nhỏ hơn 3.55766E + 18. Tất cả các khả năng cho tối đa 3 lần bắt (29 người còn lại) được liệt kê dưới đây.

(Promotions, Pawns lost) possibilities

BLACK 16 MEN, WHITE 15 MEN. ESTIMATE   3.55766E+18 = 2^61.62563249
(1,0)   843242400 x (1,0)  660810150 = 5.57223E+17
(2,0)  4540536000 x (1,1)  372972600 = 1.6935 E+18
                               TOTAL   2.25072E+18 = 2^60.96509144


BLACK 16 MEN, WHITE 14 MEN. ESTIMATE   9.5675 E+19 = 2^66.3747752
(2,0)  5383778400 x (2,0) 1555313760 = 8.37346E+18
(3,0) 16426650240 x (2,1) 1331890560 = 2.18785E+19
(4,0) 39704464800 x (2,2)  718918200 = 2.85443E+19
                               TOTAL   5.87962E+19 = 2^65.67235739


BLACK 16 MEN, WHITE 13 MEN. ESTIMATE   2.69447E+20 = 2^67.86856193
(3,0) 21810428640 x (3,0) 1373480394 = 2.99562E+19
(4,0) 39704464800 x (3,1) 1321302840 = 5.24616E+19
(5,0) 64960896000 x (3,2) 1069488420 = 6.94749E+19
(6,0) 69702272640 x (3,3)  510630120 = 3.55921E+19
                               TOTAL   1.87485E+20 = 2^67.34533572


BLACK 15 MEN, WHITE 15 MEN. ESTIMATE   1.47491E+20 = 2^66.99918768
(2,0)  3555401850 x (2,0) 3555401850 = 1.26409E+19
(2,1)  2075673600 x (3,0) 8589180600 = 1.78283E+19
(3,0)  8589180600 x (2,1) 2075673600 = 1.78283E+19
(3,1)  5133328200 x (3,1) 5133328200 = 2.63511E+19
                  TOTAL BOTH COLUMNS   7.46486E+19 = 2^66.01674923


BLACK 15 MEN, WHITE 14 MEN. ESTIMATE   4.51366E+20 = 2^68.61286007      
(3,0) 12144582450 x (3,0) 4501448952 = 5.46682E+19
(3,1)  7209001800 x (4,0) 4520355840 = 3.25873E+19
(4,0) 16689622950 x (3,1) 3852728880 = 6.43006E+19
(4,1)  9926116200 x (4,1) 3788825040 = 3.76083E+19
(5,0) 21196375200 x (3,2) 2087805720 = 4.42539E+19
(5,1) 12180168000 x (4,2) 1985223240 = 2.41804E+19
                  TOTAL BOTH COLUMNS   2.57599E+20 = 2^67.80368692

Vì vậy, trong trường hợp xấu nhất của một bên với 15 người đàn ông và bên kia với 14 người đàn ông, chúng ta cần 67,84 bit.

Thêm phần này vào các bit 92.116 cần thiết để chỉ định hình vuông nào và màu nào, chúng ta có tổng cộng 67.804 + 92.116 = 159,92 bit.

Trường hợp xấu nhất 177 bit

Algoritm này, trong khi hầu như không đơn giản, lại đưa ra trường hợp xấu nhất 177 bit (184b = 23B trong thực tế), kịch bản trường hợp tốt nhất 13b (16b = 2B) khi chỉ còn 2 vua.

Bit     Description
  1     Turn (0=white 1=black)
  2-  7 White king position (2-4=letter, 5-7=number)
  8- 13 Black king position (8-10=letter, 11-13=number)
 14- 75 Which squares contain pieces (skipping the 2 king squares, so only 62)
        Ordered a1-h1,a2-h2,(...)
 76-105 Which color owns the square with their piece (0=white, 1=black)
        If there's LESS than 30 pieces (apart from kings), this area is
        smaller
106-end Square data

Square data has the following system:
Every square gets assigned a number which determines piece. Number is:
0 Queen
1 Rook
2 Bishop
3 Knight
4 Pawn OR allowed-castle rook depending on square
5 Pawn subject to potential enpassant

The first bits (max 13) is the potential enpassant slots from A-H, determined
from data of 1 + 14-105 for which of the squares has a piece, and which color
owns the piece and whose turn it is. For example, if turn is White (bit 1 is
0), all pieces on row 5 which is Black owned (determined from 14-105 metadata)
and has at least 1 adjacant (on the same row) square owned by White, is
explained in A-H order. A base 6 number is used which is converted to binary
for the storage. On reading, it's converted and read A-H according to the
numbers above (4 is obviously pawn in this case).
The second amount of bits takes care of the 1st and 8th row (not corners!)
in b1-g1,b8-g8. These only take up 2 bits since 4 or 5 is never needed
(pawn on 1st or 8th is invalid).
The third amount of bits takes care of the rest of the board, in the following
order: a1,h1,a2-h2,a3-h3,a4-h4,a5-h5,a6-h6,a7-h7,a8,h8 (skipping the
"enpassant" slots), in base 5 (since piece ID 0-4 are the only used) converted
to binary.

Best case: 13 bits (bit 1 for turn, bit 2-12 for kings)
Worst case: 177 bits
* 32 pieces with kings
* 5 viable enpassant pawns
* No pieces at 1st or 8th row (except if kings+rooks are at initial posions
whether or not they can castle)
In this case, the space as following:
  1   bit   turn
+ 12  bits  king positions
+ 62  bits  which squares have pieces
+ 30  bits  color of pieces
+ 13  bits  enpassant area
+ 0   bits  initial rows area
+ 59  bits  the rest of the area
= 177 bits  total

Potential optimizations but not really worth it IMO:
* Decrease average by make corners 2 bits as well if kings aren't at e1/e8
* Alter reading order to read b1-g1,b8-g8 last - decreases worst case to
  176 bits if the "which squares have pieces" area is cut off if 30 existing
  pieces has been defined already. Would actually save 8 bits on file but meh

166 bit

• 1 bit: đến lượt của ai?
• 2bit: tùy chọn castling nào được mở? (NB khi đọc kỹ câu hỏi, chỉ cần ghi lại các tùy chọn ném cho người chơi có lượt chơi).
• lg 6 ~= 2.585bit: tùy chọn en passant nào đang mở? (Xem câu trả lời khác của tôi)
• lg sum_{i=1}^{16} sum_{j=1}^{16} 64! / (i! j! (64-i-j)! = lg 3629590441720924477681996172 ~= 91.552 bit: hình vuông nào được chiếm bởi người đàn ông màu nào?
• Tại lg 451366131803622235200 ~= 68.613các bit tồi tệ nhất để chỉ ra người đàn ông nào và theo thứ tự nào (xem bên dưới)

Sử dụng mã hóa số học (vì ở mỗi bước chúng tôi áp dụng phân phối đồng đều), chúng tôi có thể đạt được ceil(3 + 2.585 + 91.552 + 68.613) = 166các bit.

Mã hóa cho nam giới: cho rằng chúng ta biết có bao nhiêu người đàn ông có màu sắc nhất định, chúng ta có thể dễ dàng liệt kê tất cả các phân phối / nhiều người có thể có (ví dụ với 5 người đàn ông, chúng ta có thể có một Vua, một Nữ hoàng, hai Rooks và một Cầm đồ) và sau đó chúng ta có thể xem xét tất cả các hoán vị có thể có của mỗi phân phối.

Tuy nhiên, chúng ta có thể làm tốt hơn nữa bằng cách tính đến sự phụ thuộc lẫn nhau. Tôi chỉ làm điều này ở mức độ rất cơ bản: có bao nhiêu chương trình khuyến mãi có thể? Một con tốt chỉ có thể trở thành "thông qua" và có thể quảng bá theo ba cách: nó bắt và do đó di chuyển vào một cột khác; hoặc cầm đồ đối nghịch của nó và do đó di chuyển vào một cột khác; hoặc cầm đồ đối nghịch của nó bị bắt. Do đó, một màu trắng có khả năng tạo ra hai con tốt cho màu trắng và một màu đen.

Chúng tôi có thể xây dựng một bảng một phần của giới hạn trên về các chương trình khuyến mãi:

(Max white promos, max black promos):

           White men
           16      15      14      13
Black men
       16  (0, 0)  (1, 2)  (2, 4)  (3, 6)
       15  (2, 1)  (3, 3)  (4, 5)  (5, 7)
       14  (4, 2)  (5, 4)  (6, 6)  (7, 8)
       13  (6, 3)  (7, 5)  (8, 7)  (8, 8)

Chúng tôi cũng có thể tính toán số lượng hoán vị cho rằng một người chơi có Nđàn ông và không nhiều hơn những Pcon tốt được thăng cấp:

Num of permutations (cumulative):
    max promotions: 0              1              2              3              4              5              6              7              8
 1 men              1              1              1              1              1              1              1              1              1
 2 men             10             10             10             10             10             10             10             10             10
 3 men             72             75             75             75             75             75             75             75             75
 4 men            436            496            500            500            500            500            500            500            500
 5 men           2305           3025           3120           3125           3125           3125           3125           3125           3125
 6 men          10746          17106          18606          18744          18750          18750          18750          18750          18750
 7 men          44170          88795         106260         109179         109368         109375         109375         109375         109375
 8 men         159832         415360         575240         619200         624744         624992         625000         625000         625000
 9 men         509841        1721961        2884815        3398769        3504735        3515301        3515616        3515625        3515625
10 men        1447200        6258240       13063080       17697780       19260180       19510320       19530840       19531230       19531240
11 men        3706065       20021265       52183395       85007571      102173181      106786581      107369592      107409918      107410281
12 men        8678340       57101220      183088620      364510476      509818716      570620556      584017632      585352152      585430164
13 men       18725850      146911050      567991710     1373480394     2297173164     2902775304     3107861328     3143928216     3146014014
14 men       36756720      339459120     1555313760     4501448952     9021804792    13325103792    15664512864    16283899632    16360920576
15 men       60810750      660810150     3555401850    12144582450    28834205400    50030580600    66655789200    73588394880    74576231730
16 men       64864800      843242400     5383778400    21810428640    61514893440   126475789440   196178062080   240747386880   253686232800

Kết hợp cả hai, chúng ta có thể nhận được số bit cần thiết để chỉ định cả hai hoán vị cho số lượng người ở cả hai bên:

           White men
           16      15      14      13      <13
Black men
       16  51.902  61.626  66.375  67.868  <=67.009
       15  --      67.000  68.613  67.534  <=65.243
       14  --      --      67.734  65.480  <=63.055
       13  --      --      --      63.102  <=60.676

Nếu không có trong phần này của bảng, chúng ta có thể giả sử rằng cả hai bên có tới 8 chương trình khuyến mãi và chúng tôi vẫn làm tốt hơn trường hợp xấu nhất, đó là 68,613 bit khi một người có 14 người và bên kia có 15 người.

Lưu ý rằng đây vẫn còn là một chặng đường dài để trở thành một đại diện hoàn hảo, bởi vì nó cho phép nhiều vị trí bất hợp pháp.

Mã để tính bảng hoán vị:

import java.util.*;

public class ChessCombinatorics {
    public static void main(String[] args) {
        long[] f = new long[17];
        f[0] = 1;
        for (int i = 1; i < 17; i++) f[i] = i * f[i-1];

        // Indexed by num promotions, then total num men.
        long[][] distribs = new long[9][17];
        long[][] perms = new long[9][17];

        for (int promotedPawns = 0; promotedPawns < 9; promotedPawns++) {
            Map<Integer, Map<String, Long>> numCases = new HashMap<Integer, Map<String, Long>>();
            for (int i = 1; i < 17; i++) numCases.put(i, new HashMap<String, Long>());

            for (int extraQ = 0; extraQ <= promotedPawns; extraQ++) {
                for (int extraR = 0; extraR + extraQ <= promotedPawns; extraR++) {
                    for (int extraN = 0; extraN + extraR + extraQ <= promotedPawns; extraN++) {
                        int extraB = promotedPawns - extraN - extraR - extraQ;
                        int unpromotedPawns = 8 - promotedPawns;

                        // Promoted pawns should only count towards their new type if the existing ones are alive.
                        // Otherwise we double-count some cases.
                        int minQ, maxQ, minR, maxR, minN, maxN, minB, maxB;
                        if (extraQ == 0) {minQ = 0; maxQ = 1;} else {minQ = maxQ = 1 + extraQ;}
                        if (extraR == 0) {minR = 0; maxR = 2;} else {minR = maxR = 2 + extraR;}
                        if (extraN == 0) {minN = 0; maxN = 2;} else {minN = maxN = 2 + extraN;}
                        if (extraB == 0) {minB = 0; maxB = 2;} else {minB = maxB = 2 + extraB;}

                        for (int numQ = minQ; numQ <= maxQ; numQ++) {
                            for (int numR = minR; numR <= maxR; numR++) {
                                for (int numN = minN; numN <= maxN; numN++) {
                                    for (int numB = minB; numB <= maxB; numB++) {
                                        for (int numP = 0; numP <= unpromotedPawns; numP++) {
                                            // The number of possibilities at these values is (numK + numQ + numR + numN + numB + numP)! / (numK! numQ! numR! numN! numB! numP!)
                                            numCases.get(1+numQ+numR+numN+numB+numP).put(numQ+","+numR+","+numN+","+numB+","+numP, f[1 + numQ + numR + numN + numB + numP] / f[numQ] / f[numR] / f[numN] / f[numB] / f[numP]);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            for (int numMen = 1; numMen < 17; numMen++) {
                distribs[promotedPawns][numMen] = numCases.get(numMen).size();
                if (distribs[promotedPawns][numMen] > 0) {
                    for (Long l : numCases.get(numMen).values()) perms[promotedPawns][numMen] += l;
                }
            }
        }

        System.out.println("Num of permutations (cumulative):");
        System.out.println("    max promotions: 0              1              2              3              4              5              6              7              8");
        for (int numMen = 1; numMen < 17; numMen++) {
            System.out.print(String.format("%2d men", numMen));
            long cumul = 0;
            for (int promotedPawns = 0; promotedPawns < 9; promotedPawns++) {
                cumul += perms[promotedPawns][numMen];
                System.out.print(String.format("%15d", cumul));
            }
            System.out.println();
        }

        System.out.println("Entropy of permutations:");
        System.out.println("    max promotions: 0              1              2              3              4              5              6              7              8");
        for (int numMen = 1; numMen < 17; numMen++) {
            System.out.print(String.format("%2d men", numMen));
            long cumul = 0;
            for (int promotedPawns = 0; promotedPawns < 9; promotedPawns++) {
                cumul += perms[promotedPawns][numMen];
                System.out.print(String.format("  %6.3f", Math.log(cumul) / Math.log(2)));
            }
            System.out.println();
        }

    }
}

178 bit (174 tại một nhúm!) Trường hợp xấu nhất

Xin chào, chỉ cần quay lại với tiền mã hóa, điều mà tôi chưa thực sự làm được từ thời đại học. Tôi thấy trang web này và nghĩ rằng nó trông thú vị. Tôi đã thực hiện một kiểm tra trị liệu nhỏ và nó xuất hiện ít nhất 146 bit cho một thuật toán hoàn hảo, có thể là một vài điều nữa (tôi sẽ giải thích trong các bình luận khi tôi có thời gian.)

Dù sao, đây là cách tôi cấu trúc dữ liệu. Khái niệm cơ bản có đến 178 bitcoin, nhưng với một số trò đùa tinh nghịch, nó có thể giảm xuống còn 174 (đó là 21 3/4 byte). 175 dễ dàng hơn để lập trình, dễ đọc hơn cho con người và vẫn trong phạm vi 22 byte.

A) Vị trí của cả hai vị vua: mỗi vị 6 bit cho 12 BITS trắng và đen

B) Trong số 62 hình vuông còn lại, chiếm chỗ nào? Một ma trận gồm 62 BITS

C) Đến lượt của ai? 1 CHÚT

TOTAL SO FAR: 75 BITS

D) En Passant. Nếu đến lượt của người da trắng di chuyển, tối đa 5 con tốt màu đen có thể trông giống như họ có thể bị bắt En Passant. Con tốt màu đen phải ở hàng 5 (từ dưới lên trên bắt đầu từ số 0) và có một con tốt màu trắng bên cạnh. Một tình huống với số lần chụp tối đa có thể xảy ra như thế này:

BẠC BẠC

Nếu có 6 con tốt màu đen trên hàng 5, màu trắng sẽ chỉ có 2 hình vuông để đứng và chỉ có thể đe dọa 4 con tốt màu đen, do đó không thể có nhiều hơn 5 con tốt màu đen bị đe dọa từ En passant cùng một lúc. Vì vậy, chúng ta cần số 1 ​​đến 5 chỉ ra con nào trong số (tối đa 5) con tốt trên hàng 5 có con tốt (trong trường hợp này là màu trắng) bên cạnh nó được nâng lên 2 ô vuông ở lượt cuối ( hoặc 0 nếu không có con tốt trong tình huống này đã được di chuyển theo cách này ở lượt cuối cùng.)

E) Trong số tối đa 30 ô vuông chiếm đóng (không bao gồm các vị vua) chúng chứa gì?

Có 10 khả năng, mỗi khả năng được biểu thị bằng một số thập phân.

Các bit quan trọng nhất đại diện cho màu sắc.

Do đó số chẵn có màu trắng, số lẻ có màu đen.

Trắng đen

Cầm đồ 0/1 (hoặc Rook được phép vào lâu đài *)

Hiệp sĩ 2/3

Giám mục 4/5

Rook 6/7

Nữ hoàng 8/9

* Một rook được phép vào lâu đài (và do đó chưa bao giờ được di chuyển từ hàng đầu tiên hoặc hàng cuối cùng) được biểu thị bằng 0 hoặc 1 thay vì 6 hoặc 7. Nó không thể bị nhầm lẫn với một con tốt, bởi vì những con tốt không thể tìm thấy ở đầu tiên hoặc hàng cuối cùng.

Điều này cung cấp một số thập phân lên đến 30 chữ số, chúng ta có thể nhân với 6 và sau đó thêm mã cho En passant. Số kết quả sẽ phù hợp với 103 bit, khi được thêm vào 75 được đề cập ở trên là 103 + 75 = 178 bit . Trên thực tế, nếu chúng ta chỉ đơn giản nhân với 10 thay vì 6, điều đó sẽ không khác biệt gì với số bit được sử dụng và việc giải mã dễ dàng hơn.

Đây chỉ là 2 bit hơn 22 byte. Tuy nhiên, chúng ta có thể đẩy nó xuống còn 174 bit, như được giải thích dưới đây.

Nếu không có mảnh nào bị bắt, thì việc cầm đồ không thể được thăng cấp là điều không thể .

Bằng chứng là như sau. Hãy tưởng tượng màu trắng bị ám ảnh với việc thúc đẩy cầm đồ của anh ấy (ví dụ) cột E, ngay từ khi bắt đầu trò chơi. Có một con tốt màu đen đối diện với con tốt này đang cản đường. Do đó, để thúc đẩy sự cầm đồ này, một trong những điều sau đây phải xảy ra:

1) Con tốt màu đen bị bắt.

2) Con tốt màu đen bắt được một mảnh khác và do đó di chuyển ra khỏi đường đi.

3) con tốt trắng bắt một con tốt trên một cột liền kề như cột D.

4) con tốt màu trắng đi qua (hoặc được truyền qua) một con tốt màu đen trên cột liền kề và sau đó chụp một mảnh trên cùng cột liền kề đó, làm cho con tốt màu trắng thay đổi cột.

Trường hợp 4 là thú vị nhất, bởi vì nó không chỉ là con tốt trắng bắt đầu trên cột E mà bây giờ có một con đường rõ ràng để quảng bá. Con tốt màu đen trên cột vẫn còn trên cột E cũng có thể thúc đẩy. Do đó, một lần chụp có thể dọn đường cho một con tốt của mỗi màu để phát huy.

Dù sao, thực tế là không có con tốt nào có thể quảng bá cho đến khi một mảnh được chụp có nghĩa là chúng ta không phải lưu trữ mảnh thứ 30. Chúng tôi có thể giải quyết nó bằng cách loại bỏ (hoặc bằng phép trừ, bởi vì bộ mã mảnh hoàn chỉnh khi bắt đầu trò chơi luôn cộng với số tiền tương tự = 80.) Một điểm nhỏ là chúng tôi phải đảm bảo rằng các ô vuông có các rooks đứng ở đầu trò chơi là một trong số những người được quét đầu tiên (bởi vì nếu họ là người cuối cùng, chúng tôi sẽ không biết liệu rook có thể lâu đài hay không.) Điều này được thực hiện dễ dàng bằng cách quét hàng 0 và sau đó hàng 7 đến 1: For r = 8 đến 1 hàng quét [r mod 8].

Vì vậy, ma trận các bit trong (B) sẽ cho chúng ta biết có bao nhiêu phần (không bao gồm các vị vua.) Nếu có đủ 30, bỏ qua phần cuối cùng khi mã hóa, bộ giải mã sẽ tìm ra nó là gì. Bây giờ chúng tôi có một số thập phân lên đến 29 chữ số, chúng tôi nhân với 6 và thêm vào mã En Passant. Số kết quả sẽ chỉ nén thành 99 bit, cho tổng số 99 + 75 = 174 bit.

Như một ví dụ Đây là một vị trí thực tế. White vừa mới thực hiện bước đi đầu tiên (cầm đồ của nhà vua tiên tiến) và đến lượt Black `.

rnbqkbnr
pppppppp


    P

PPPP PPP
RNBQKBNR

A) Vị trí của các vị vua (Trắng / Đen theo bát phân, 12 bit ): 03 73 = 000011 111011

B) Những hình vuông nào bị chiếm đóng? Bắt đầu với hàng 0 (hàng dưới cùng) sau đó tất cả các hàng khác từ trên xuống dưới, bỏ qua các vị vua:

1111 111

1111 111
11111111
00000000
00000000
00001000
00000000
11110111 

C) Lượt của Black: Turn Bit = 1

D) En Passant. Không có con tốt màu trắng bên cạnh một con tốt màu đen, do đó không có con tốt nào có thể bị bắt (mặc dù con tốt này đã tiến lên bước cuối cùng) nên D = 0. Nếu, thay vì chỉ xem xét những con tốt có một con tốt thù địch bên cạnh chúng, chúng ta xem xét tất cả những con tốt không có phần thân thiện bên cạnh chúng ở cả hai bên, thì D sẽ là 1, vì có một con tốt như vậy trong tình huống này, và đặc biệt là cầm đồ đã thực sự di chuyển trong lượt cuối cùng.

E) Một lần nữa, hàng dưới cùng trước, sau đó tất cả các hàng khác từ trên xuống dưới, bỏ qua các vị vua và với bốn tân binh không được gọi là 0 hoặc 1 (số thường dành cho cầm đồ.)

RNBQ BNR =   0248 420
rnbq bnr =   1359 531
pppppppp =   11111111
PPPPPPPP = (0)0000000

Chữ số thứ 30 (trong ngoặc) có thể được loại bỏ.

Mặc dù không rõ ràng ở đây, nhưng con tốt mà Trắng đã tiến lên thực sự nằm ở một đầu của danh sách những con tốt, bởi vì chúng tôi quét từng hàng.

Bây giờ dữ liệu của chúng tôi trông như thế này, với 29 mã cho nội dung hình vuông, cộng với mã En Passant:

 (0 discarded) 0000000 11111111 1359531 0248420 (0 en passant)

Tốt nhất là quét từ phải sang trái khi giải mã và từ trái sang phải (thứ tự ngược lại) khi mã hóa. Điều này có nghĩa là khi có ít mảnh hơn, chúng ta sẽ có số lượng nhỏ hơn, trong khi vẫn giữ được sự thống nhất tối đa (nghĩa là chúng ta muốn khoảng trống / số 0 đứng đầu, không theo dõi, để cho phép nén các bảng chiếm dụng thưa thớt.) Khi chúng ta chỉ có 2 vị vua trên bảng, chúng ta sẽ có 75 bit được đề cập ở trên, cộng với 3 bit để lưu trữ dữ liệu en passant = 78 bit trong trường hợp tốt nhất. Mỗi phần bổ sung có dưới 3,5 bit (2 phần có thể được lưu trữ trong 7 bit, vì 100 <128.)

Có một vấn đề thực tế là số nguyên 99 bit quá lớn để phù hợp với biến số nguyên 64 bit, điều đó có nghĩa là nhiều ngôn ngữ lập trình không cung cấp hỗ trợ cho nó (bạn không thể chuyển đổi một chuỗi đại diện cho 29-30 chữ số số thành một số nguyên.) Là một cách dễ dàng để mã hóa cho 22 byte, chúng ta có thể chia một số 30 chữ số (mã 29 mảnh + mã enant) thành hai số có 15 chữ số, mỗi số sẽ khớp với 50 bit mỗi số (tổng cộng 100 bit cộng với 75 được đề cập ở trên làm cho 175 bit trường hợp xấu nhất.)

Để nén tối đa, như đã nêu ở trên, 29 chữ số thập phân cộng với mã En Passant (6 giá trị có thể), sẽ chỉ vừa với 99 bit (với tổng số 174 bit) nhưng không có sự hỗ trợ từ ngôn ngữ cho các số nguyên có kích thước này. phức tạp để lập trình. Có thể dễ dàng hơn để tách 29 bit màu và làm việc với mã loại mảnh (5 khả năng) và mã En passant (6 khả năng) tách biệt với màu sắc (70 bit, gần như phù hợp với biến 64 bit.)

Đây là một giải pháp đầy đủ, trường hợp xấu nhất thực tế là 181 bit

Trọng tâm ở đây là một chương trình đơn giản bạn có thể dễ dàng hiểu

Đầu vào là FEN, ở đây là vị trí mở, nó có sáu trường (5 & 6 bị bỏ qua):

rnbqkbnr / pppppppp / 8/8/8/8 / PPPPPPPP / RNBQKBNR w KQkq - 0 1

Trường đầu tiên (vị trí mảnh) được phân tích cú pháp

perl -pe 's/\d/"_"x$&/ge;s/\s.*//;s|/||g'

Để sản xuất:

rnbqkbnrpppppppp________________________________PPPPPPPPRNBQKBNR

Trường một: mã hóa vị trí của các vị vua (12 bit):

printf("%b",index('k',$_))
printf("%b",index('K',$_))

Trường hai: mã hóa các phần (tối đa 5 bit mỗi phần):

s/_/0/g     Blank
s/P/100/g   From here, as normal chess meaning
s/p/101/g
s/Q/11000/g
s/q/11001/g
s/R/11010/g
s/r/11011/g
s/B/11100/g
s/b/11101/g
s/N/11110/g
s/n/11111/g
s/K//
s/k//

Trường ba: màu hoạt động (1 bit)

s/w/0/
s/b/1/

Trường bốn: tính khả dụng của castling (4 bit)

m/K/?1:0
m/k/?1:0
m/Q/?1:0
m/q/?1:0

• FIQ cho thấy lĩnh vực này có thể được loại bỏ hoàn toàn.

Trường năm: en passant (0 hoặc 3 bit)

printf("%b",ord($1)-ord("a")) unless m/-/
// The EP's rank is 3 or 6 based on active color, only need to encode file

Trường hợp xấu nhất ngây thơ 200 bit

• Hai vị trí vua - 12 bit
• Bảng
  • QRRBBNN QQQQQQQQ - 75 bit
  • qrrbbnn qqqqqqqq - 75 bit
  • Hình vuông trống - 30 bit
• Màu hoạt động - 1 bit
• Castling - 4 bit
• En Passant - 3 bit

Trường hợp xấu nhất

Mỗi người chơi không thể quảng bá tất cả các con tốt mà không chiếm được các mảnh khác . Đây là hiệu ứng entropy của chụp mảnh:

• PpR(3 + 3 + 5 = 11 bit) => Qq_(5 + 5 + 1 = 11 bit)
• PPpp(3 + 3 + 3 + 3 = 12 bit) => QQq_(5 + 5 + 5 + 1 = 16 bit)

Vì vậy, thực sự hội đồng quản trị tồi tệ nhất là:

• QRRBBNN QQQQQQQQ - 75 bit
• qrrbbnn qqqq - 55 bit
• Hình vuông trống - 34 bit

Trường hợp xấu nhất là để thúc đẩy tất cả các mảnh hơn là để lại cầm đồ cho en passant.

TỔNG TRƯỜNG HỢP CÔNG VIỆC THỰC TẾ VỚI MÃ SỐ 12 + 75 + 55 + 34 + 1 + 4 = 181 bit

FIQ cho thấy hai cải tiến cho sơ đồ đơn giản này, nhưng chúng khó mã hóa hơn:

• Xóa bit 2 khỏi mã hóa mảnh trên hàng 1 và 8 vì các con tốt không thể đến đó (tiết kiệm tối đa 16 bit)
• Sử dụng những con tốt để mã hóa các tân binh có thể đúc được (tiết kiệm 4 bit)

Mã duy nhất còn lại không được hiển thị trong câu trả lời này (cho ngắn gọn) là: phá vỡ FEN đầu vào trong các trường ( split /\s/) và gán biến.

Tổng dữ liệu cần 33 byte

(Nhờ có ai đó trong các nhận xét mà tôi nhận ra điều này không hiệu quả đối với khuyến mãi cầm đồ. Sẽ cập nhật điều này khi tôi có thể giải quyết nó)

đối với byte đầu tiên, chúng tôi sử dụng năm bit:

• bit đầu tiên: lượt của người chơi, 1 = trắng
• bit thứ hai: lâu đài vua đen, 1 = lâu đài can
• bit thứ ba: lâu đài bên nữ hoàng đen, 1 = lâu đài can
• bit thứ tư: lâu đài trắng bên vua, 1 = lâu đài can
• bit thứ năm: lâu đài bên nữ hoàng trắng, 1 = lâu đài can

32 byte tiếp theo được sử dụng để đại diện cho mỗi quân cờ, theo thứ tự được xác định trước

• 3-bit: đại diện cho hàng
• 3-bit: đại diện cho cột
• 1-bit: đại diện cho en-passant, 1 = can en-passant
• 1 bit: nếu bit "có thể en-passant" là 1: cho biết bên nào, 0 = bên trái
  đại diện cho dù nó đã bị bắt. 0 = không bị bắt
  (Nếu nó có thể vượt qua thì chắc chắn nó không bị bắt)

Một số mã C để thể hiện ý tưởng này (không thực sự hoạt động)

int main() {
    char b, c[32], i;

    //decode:

    FILE *p=fopen("/path/to/file.csv","r");
    fscanf(p,"%d,",&b);
    for(i=0;i<31;i++) fscanf(p,"%d,",&c[i]);
    fscanf(p,"%d",&c[31]);
    fclose(p);
    if(b&16) /* white's turn */
    else /* black's turn */
    if(b&8) /* black king side can castle */
    if(b&4) /* black queen side can castle */
    if(b&2) /* white king side can castle */
    if(b&1) /* white queen side can castle */

    for(i=0;i<32;i++) {
        int row, column;
        row=c[i]&7;
        column=c[i]&56;
        if(c[i]&64 && isPawn(c[i])) { //can en-passant
            if(c[i]&128) //can en-passant to the right
            else //can en-passant to the left
        }
        if(!(c[i]&64)) {
            if(c[i]&128) //captured
            else //not captured
        }
    }

    //encode:

    p=fopen("/path/to/file.csv","w");

    if(b&16) b&=239;
    else b|=16;
    if(black_king_side_cannot_castle) b&=247;
    if(black_queen_side_cannot_castle) b&=251;
    if(white_king_side_cannot_castle) b&=253;
    if(white_queen_side_cannot_castle) b&=254;

    for(i=0;i<32;i++) {
        c[i]=row;
        c[i]+=column*8;
        if(isPawn(c[i]) && can_en_Passant) {
            c[i]|=64;
            if(can_en_Passant_left) c[i]&=127;
            else c[i]|=128;
        }
        if(!(c[i]&64)) {
            if(isCaptured(c[i])) c[i]|=128;
            else c[i]&=127;
        }
    }
    fprintf(p,"%d,",b);
    for(i=0;i<31;i++) fprintf(p,"%d,",c[i]);
    fprintf(p,"%d",c[31]);
    fclose(p);
    return 0;
}

256 242 bit

Đây là một thuật toán nén cơ bản có thể được cải thiện vì nó không loại trừ một số vị trí bất hợp pháp khỏi bị đại diện.

Bảng bắt đầu với 5 bit thông tin tiêu đề, như sau:

0 1 1 1 1
---------
1 2 3 4 5

1: Turn (black = 1, white = 0)
2: Black can castle queen-side
3: Black can castle king-side
4: White can castle queen-side
5: White can castle king-side

Sau đó, một chuỗi 12 bit đại diện cho vị trí của các vị vua.

0 0 0 1 0 0 1 1 1 1 0 0
-----------------------
0 0 0 0 0 0 0 0 0 1 1 1
1 2 3 4 5 6 7 8 9 0 1 2

01 - 03: white king's rank
04 - 06: white king's file
07 - 09: white king's rank
10 - 12: white king's file

Sau đó, một số 64 chữ số khổng lồ ở cơ sở 11, sau đó được nhân với 9 để thêm một chữ số khác ở cuối đại diện cho trạng thái của en-passant. Mỗi chữ số trong cơ sở 11 đại diện cho một hình vuông trên bảng, với các giá trị có thể sau:

0: empty

1: white pawn
2: white knight
3: white bishop
4: white rook
5: white queen

For the black equivalent of each white piece, add 5.

Và các chữ số trong cơ sở 9:

0: no en-passant possible
1 - 8: en-passant on rank 1 - 8

11 ⁶⁴ × 9 là khoảng 2 ^224,57 , cần 225 bit để mã hóa. Cộng với 17 bit tiêu đề ở trên cùng, là tổng số 242 bit.

Cảm ơn ugoren cho những cải tiến.

? bit

(≥ 217 trường hợp xấu nhất, 17 trường hợp tốt nhất, 179 cho ban đầu)

Mô tả mã hóa

Siêu dữ liệu bổ sung bao gồm lượt của nó (một bit) và castling (bốn bit, nghĩa là lâu đài trắng có thể ở bên cạnh các vị vua? Về phía nữ hoàng? Và tương tự cho màu đen).

Đối với vị trí bảng, chúng tôi mã hóa nó như một tập hợp các phần hoạt động. Chà, thực ra, chúng tôi đảm bảo liệt kê các mảnh theo thứ tự cụ thể vì những lý do mà tôi sẽ giải thích một chút. Đối với mỗi phần, chúng tôi lưu trữ màu của nó (một bit), loại của nó (ba bit để bao gồm 6 loại, cộng thêm một loại cho "cầm đồ có thể được thực hiện bởi en passant"), cũng như vị trí của nó.

Đây là phần thú vị: để mã hóa vị trí của một mảnh, thay vì lưu trữ dưới dạng tọa độ, chúng tôi lưu trữ khoảng cách tương đối của nó từ mảnh cuối cùng khi liệt kê các mảnh theo thứ tự từ trái sang phải, từ trên xuống dưới (ví dụ: A8 , B8, ..., G1, H1). Ngoài ra, chúng tôi lưu trữ khoảng cách dưới dạng số có độ dài thay đổi, sử dụng 1để có nghĩa là phần này nằm ngay bên cạnh phần trước, 0xxđể bỏ qua 1-3 phần, 000xxxđể bỏ qua 4-10 phần, 000000xxxxtrong 11-25, 0000000000xxxxxcho 26-56 và cuối cùng 000000000000000xxxcho 57-62.

Ví dụ

Tôi đã thực hiện một ý chính của một số vị trí được mã hóa bằng mã hóa này và chú thích vị trí cho vị trí ban đầu với một số nhận xét.

Tôi không biết cách phân tích kích thước bit trong trường hợp xấu nhất, nhưng đi theo các ví dụ trong ý chính, tôi tin rằng thuật toán ít nhất phải hiệu quả.

Thực hiện bộ giải mã

Dưới đây là bộ giải mã nhanh và bẩn cho mã hóa này (lấy đầu vào là dữ liệu nhị phân được mã hóa trong văn bản, như trong ví dụ chú thích ở trên và bỏ qua những thứ không '0' hoặc '1'). Sản xuất một bàn cờ unicode để stdout.

#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>

char buf[1024];
int wi = 0, ri = 0;

int read_n(int n) {
  int res = 0;
  for (int i = 0; i < n; i++) {
    res = res << 1 | (buf[ri++] == '1');
  }
  return res;
}

int read_varnum() {
  int v, c = 0;

  for (int i = 1; i <= 5; i++) {
    v = read_n(i);
    if (v != 0) return c + v;
    c += (1 << i) - 1;
  }

  assert(false); /* Shouldn't happen */
}

char *piece_to_str(int piece, int color) {       /* ↓ pawn that may be taken with en passant */
  char *pieces[] = { "♙", "♘", "♗", "♖", "♕", "♔", "♙",
                     "♟", "♞", "♝", "♜", "♛", "♚", "♟" };
  return pieces[color * 7 + piece];
}

int main(void) {
  int ch;
  while (ch = getchar(), ch != EOF) {
    if (ch == '0' || ch == '1') buf[wi++] = ch;
  }

  int board[64];
  memset(board, -1, 64 * sizeof(int));

  /* Read metadata */
  int is_white = read_n(1);
  int castling = read_n(4);

  /* Read the board state */
  int bi = -1;
  while (ri != wi) {
    int color = read_n(1);
    int kind  = read_n(3);
    int delta = read_varnum();
    board[bi + delta] = color << 8 | kind;
    bi += delta;
  }

  /* Print metadata */
  printf("  Current turn: %s's turn to play.\n", is_white? "white" : "black");
  printf("  Castling: White may castle? %s %s\n",
         castling & 0x8? "left" : "", castling & 0x4? "right" : "");
  printf("            Black may castle? %s %s\n",
         castling & 0x2? "left" : "", castling & 0x1? "right" : "");
  printf("\n");

  /* Print the board out */
  printf("+");
  for (int x = 0; x < 8; x++) printf("--");
  printf("-+\n");

  for (int y = 0; y < 8; y++) {
    printf("|");
    for (int x = 0; x < 8; x++) {
      int piece = board[y*8 + x],
          color = piece >> 8,
          kind  = piece & 0xFF;

      if (piece == -1) printf("  ");
      else printf(" %s", piece_to_str(kind, color));
    }
    printf(" |\n");
  }

  printf("+");
  for (int x = 0; x < 8; x++) printf("--");
  printf("-+\n");

  return 0;
}

Tối đa: 184 bit, Tối thiểu: 75 bit

Tôi đã được truyền cảm hứng từ mã hóa Huffman của @ AdamSpeight cho các mảnh để thử chế tạo sơ đồ của riêng tôi. Tôi nghi ngờ điều này sẽ thắng, nhưng nó có giới hạn có thể tính toán được.

Sơ đồ này xử lý các quân cờ như thể có 11 loại quân cờ khác nhau. Tôi đã theo thuật toán mã hóa Huffman để nhóm các lớp này theo tần số và loại thực của chúng để tạo ra các bảng mã sau:

 Piece Class                | Frequency Per Team | Encoding
============================+====================+==========
 Pawn, normal               | 0 - 8              | 0
 Pawn, jumped two last turn | 0 - 1              | 1111
 Knight                     | 0 - 2              | 1000
 Bishop                     | 0 - 2              | 1001
 Queen-side rook, unmoved   | 0 - 1              | 10100
 Queen-side rook, moved     | 0 - 1              | 10101
 King-side rook, unmoved    | 0 - 1              | 10110
 King-side rook, moved      | 0 - 1              | 10111
 Queen                      | 0 - 1              | 1110
 King, unmoved              | 0 - 1              | 1100
 King, moved                | 0 - 1              | 1101

Mã của mỗi mảnh có thể được đi trước bởi hai bit để hiển thị cho đội đó thuộc về đội nào ( 10đối với Trắng, 11đối với Đen). 0có thể được sử dụng để mã hóa các khoảng trống. Những ý tưởng này cho phép chúng tôi xây dựng một mã hóa vuông cho cả bảng bằng bất kỳ thủ tục nào chúng tôi muốn. Tôi sẽ giả sử thứ tự lặp a1, b1, c1, ... f8, g8, h8. Điều này có nghĩa là chỉ liệt kê các mã này như được hiển thị ở trên sẽ mã hóa tất cả thông tin ngoại trừ lượt của nó. Một công cụ cờ vua rất đơn giản có thể sử dụng các "lớp" cho những con tốt, tân binh và vua để xác định xem việc ném và en passant có hợp pháp hay không. Hơn nữa, chương trình này dễ dàng xử lý các chương trình khuyến mãi cầm đồ. Nếu người chơi khuyến khích một con tốt cho một tân binh, có thể sử dụng mã của vua hoặc nữ hoàng miễn là biến thể "di chuyển" được chọn.

Ngoại trừ các vị trí bệnh lý mà tôi không nghĩ có thể xảy ra, trường hợp xấu nhất cho mã hóa này là khi tất cả các mảnh vẫn còn trên bảng và người chơi trước đó di chuyển một con tốt về phía trước hai khoảng trống. Ví dụ, bảng dưới đây mã hóa 1. e4:

1101010010100010100110111010110010100110100010101101001001001100100100100000000000000101111000000000000000000011011011011011011011011011101001110001110011111101111001110011110001110110
===========================================================================
                              Black's move
1110100 111000 111001 111110 111100 111001 111000 1110110 | r n b q k b n r
    110    110    110    110    110    110    110     110 | p p p p p p p p
      0      0      0      0      0      0      0       0 | . . . . . . . .
      0      0      0      0      0      0      0       0 | . . . . . . . .
      0      0      0      0 101111      0      0       0 | . . . . P . . .
      0      0      0      0      0      0      0       0 | . . . . . . . .
    100    100    100    110      0    100    100     100 | P P P P . P P P
1010100 101000 101001 101110 101100 101001 101000 1010110 | R N B Q K B N R

Điều này có nghĩa là mã hóa trong trường hợp xấu nhất có 184 bit: 1 để chỉ người chơi, 32 cho khoảng trống, 45 cho cầm đồ không di chuyển, 6 cho cầm đồ nhảy hai không gian, 24 cho các hiệp sĩ, 24 cho các giám mục, 28 cho các tân binh, 12 cho các nữ hoàng và 12 cho các vị vua.

Khi các mảnh được di chuyển và được chụp, kích thước của mã hóa sẽ giảm xuống. Kịch bản trường hợp tốt nhất được đại diện bởi hai vị vua một mình trên bảng: 1 bit để chỉ người chơi + 62 bit để chỉ ra các ô vuông trống + 12 bit để chỉ các vị vua cho độ dài tối thiểu 75 bit.

Tôi sẽ quay lại và chỉnh sửa phản hồi này với một số mã chứng minh mã hóa này hoạt động vào ngày hôm nay hoặc ngày mai. Hiện tại, tôi tò mò muốn xem người khác nghĩ gì về mã hóa này.

184 bit = 23 byte trường hợp xấu nhất và không quá phức tạp:

A. Hình vuông nào chiếm: 64 bit = 8 byte B. Màu nào cho <= 32 ô vuông bị chiếm: 32 bit = 4 byte Và hiện chỉ sử dụng <= 30 ô vuông được chiếm bởi những người không phải là vua: B. sử dụng PNBRQ được mã hóa trong cơ số 5, cho 5 ^ 30 khả năng; và 32 * 31 * 2 * 4 * 4 * 9 cho các vị trí vua, quyền tô màu, quyền trắng và đen, en vuông thụ động (trong số 8 khả năng cộng với không, thứ 9); con số này 5 ^ 30 * 32 * 31 * 2 * 4 * 4 * 9 = 266075134277343750000000000 = 2 ^ 87.782 phù hợp với 88 bit cho tổng số 64 + 32 + 88 = 184 bit cho toàn bộ mã hóa.

Điều này có thể giảm, ví dụ 32 * 31 * 2 * 4 * 4 * 9 = 285696 có thể giảm xuống 2 * (32 * 31 + 31 * 3 + 31 * 3 + 3 * 3) * 6 = 14244, bằng cách sử dụng thực tế nhiều nhất là 6 en ứng cử viên nạn nhân thụ động (bao gồm cả không có ai), và mã hóa quyền đúc và các vị trí vua trong cùng một tập hợp sử dụng quyền castling thực tế chỉ quan trọng khi vua trên quảng trường ban đầu. Điều này tiết kiệm 4 bit.

Tôi có lý do để tin rằng không thể đạt được 18 byte, tức là tổng số vị trí cờ hợp pháp vượt quá 2 ^ 144.

Lược đồ 160 bit của bạn rất khéo léo nhưng tôi nghĩ nó cần được đưa ra dưới dạng chương trình mã hóa / giải mã trước khi tôi hoàn toàn tự tin về nó.

Trường hợp xấu nhất 171 bit:

Tôi đã kết hợp một vài ý tưởng, cũng như một số suy nghĩ của riêng tôi.

Chúng ta sẽ bắt đầu với một bảng 64 bit. Mỗi bit đại diện cho một không gian chiếm trên bảng. Họ điền vào các hàng. Vì vậy, sự khởi đầu trông giống như:1111 1111 1111 1111 0000 0000 0000 0000 0000 0000 0000 0000 1111 1111 1111 1111

Bây giờ, mỗi phần sẽ được đại diện bởi 4 bit. Bit thứ 1: color ( 0=white, 1=black) Bit thứ 2-thứ 4: Một trong 8 loại.

0=king, 1=queen, 2=bishop0, 3=knight, 4=rook, 5=pawn0, 6=pawn1, 7=bishop1

Cuối cùng, chúng tôi sẽ bao gồm một chút chỉ định lần lượt. 0=white, 1=black.

4 bit * 32 miếng = 128 bit và tôi đã có 64 + 1 từ lượt và bảng. Điều đó mang lại tổng cộng 128 + 64 + 1 = 193 Tôi thậm chí chưa bắt đầu với en passant hoặc castling. Vượt quá giới hạn của tôi không có gì - thậm chí không đến lượt. Đây là nơi các thủ thuật bắt đầu.

Được rồi - bạn thấy những loại trên? Giám mục0 và Giám mục1? Cầm đồ0 và cầm đồ1? Những loại này được chỉ định, bởi vì chúng cho chúng ta biết một chút để chèn sau phần này. Vì vậy, Bishop0 có nghĩa là sau nó, sẽ có 0 - tức là phần tiếp theo có màu trắng. Giám mục1 cho chúng ta biết mảnh tiếp theo là màu đen, và pawn0 và pawn1 hoạt động như nhau. (Nếu mảnh này là mảnh cuối cùng được liệt kê, thì nó sẽ cho chúng ta biết về lượt tiếp theo thay thế).

Trường hợp xấu nhất của tôi liên quan đến tất cả các mảnh trên bảng, vì vậy với 16 con tốt và 4 giám mục, điều này giúp tôi tiết kiệm được 20 bit. Tôi xuống tới 173.

Đuợc. Đối với một bit khác trong trường hợp xấu nhất của tôi - một khi có 16 màu được mã hóa, chúng ta dừng mã hóa màu - vì chúng ta biết nó sẽ chuyển tiếp. Trường hợp xấu nhất của tôi bây giờ liên quan đến một mảnh màu trắng làm cho nó ở góc xa mà không bị bắt. Ở đó, tôi chỉ tiết kiệm được một chút. 172.

Bây giờ tôi sẽ thay đổi thứ tự mà tôi đặt tên cho các mảnh. Chúng tôi sẽ đặt tên cho chúng dọc theo các cột bắt đầu từ bên ngoài di chuyển vào. Bảng được đặt tên ở đầu sẽ giữ nguyên, nhưng khi tôi đặt các mảnh trên đó, tôi bắt đầu từ phía dưới bên phải và đi lên cột đó. Sau đó, tôi nhảy xuống phía dưới bên phải của màu đen, và đi lên cột đó. Tôi nhảy xuống ô không xác định phía dưới bên phải, và cứ thế - điều này có nghĩa là trường hợp xấu nhất của tôi lại là sự khởi đầu. Lý do của tôi phải làm với thủ thuật en passant của tôi, hai bit tiếp theo tôi bị mất và castling.

Bây giờ, để một con tốt được thăng cấp (như đã thảo luận về chiều dài), một mảnh phải được nắm bắt. Như vậy, khi chúng ta biết có 32 mảnh, chúng ta chỉ cần biểu thị 31 trong số chúng. Phần cuối cùng được xác định duy nhất. Hóa ra, đối với tôi, điều này chỉ tiết kiệm được 2 bit - bởi vì mảnh cuối cùng của tôi có thể là một con tốt / giám mục (thường làm tôi mất 3 bit vì tôi tiết kiệm được một bit trên mảnh tiếp theo), màu sắc đã được xác định và chỉ có vậy 2 bit. Tôi xuống tới 170 bit.

Khi cầm đồ được thăng chức, họ chỉ cần thay đổi loại của họ. Đối với mỗi phần rời khỏi bảng, tôi loại bỏ (tối thiểu) 3 bit và hai chương trình khuyến mãi cầm đồ làm tôi mất 2 bit, vì vậy tôi đang từ chối (từ từ) trong các chương trình khuyến mãi.

Castling. Để ném đá xảy ra, cả vua và tân binh có liên quan đều không thể di chuyển. Do đó, khi một tân binh có khả năng ném cả nó và nhà vua sẽ ở vị trí ban đầu của họ. Vì vậy, các tân binh có khả năng đúc sẽ được liệt kê ở cùng một nơi với các vị vua của màu đó. Vì điều này là bất hợp pháp (hai vị vua hoặc ba vị vua cùng màu trên bảng) và chỉ có thể xảy ra trong ba thiết lập có thể có cho mỗi màu (trái, phải, cả hai tân binh đều được liệt kê là vua) - việc giải mã là hoàn toàn có thể. Vì vậy, không có bit nào chúng ta đã mã hóa castling.

En Passant Ở đây chúng tôi cũng sẽ sử dụng các vị trí bất hợp pháp. Mỗi lần chỉ có một con tốt có thể gặp nguy hiểm. Nó phải ở hàng thứ tư của nó. Con tốt dễ bị tổn thương sẽ được 'lật' trở lại hàng nhà của nó - chuyển đổi với bất cứ thứ gì ở đó. Khi con tốt đó ở hàng đầu tiên của nó - một vị trí bất hợp pháp, tình huống sẽ rõ ràng đối với người giải mã - nó sẽ đảo ngược các vị trí và đánh dấu con tốt là dễ bị tấn công.

Chúng tôi cần phải xử lý đơn đặt hàng vì phần cuối cùng phải được 'xác định duy nhất'. Theo một thứ tự tiêu chuẩn, chúng tôi sẽ không thể biết được liệu người chơi ở góc sau có thể là lâu đài hay không - điều đó không được biết đến. Khi chúng tôi làm việc từ bên ngoài vào, chúng tôi đảm bảo rằng bất cứ nơi nào mà tân binh được 'liệt kê' ở góc riêng của nó, hoặc ở giữa bảng vì nó được chuyển đổi với một con tốt dễ bị tổn thương, sẽ có một mảnh được liệt kê sau nó - vì vậy chúng tôi được cho biết loại của tân binh. Chúng tôi biết sẽ có một mảnh sau nó bởi vì, để một con tốt dễ bị tổn thương thì phải có một con tốt ở bên trong (nó sẽ được mã hóa sau đó theo hướng dẫn ở trên).

Ồ, và để giúp đảm bảo rằng trường hợp xấu nhất liên quan đến tất cả các mảnh trên bảng, một khi chúng ta có ít hơn 32 mảnh, chúng ta có thể sử dụng bảng 64 bit để xác định vị trí rẽ cũng như chiếm vị trí bằng cách sử dụng 0 để thể hiện các mảnh khi màu trắng của nó lần lượt và 1 giây khi nó chuyển sang màu đen.

Vì vậy, chúng tôi có en passant và castling miễn phí. Chúng tôi đã nhặt được mảnh cuối cùng miễn phí, mặc dù phải mất một chút tinh chỉnh để làm cho trò đó trở nên tốt đẹp với các quy tắc en passant và castling. Chúng tôi đã bỏ 20 bit trên các mảnh tiêu chuẩn. Tôi tin rằng trường hợp xấu nhất ở đây liên quan đến một con tốt trắng trung gian di chuyển về phía trước và một mảnh màu đen ở giữa nó và nữ hoàng của nó trong khi tất cả các mảnh nằm trên bảng. Kiểm tra nhanh gấp đôi: mảnh đầu tiên được chụp - gọi nó là con tốt, 3 bit khỏi bảng trong cầm đồ, 3 bit trên bảng ở dạng mảnh cuối cùng, một bit trong dấu rẽ biến mất. Thúc đẩy hai con tốt 2 bit trở lại trên bảng. Ôi chết tiệt, tôi ở 171.

EDIT Tôi đã thêm mã cho bộ giải mã (đang hoạt động?) - trong R - bên dưới. Nó lấy các vectơ của booleans làm đầu vào - (xin lỗi - tôi không có khả năng mã hóa tốt trong bất cứ điều gì cho phép tôi thực sự sử dụng các bit) Tôi cũng đã bao gồm vị trí bắt đầu.

separate = function(vec){
    #Using a boolean vector (sorry R doesn't handle bits well and this will build quickest)
    board = matrix(vec[1:64],8,8,byrow=T)
    npieces = min(sum(board),64-sum(board))
    n = length(vec)
    a = vec[65:n]
    counter = 0
    pieces = list()
    white = 0
    Letters=c(letters,LETTERS)
    for (i in 1:npieces){
        col = ifelse(a[1],"black",{white=white+1;"white"})
        typ = a[2:4]
        a=a[-(1:4)]
        num = 4*typ[1] + 2*typ[2] + typ[3]
        type = switch(letters[num+1],a="king",b="queen",c="knight",d="rook",e="bishop0",f="bishop1",g="pawn0",h="pawn1")
        if (num > 3) {
            if(num%%2){
                a = c(T,a)
            } else {
                a = c(F,a)
            }
            type = substr(type,1,nchar(type)-1)
        }
        pieces[[Letters[i]]] = list(color=col,type=type)
        if (length(pieces)==31&&npieces==32) {
            col = ifelse(16-white,{white=white+1;"white"},"black")
            type = "TBD"
            pieces[[Letters[i+1]]] = list(color=col,type=type)
            break
        }
    }

    if (npieces==32) {
        f=function(y){sum(sapply(pieces,function(x)x$type==y))}
        if (f("pawn")<16) {pieces[[32]]$type="pawn"}
        if (f("bishop")<4) {pieces[[32]]$type="bishop"}
        if (f("knight")<4) {pieces[[32]]$type="knight"}
        if (f("queen")<2)  {pieces[[32]]$type="queen"}
        if (f("king")<2)   {pieces[[32]]$type="king"}
        if (f("rook")<(6-f("king"))) {pieces[[32]]$type="rook"}
    }
    return(list(board,pieces,turn=ifelse(a[length(a)],"black","white")))
}


fillboard = function(out) {
    board = out[[1]]
    pieces = out[[2]]
    turn = out[[3]]
    lpieces = lapply(pieces,function(x) paste(substr(x$color,1,1),x$type))
    game = matrix("     ",8,8)
    #Start with corners.
    a = c(1,57,8,64)
    #Then kings
    b = c(25,32)
    #Then rooks in en passant
    c = c(4,60,5,61)
    #Then kings in en passant
    d = 28:29
    exceptions = list(a,b,c,d)
    for (places in exceptions) {
        c= which(board[places])
        if (length(c)) {
            repl = lpieces[1:length(c)]
            game[places[c]] = unlist(repl)
            board[places] = F
            lpieces = lpieces[-(1:length(c))]
        }
    }
    #Loop through rows.
    for (i in c(1:4,8:5)) {
        j = which(board[i,])
        if (length(j)) {
            repl = lpieces[1:length(j)]
            game[i,j] = unlist(repl)
            board[i,j] = F
            lpieces = lpieces[-(1:length(j))]
        }
    }
    return(matrix(unlist(game),8,8,F))
}

swapillegal = function(matr) {
    mat = matr
    if (any(mat[8,]=="b pawn")) {
        j = which(mat[8,]=="b pawn")
        mat[8,j] = mat[5,j]
        mat[5,j] = "b pawn-e"
    }
    if (any(mat[1,]=="w pawn")) {
        j = which(mat[1,]=="w pawn")
        mat[1,j] = mat[4,j]
        mat[4,j] = "w pawn-e"
    }

    if (sum(mat[8,]=="b king") > 1) {
        j = which(mat[8,-4]=="b king")
        j[j==7] = 8
        mat[8,j] = "b rook-c"
    }
    if (sum(mat[1,]=="w king") >1) {
        j = which(mat[1,-4]=="w king")
        j[j==7] = 8
        mat[1,j] = "w rook-c"
    }
    return(mat)
}

decode = function(vec) {
    a = separate(vec)
    b = fillboard(a)
    c = swapillegal(b)
    list(board=c,turn=a[[3]])
}


startboard = c(rep(T,16),rep(F,32),rep(T,16))
#Re-ordering -- first spots will be the corners. Then kings. then en passant positions of those spots
pieces = c(F,F,T,T,F,F,T,T,T,F,T,T,T,F,T,T,F,F,F,F,T,F,F,F,F,F,T,F,F,T,F,F,F,F,T,F,T,F,F,F,T,F,F,T,T,F,T,T,F,T,T,F,T,T,F,T,T,F,T,T,F,T,T,F,T,T,T,F,T,F,T,T,F,T,F,F,T,T,T,F,T,F,T,F,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,T,F)
########## w rook -w rook -B rook -B rook -W king -B king -w kni  -w bi 0 -w Q  -w Bi 0 -w kni-w p0   - 2   -   3 -  4  - 5   -  6  -  7  -w p1 -b kni-b bi1  -b q  -b bi1  -b kni-b p1   -2    - 3   - 4   - 5   - 6   - b p0- implicit b p0.
#After the kings come all the prior en passant positions. which are empty at start. Then we start at whites bottom right, and move across rows to middle. Then we go to blacks bottom left, and fill across to the middle.
#Changing start to properly encode rooks for castling
newpieces= c(F,F,F,F,F,F,F,F,T,F,F,F,T,F,F,F ,pieces[-(1:16)])
test2 = decode(c(startboard,newpieces))

Mã này xây dựng 4 chức năng. Một trong đó thực hiện một số phân tách cơ bản của các mảnh và cấu trúc bảng, cũng như tìm ra loại mảnh và bất kỳ mảnh 'ẩn' nào. Hàm tiếp theo điền vào cấu trúc bảng với các phần đó theo thứ tự hơi kỳ quái (và khác với thuật toán ban đầu của tôi) [được giải thích trong các nhận xét mã]. Hàm tiếp theo sẽ điền vào bảng và phát hiện bất kỳ vị trí bất hợp pháp nào - sau đó sửa chúng và đổi tên những con tốt dễ bị tấn công bởi "x pawn-e" và bất kỳ tân binh nào có thể điều khiển "x rook-c". Hàm cuối cùng là một trình bao bọc chạy các chức năng đó theo thứ tự và đưa ra một đầu ra là bảng hiện tại cũng như lượt.

Tôi cũng đã bao gồm mã hóa của vị trí bắt đầu (mặc dù để thấy nó, bạn sẽ phải gọi c(startboard,newpieces)và mã gọi hàm bao bọc trên vị trí đó.

229/226 bit

Điều này hóa ra không phải là rất thành công, nhưng có thể cứu những người khác đi vào con đường tương tự.

Phiên bản đơn giản:

• 1 bit cho lượt của nó
• 4 bit cho bốn khả năng castling
• 3bit cho khả năng en passant . Điều này có chiều sâu hơn mà lúc đầu tôi hiểu. En passant phải được thực hiện bởi một con tốt di chuyển từ cùng một cấp (hàng) như cầm đồ được bắt. Phân tích trường hợp chỉ ra rằng một khi chúng ta biết có bao nhiêu con tốt của màu di chuyển lần cuối đã tiến lên chính xác hai hình vuông, sẽ có nhiều nhất là 6 trường hợp người qua đường (bao gồm cả trường hợp không có con tốt dễ bị tổn thương đối với người qua đường ). Trường hợp xấu hơn là 5 con tốt (có khả năng tất cả dễ bị tổn thương: ví dụ: PpPPpPPpcó năm lỗ hổng P). Với 6 con cờ có ít nhất 2 con cờ của đối phương trong cùng một cấp bậc, mỗi trong số đó có thể đe dọa nhiều nhất là 2 con cờ en passant . Vì vậy, chúng ta cần ceil(lg 6) = 3bit ở đây.

Rồi hội đồng quản trị. Bảng có 64 ô vuông, vì vậy một chỉ số hình vuông có thể được mã hóa thành 6 bit. Chúng tôi liệt kê những người đàn ông theo cấp bậc, màu sắc xen kẽ, bắt đầu với nhà vua.

• 6bit: vị trí của vua trắng. (Đảm bảo được lên bảng).
• 6bit: vị trí của vua đen. .
• 6bit: vị trí của nữ hoàng trắng. Nếu không có nữ hoàng trắng, hãy lặp lại vị trí của vua trắng như một tín hiệu.
• Đối với mỗi nữ hoàng trắng bổ sung, một 1bit theo sau là 6 bit cho vị trí.
• Một 0chút.
• Ditto cho nữ hoàng đen.
• Quá trình tương tự cho các tân binh, giám mục, hiệp sĩ và cầm đồ, mặc dù chúng ta có thể bỏ qua những con tốt cho một màu nếu chúng ta đã có 16 người đàn ông có màu đó.
• Xóa 0bit cuối cùng .

Điều này có giá một 12bit nhất định cho các vị vua và 2*7*5-1 = 69bit cho những người đàn ông khác. Trong trường hợp xấu nhất là tất cả 32 người đàn ông ở trên bảng, sẽ phải trả giá 7cho mỗi người đàn ông không phải là vua 12 + 7*30 - 1 = 221 bits. Vì vậy, với các 8bit ban đầu cho trạng thái toàn cầu, chúng ta có 229 bit .

Phiên bản nâng cao:

Bằng cách sử dụng mã hóa số học, chúng tôi có thể hoạt động lg num_possibilitiesthay vì ceil(lg num_possibilities)và chỉ lấy một ceilở cuối.

• 1 bit cho lượt của nó
• 4 bit cho bốn khả năng castling
• lg 6bit cho khả năng en passant .
• 6 bit cho vua trắng
• lg 60 bit (trường hợp xấu nhất) cho vua đen
• lg 63 bit (vì tôi không muốn làm phức tạp nó đến mức nhìn vào séc) cho nữ hoàng trắng, sử dụng vị trí của vua trắng nếu không có
• Đối với mỗi nữ hoàng trắng bổ sung, một 1chút tiếp theo lg 62, lg 61vv bit cho vị trí của mình.
• Một 0chút.
• lg 63 bit (hoặc ít hơn, nếu có bất kỳ nữ hoàng trắng nào) cho nữ hoàng đen.
• v.v.

Người đàn ông thứ n thực sự có mặt có 66-ngiá trị có thể. Nếu một loại không có màu, chúng tôi đã dành 66-#men so farcác bit để ghi lại đó (cộng thêm một bit cho dấu phân cách). Các trường hợp cực đoan là:

1. Tất cả đàn ông có mặt, bao gồm ít nhất một con tốt không được trích dẫn từ mỗi bên. Chúng tôi dành 5+lg 6cho nhà nước toàn cầu, 6+lg 60cho các vị vua, 29cho các bit phân cách và SUM_{n=32}^{63} lg ncác bit trên các vị trí. Tổng cộng: ceil(225.82)bit. Thất vọng.
2. Chỉ còn lại những con tốt Chúng tôi dành 5+lg 6cho nhà nước toàn cầu, 6+lg 60cho các vị vua, 29cho các bit phân cách, 8*lg 63nói rằng không có phần nào khác, và SUM_{n=48}^{63} lg ntrên các vị trí của những con tốt. Tổng cộng: ceil(188.94)bit. Tốt hơn - bằng cách cứu tân binh thứ hai, hiệp sĩ và giám mục cho mỗi bên, chúng tôi đã tiến lên một chút.

Vì vậy, trường hợp xấu nhất dường như là 226 bit , với mức tiết kiệm 3 lần.

Chúng tôi chắc chắn có thể làm tốt hơn trong trường hợp trung bình bằng cách mã hóa các con tốt trước các mảnh, vì chúng bị giới hạn ở 48 ô vuông thay vì 64. Tuy nhiên, trong trường hợp xấu nhất là tất cả đàn ông đều ở trên bảng và tất cả các con tốt đều được thăng chức điều này sẽ khiến bạn tốn thêm 2 bit vì chúng ta sẽ cần một lá cờ "không cầm đồ" thay vì có thể đếm được những người đàn ông.

Đây là một chủ đề thảo luận trong vòng tròn Cờ vua.

Đây là một bằng chứng rất đơn giản với 164 bit https://groups.google.com/forum/#!topic/rec.games.chess.computer/vmvI0ePH2kI 155 được hiển thị tại đây http://homepages.cwi.nl/~tromp /chess/chess.html

Chiến lược đơn giản hóa:

• Hạn chế cầm đồ đến nơi có thể tìm thấy những con tốt
• Giới hạn quân đội để xem xét các mảnh ban đầu và chương trình khuyến mãi cầm đồ có thể
• Hãy suy nghĩ kỹ về các chương trình khuyến mãi và các tình huống không thể khuyến mãi

Tối thiểu: 0 bit

Tối đa: 1734 243 bit (4.335 4.401 bit / bảng được khấu hao)

Kỳ vọng: 351 177 bit (4.376 4.430 bit / bảng được khấu hao)

Vì tôi có thể xác định đầu vào và đầu ra tuy nhiên tôi muốn, tôi quyết định đi theo mã hóa lịch sử của trò chơi cho đến thời điểm này. Một lợi thế là thông tin bổ sung về người đến lượt, người thông qua và người có khả năng xây lâu đài nơi có thể bắt nguồn và không được mã hóa.

Nỗ lực 1:

Tôi nghĩ rằng tôi có thể mã hóa mỗi lần di chuyển trong 12 bit, 4 bộ ba có dạng (bắt đầu x, bắt đầu y, kết thúc x, kết thúc y) trong đó mỗi lần là 3 bit.

Chúng tôi sẽ đảm nhận vị trí bắt đầu và di chuyển các mảnh từ đó với màu trắng đi trước. Bảng được sắp xếp sao cho (0, 0) là góc dưới bên trái màu trắng.

Ví dụ: trò chơi:

  e4    e5
 Nf3    f6
Nxe5  fxe5
...    ...

Sẽ được mã hóa thành:

100001 100010 100110 100100
110000 101010 101110 101101
101010 100100 101101 100100
...

Điều này dẫn đến mã hóa 12 m bit trong đó m là số lần di chuyển được thực hiện

Một mặt điều này có thể trở nên rất lớn, mặt khác bạn có thể coi mỗi nước đi là trò chơi riêng của mình để mỗi mã hóa thực sự mã hóa m "bàn cờ". Nếu bạn khấu hao khoản này, bạn nhận được rằng mỗi "bàn cờ" là 12 bit. Nhưng tôi cảm thấy điều này là một chút gian lận ...

Cố gắng 2:

Tôi nhận ra rằng mỗi động thái trong lần thử trước đều mã hóa nhiều động thái bất hợp pháp. Vì vậy, tôi quyết định chỉ mã hóa các động thái hợp pháp. Chúng tôi liệt kê các chuyển động có thể như sau, đánh số từng ô vuông sao cho (0, 0) → 0, (1, 0) → 1, (x, y) → x + 8 y. Lặp lại qua các ô và kiểm tra nếu một mảnh ở đó và nếu nó có thể di chuyển. Nếu vậy, thêm các vị trí nó có thể đi đến một danh sách. Chọn chỉ mục danh sách đó là động thái bạn muốn thực hiện. Thêm số đó vào tổng số lần di chuyển có trọng số bằng 1 cộng với số lần di chuyển có thể.

Ví dụ như trên: Từ vị trí bắt đầu, mảnh đầu tiên có thể di chuyển là hiệp sĩ trên ô vuông 1, nó có thể di chuyển đến ô vuông 16 hoặc 18, vì vậy hãy thêm chúng vào danh sách [(1,16),(1,18)]. Tiếp theo là hiệp sĩ trên ô vuông 6, thêm di chuyển của nó. Nhìn chung, chúng tôi nhận được:

[(1,16),(1,18),(6,21),(6,23),(8,16),(8,24),(9,17),(9,25),(10,18),(10,26),(11,19),(11,27),(12,20),(12,28),(13,21),(13,29),(14,22),(14,30),(15,23),(15,31)]

Vì chúng tôi muốn di chuyển (12, 28), chúng tôi mã hóa số này thành 13 trong cơ sở 20 vì có 20 di chuyển có thể.

Vì vậy, bây giờ chúng tôi nhận được số trò chơi g ₀ = 13

Tiếp theo, chúng tôi làm tương tự cho màu đen ngoại trừ chúng tôi đánh số các ô ngược lại (để dễ dàng hơn, không bắt buộc) để có được danh sách di chuyển:

[(1,16),(1,18),(6,21),(6,23),(8,16),(8,24),(9,17),(9,25),(10,18),(10,26),(11,19),(11,27),(12,20),(12,28),(13,21),(13,29),(14,22),(14,30),(15,23),(15,31)]

Vì chúng tôi muốn di chuyển (11, 27), chúng tôi mã hóa số này thành 11 trong cơ sở 20 vì có 20 di chuyển có thể.

Vì vậy, bây giờ chúng tôi nhận được số trò chơi g ₁ = (11 20) + 13 = 233

Tiếp theo, chúng tôi nhận được danh sách các động thái sau đây cho màu trắng:

[(1,16),(1,18),(3,12),(3,21),(3,30),(3,39),(4,12),(5,12),(5,19),(5,26),(5,33),(5,40),(6,12),(6,21),(6,23),(8,16),(8,24),(9,17),(9,25),(10,18),(10,26),(11,19),(11,27)(13,21),(13,29),(14,22),(14,30),(15,23),(15,31)]

Vì chúng tôi muốn di chuyển (6, 21), chúng tôi mã hóa số này thành 13 trong cơ sở 29 vì có 29 di chuyển có thể.

Vì vậy, bây giờ chúng tôi nhận được số trò chơi g ₂ = ((13 ⋅ 20) + 11) 20 + 13 = 5433

Tiếp theo, chúng tôi nhận được danh sách các động thái sau đây cho màu đen: [(1,11),(1,16),(1,18),(2,11),(2,20),(2,29),(2,38),(2,47),(3,11),(4,11),(4,18),(4,25),(4,32),(6,21),(6,23),(8,16),(8,24),(9,17),(9,25),(10,18),(10,26),(12,20),(12,28),(13,21),(13,29),(14,22),(14,30),(15,23),(15,31)]

Vì chúng tôi muốn di chuyển $ (10, 18) $ (10, 18)

Vì vậy, bây giờ chúng tôi nhận được số trò chơi g ₃ = (((19 ⋅ 29 + 13) 20) + 11) 20 + 13 = 225833

Và tiếp tục quá trình này cho tất cả các động thái còn lại. Bạn có thể nghĩ g là hàm g (x, y, z) = x y + z. Do đó g ₀ = g (1, 1, 13), g ₁ = g (g (1, 1, 11), 20, 13), g ₂ = g (g (g (1, 1, 13), 20, 11), 20, 13), g ₃ = g (g (g (g (1, 1, 19), 29, 13), 20, 11), 20, 13)

Để giải mã số trò chơi g ₀ , chúng tôi bắt đầu ở vị trí ban đầu và liệt kê tất cả các di chuyển có thể. Sau đó, chúng tôi tính g ₁ = g ₀ // l , m ₀ = g ₀ % l , trong đó l là số lần di chuyển có thể, '//' là toán tử chia số nguyên và '%' là toán tử mô đun. Cần giữ g ₀ = g ₁ + m ₀ . Tiếp theo chúng ta thực hiện di chuyển m ₀ và lặp lại.

Từ ví dụ trên nếu g ₀ = 225833 thì g ₁ = 225833 // 20 = 11291 và m ₀ = 225833% 20 = 13. Tiếp theo g ₂ = 11291 // 20 = 564 và m ₁ = 11291% 20 = 11. Sau đó g ₃ = 11291 // 20 = 564 và m ₂ = 11291% 20 = 11. Do đó g ₄ = 564 // 29 = 19 và_m_ ₃ = 564% 29 = 13. Cuối cùng g ₅ = 19 // 29 = 0 và m ₄ = 19% 29 = 19.

Vậy có bao nhiêu bit được sử dụng để mã hóa một trò chơi theo cách này?

Để đơn giản, giả sử luôn có 20 lần di chuyển mỗi lượt và trong trường hợp xấu nhất, chúng tôi luôn chọn người lớn nhất, 19. Số chúng tôi sẽ nhận được là 19 20 ^m

+ 19 20 ^{m - 1} + 19 20 ^{m - 2} + ⋯ + 19 ⋅ 20 + 19 = 20 ^{m + 1} - 1 trong đó _m là số lần di chuyển. Để mã hóa 20 ^{m + 1} - 1, chúng ta cần khoảng các bit log ₂ (20 ^{m + 1} ) khoảng (m + 1) ∗ log ₂ (20) = 4.3219 ∗ (m + 1)

Trung bình m = 80 (40 di chuyển cho mỗi người chơi), do đó, sẽ mất 351 bit để mã hóa. Nếu chúng tôi ghi lại nhiều trò chơi, chúng tôi sẽ cần mã hóa toàn cầu vì chúng tôi không biết mỗi số sẽ cần bao nhiêu bit

Trường hợp xấu nhất khi m = 400 (200 di chuyển cho mỗi người chơi) vì vậy điều này sẽ mất 1734 bit để mã hóa.

Lưu ý rằng vị trí chúng tôi muốn mã hóa phải được trao cho chúng tôi thông qua con đường ngắn nhất để đến đó bằng cách tuân theo các quy tắc. Ví dụ, trò chơi được lý thuyết hóa ở đây không cần m = 11741 để mã hóa vị trí cuối cùng. Thay vào đó, chúng tôi chạy tìm kiếm Breadth-First để tìm đường đi ngắn nhất đến vị trí đó và mã hóa thay vào đó. Tôi không biết chúng ta sẽ cần phải đi sâu đến mức nào để liệt kê tất cả các vị trí cờ vua, nhưng tôi nghi ngờ rằng 400 là một sự đánh giá quá cao.

Tính toán nhanh:

Có 12 quân cờ độc đáo hoặc hình vuông có thể để trống để đặt chúng trên bàn cờ là 13 ⁶⁴ . Đây là một sự đánh giá quá cao vì nó bao gồm nhiều vị trí không hợp lệ. Khi chúng ta m di chuyển vào các trò chơi chúng tôi đã tạo ra khoảng 20 ^m vị trí. Vì vậy, chúng tôi đang tìm kiếm khi 20 ^m = 13 ⁶⁴ . Đăng nhập cả hai mặt để có được m = 64 * log ₂₀ (13) = 54.797. Điều này cho thấy chúng ta sẽ có thể đến bất kỳ vị trí nào trong 55 lần di chuyển.

Bây giờ tôi đã tính trường hợp xấu nhất là m = 55 chứ không phải m = 400, tôi sẽ chỉnh sửa kết quả của mình. Để mã hóa một vị trí trong đó m = 55 mất 243 bit. Tôi cũng sẽ nói rằng trường hợp trung bình là khoảng m = 40, cần 177 bit để mã hóa.

Nếu chúng ta sử dụng đối số khấu hao từ trước đó, chúng ta sẽ mã hóa 400 "bàn cờ" trong 1734 bit để chúng ta nhận được rằng mỗi "bàn cờ" chiếm 4.335 bit trong trường hợp xấu nhất.

Lưu ý rằng g = 0 biểu thị một trò chơi hợp lệ, trò chơi mà mảnh trên hình vuông thấp nhất di chuyển đến hình vuông thấp nhất có thể.

Ghi chú bổ sung:

Nếu bạn muốn tham khảo một vị trí cụ thể trong trò chơi, bạn có thể cần phải mã hóa chỉ mục. Điều này có thể được thêm bằng tay, ví dụ như ghép chỉ mục vào trò chơi hoặc thêm một động thái "kết thúc" bổ sung như là lần di chuyển cuối cùng có thể mỗi lượt. Điều này hiện có thể giải thích cho các cầu thủ bị thủng lưới, hoặc 2 liên tiếp để biểu thị các cầu thủ đã đồng ý rút thăm. Điều này chỉ cần thiết nếu trò chơi không kết thúc trong một checkmate hoặc bế tắc dựa trên vị trí, trong trường hợp này nó được ngụ ý. Trong trường hợp này, nó mang số bit cần thiết trung bình lên tới 356 và trong trường hợp xấu nhất là 1762.