最小のチェスボード圧縮

39

チェス盤をエンコードおよびデコードできるアルゴリズムまたはプログラムを作成します。目標は、そのターンでのプレーヤーのすべての動きの可能性を判断するために使用できる（一度デコードされた）チェス盤の最小の表現を作成することです。

エンコードは以下を表示できる必要があります。

  • 誰の番です。
  • プレイヤーが両サイドでキャッスルできるかどうか。
  • プレイヤーが同乗者を演じることができるかどうか、もしそうなら、どのポーンですか？
  • すべてのピースの位置。

キャスリングに関する重要な注意事項：白が王を1ターン動かし、次に次の王を戻す場合、その後、どちらの側でもキャッスルできないことは明らかでなければなりません。彼らが左または右のルークを動かした場合も同様です。ボードは視覚的には2ターン前と同じ状態ですが、ゲームの状態は変化しています。詳細はこちら：http : //en.wikipedia.org/wiki/Chess#Castling

en-passantについての重要な注意：これはターンセンシティブな動きでもあります。詳細については、ルールをご覧ください。http://en.wikipedia.org/wiki/Chess#En_passant

必要に応じて入力と出力を決定します。それを最も圧縮できる人への主要な小道具！

あなたのスコアは最悪のシナリオで決定されます-ビットの最大可能サイズ。その数をどのように計算したか、何を計上したかを必ず示してください。最小の最悪の場合を撃ちます！

code-challenge  chess  compression 
— セルツァー
ソース
「ビット単位」とはどういう意味ですか？
— ピーターテイラー14年
これは最小のコードですか、それとも最も圧縮されたコードですか？最も圧縮された方がより興味深い。
— ジャスティン14年
明確にしないで申し訳ありません。ビット単位の表現は、ビット単位の操作が必要なビットとして表現し始める場合にのみ圧縮できるという意味で、ビット単位です。私の側の不十分な使用。また、最小のコードではなく、最も圧縮されています。
— セルツァー14年
2
@GeekWithALifeはい、ボード上に18人のクイーンを同時に置くことができます。このリンクをたどり、再生ボタンをクリックして例をご覧ください。
— きしむオッシファージュ14
1
@AJMansfieldは、約28人の男性がいるボードに役立つかもしれませんが、32ビットの男性がいるボードには117ビットで十分であり、ターゲットよりも約50ビット少ないと計算します。複雑なのは、32人以下の男性になったら、昇進によってプレイヤーにさらに多くの司教が与えられることです。
— ピーターテイラー14年

回答:

27

最小：12ビット
最大：
平均：

昨夜、もっと小さくすることができると思っていました。

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)

結果は、12ビットという印象的なサイズです！

それでは、K +1の他のタイプのピースはどうでしょうか？

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

サブツリーの2つの可能な配置があります。 

   /\      /\
  +  K    K  +

両方とも、すべてのピースで同じビットサイズになります。そのため、使用するものに違いはありません。最初のものを選択します。

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

だから王に他の2種類のピース

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

5つのサブツリーがあります（1と2を使用して、どの部分を示すかを示します）。

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

したがって、使用するサブツリーをエンコードするには3ビットが必要です。

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

さらに多くのピースの分析を行っています

+3その他

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

+4その他

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

+5その他

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

最大：208？

これらすべてのサブツリーを9ビットにエンコードすることは可能ですか？

すべての可能なサブツリーを合計すると、392個の可能なサブツリーが得られます。

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

Freq IDを使用する

164603以来、ユニークな作品の周波数。

Log2( 164603) = 17.3286110452
             ~ 18 bits

0
 0000 0000 0000 0000 00  Freq ID

（+000）（+00）キャスリング

最大：= 204ビット

回転3

最小：82最大：199平均：160

最後に、最大ビットサイズを見つけるための分析を行いました。ユニークな作品頻度のそれぞれのための最適なハフマン符号化で。 

               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

これは最悪のサイズであり、ポーンの数が1より大きい場合、En-Passant列ビットになります。これらのポーンの色と位置に関係なく、一部のボードが3ビット小さくなる可能性があります。

また、ボードのサイズには144種類（最悪の場合）しかありません。

75-216ビット（v2） v1最小サイズは98ビット（12.25バイト）で、ボード上の2つのキングのみです。

最大サイズはわずか216ビット（27バイト）です。

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

サイズは平均で約157ビット（19.625バイト）です。

個

ボードをエンコードするには、バイナリツリーエンコーディングスキームを使用しています。空の正方形は、32から62の出現範囲の中で最も頻繁に出現します。次はポーン、次にルーク、ナイト、ビショップ、そして最も頻度が低いのはクイーンとキングです。

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

開始ボードは、わずか166ビット（20.75バイト）でエンコードできます。

  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

誰が移動したかを示すために必要なのは1ビットだけです 

0-> Black , 1-> White

キャスリングは4ビットでエンコードできます。

 B  W
LR LR
00 00

だから私は171ビット（21.375バイト）を使用しました

En-Passeは、わずか16ビット（2バイト）にエンコードできます

合計で187ビット（23.375バイト）です。

レイアウト

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

まだコードを書いていません。

未使用のビットのうち3ビットに注意してください。したがって、最大は213ビットです。

可能な改善

1）ヘッダーブロックの形式を24ビットから8ビットに削減（@Peter Taylorの提案による）

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

2）可変長ヘッダー

小さな4ビット固定ヘッダー 

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

追加ビットの次のブロック（キャスティングがまだ可能な場合）

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

追加ビットの次のブロック（ポーンが存在する場合）

000--> En-Passant column Position

だから今、私は可変長ヘッダー4-11ビットを持っています

3）ボードに残っている部分に応じて、異なるエンコードスキームを使用します。

ボード上にあるピースと頻度に応じてツリーエンコーディングを変更します。

ゲーム終了状態の1つの可能なエンコード（ポーンなし）

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

これは、1個あたり約4ビットです。

ボードにはどのタイプのピースがありますか？

RBNQK Permutation
11111 (11111)

順列は可変長の0〜5ビットです。ピースのタイプが1つだけ残っている場合は、それを含めないでください。

それらのピースのどの順列をツリーに使用しますか？これは、上記の例のピース数の階乗です。5個なので、120個の可能な順列をエンコードできます。

 #    !  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.

空の正方形と色には追加ビットがあることに注意してください。

例

残ったQKのみの例を挙げましょう

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

合計81ビット

残った王だけの例を挙げましょう

 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

すべてをまとめる 

 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

そこで、ボードの最小エンコードを75ビット（9ビット3ビット）で計算します

このコーディング方式が最大サイズにどのように影響するかをまだ計算していません。

改善4

キャスティングのビット数を2ビットに減らします。ターンしているプレイヤーのためにキャストするだけです。

 0 Castling possible (from header block)
 LR 
 00

考えてみると、ヘッダーブロック内に2ビットを含めることをお勧めします。

— アダム・スペイト
ソース
通過するために16ビットは必要ありません。直前のターンで最大1つのポーンが移動したため、4ビットで十分です（たとえば1111、「no passentant possible」またはそれ以外の場合は2進数としての列）。
— ピーターテイラー14年
なぜポーンがツリー内でより良い位置を取得するのですか？一般的なケースでは最も一般的ですが、極端なケースではR / B / Nが10回現れることがあります。
— ウゴレン14年
@PeterTaylor、実際には3ビットで十分です。黒の5位のポーンを持つ列のみをカウントする場合（白の動きを想定）、8は無効になります。
— ウゴレン14年
1
最悪の場合は実際には不可能であることに注意してください。キャプチャなしでプロモーションを行うことはできません（2つのプロモーションにつき少なくとも1つのキャプチャが必要です）。
— ウゴレン14年
2
64の位置（白または黒のキング）をエンコードするには、6ビット（2 ** 6 = 64）が必要です。
— ランブルスコAcido 14
17

192ビット（最悪の場合）

これは、任意のポーンプロモーションに対処し、64 + 4×32 = 192ビットを超える必要のない、非常に単純なストレージスキームです。

  • 最初の64ビットには、ピースがどこにあるかを示すビットボードが格納されます（ただし、内容は異なります）。つまり、チェス盤の各正方形（正方形a1からb1、c1など、正方形h8まで）ごとに1ビットを格納し、空の正方形は0で、占有された正方形は1で表されるようにします。

  • 次に、ビットボード上で占有されているとマークされた各正方形について、その正方形上のピースをエンコードする4ビットのニブルを保存します。4ビットの最初の部分はピースの色をエンコードし（0 =白、1 =黒）、残りの3ビットはピースのタイプをエンコードします。

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

    ピースタイプ

    0 =（通常）ポーン
    1 =（通常）ルーク
    2 =ナイト
    3 =ビショップ
    4 =クイーン
    5 =キング（次に移動するプレイヤーの）
    6 =キング（他のプレイヤーの）

    キングの2つのエンコードに注意してください。これは、移動するプレイヤーのターンを決定するために使用されます。（実際、ボードには常に2人のキングがいるため、コード5と6の4つの組み合わせが可能になるため、ここで2番目の情報を簡単にエンコードできます。）

    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                     |
+----+----+--------------------------------+

    以下のために必要な追加情報をエンコードするためにエンアンパッサンとルールをキャスリング、我々は質屋やそれがに表示された行に応じて、ルークのいずれかを表し、一つの追加ピースタイプを、ご紹介：

    7（1行目と8行目）=移動したことがなく、キングも移動したことがないルークです。したがって、キャスティングの資格があります
    7（4行目と5行目）= 2マス進んだポーンしたがって、一時的に捕獲される可能性があります

すべてを一緒に入れて：

     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) |
    +---+---------------------------------------------+

したがって、ボードの状態をエンコードするのに必要なビットの総数は、64 + 4×ボード上のピースの数です。ボード上に32個を超えることはないため、このエンコードの最大長は192ビットです。

たとえば、上記のエンコーディングを使用すると、ボードの初期状態は次のようにエンコードされます（読みやすいように空白が挿入されます）。

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

または、16進数で：

FFFF 0000 0000 FFFF 7234 5327 0000 0000 8888 8888 FABC EBAF
— イルマリ・カロネン
ソース
2
「2つの正方形を前進させたポーン」と「移動したことのないルーク」は、それらが存在する行に応じて相互に排他的であるため、同じ状態スロットを共有できます。余分な自由状態を使用して、「色の王」をエンコードできます。その方法でぶら下がりビットを取り除くことができるはずです。
— ホタル14年
また、ビットボードに63ビットのみを保存し、エンコードされた男性の数から最後のビットを推測することで、おそらくビットを節約できます。（これは、ビットシーケンスの長さの外部エンコードを必要とするため、これが不正行為であるかどうかは明確ではありません）。また、男性の状態6と7を捨てると、最大6 ^ 32までエンコードする必要があり、82.7ビットかかります。83に切り上げると、状態6および7を使用して13ビット節約され、同じ情報を8ビットのみでエンコードできます。
— ピーターテイラー14年
ありがとう、@ FireFly！あなたの提案を実装しました。（もちろん、Peter Taylorの提案はさらに効率的ですが、現在のスキームの単純なバイナリエンコーディングが好きなので、今のところ使用していません。いつでも個別のエントリとして送信できます...）
— Ilmariカロネン14年
さて、これは少し複雑です。しかし、私に聞いてください。ターンインジケーターで1ビットヒットした場合、キングをターンでポーン1と呼ぶピースに置き換えることができます。pawnをpawn0に変更します。これで、（パッセンティブではない）ポーンがあるときはいつでも、次のピースに関する情報も少し得られます（pawn0の場合は0、pawn1の場合は1）。ポーンは16個あるため、ターンインジケーターの16ビットから1を引いた値を獲得します。通行人に対して脆弱なポーンが存在する場合は常に、その後に1ビット追加する必要があります。しかし、偶然の出会いはすぐに起こらなければならないので、最小ゲインは14ビットです。
— user5957401 16
司教のようなものでも同様のことができます。「特別なゾーン」にない司教（そのコーナーの10個のスポットとその横の中央の列）が特別とマークされているとします。あなたはその場所を知っているので、あなたはその司教を知っています。これで2人の司教ができ、次のピースでそれぞれに0または1を与えることができます。これにより、さらに4ビットが与えられますが、最悪のケースでは、特殊ゾーン全体に司教がおり、ゲインはありません。
— user5957401 16
14

160ビットの最悪の場合

前回の回答を22バイト投稿した後、21バイトまで減らすことができるかどうか疑問に思い始めました。しかし、Peter Taylorの驚くべき166バイトを見たとき、「ちょっと待って、5つの32ビットワードが可能だと思います！」

だからかなり考えた後、私はこれを思いついた：159.91936391バイト（かなりきつい！）

これは長い投稿になるので、ご容赦ください。今日できることを投稿し、すぐに数ビットのコードを追加します。

だから、それを行う方法は次のとおりです。

En Passantと不正な位置（0ビット）でエンコードされたキャスリング

パッサン

他の回答で述べたように、通行人に対して脆弱なポーンが立つことができる最大5つの正方形があります。これらは、ターンしているプレイヤーのポーンの隣の正方形です。

これをエンコードするために、en passantに対して脆弱なポーンは、最初または最後の行の正方形の1つにあるものと交換されます。これは、男性または空の正方形のいずれかです。ポーンはこれらの行に配置できないため、これにより不正な位置が生成されます。デコーダーはポーンを正しい位置に戻して、通過情報を抽出する必要があります。

これがキャスティングエンコーディングに干渉しないようにするために、ゲームの開始時にキングが立っているマスが邪魔されず、エンパッサンエンコーディングプロシージャがキングを隣り合わせに配置しないことが重要です。これは違法な王の立場になるでしょう。これらの2番目のポイントを満たすために、エンコーダーは、通過するポーンを交換するスクエアに関して2つの選択肢があります。最大5つのポーンのそれぞれの最初の選択肢の正方形は、A8、B8、C8、G8、H8です。2番目の選択肢：A1、B1、C1、G1、H1。

キャスリング

城に入れることを許可された王は、定義により、まだ最初の広場にいます。最初の正方形に白い王がいると、黒の王が立つことができる合計63の正方形があり、そのうち58が合法です（彼は自分をチェックするため、白い王のすぐ隣に移動することはできません）。白人の王が城に出ることを許可されている場合、彼は左のルーク、右のルーク、またはその両方で城に入れることができます。したがって、白の王がキャッスルできる3x58 = 174の可能性、黒の王がキャッスルできる別の174、そして両方がキャッシングできる合計3x3 = 9の合計357の可能性があります。

隣接する正方形にいる2人の王には、420の違法な配置があります。白い王が角にいるときは3x4 = 12、端にいるときは5x24 = 120、別の正方形にいるときは8x36 = 288です。したがって、すべての可能なキャスティングの可能性をエンコードするのに十分な違法な位置が簡単にあります。

少なくとも1人のキングがキャッスルを許可されている場合、エンコーダーはキャスティングデータとキャッスルを許可されていないそれらのキングの位置データをテーブルで検索し（または、ここで指定しないアルゴリズムを使用）、違法を生成します二人の王の位置。その後、これらの広場で起こったものと王を交換します。

これはエンパッサントの後にエンコードされ、デコードされることが重要です。そうでない場合、潜在的な干渉があります。

比較

したがって、これまでのところ、私はビットを使用していません！ピーターの答えを見て、私はまだエンコードするために次のものがあります：

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

これは、29人の男性の最悪の場合です（ピーターの答えを参照してください）。

どの正方形が占有されているか/誰の順番ですか？

どの正方形が占有されているかを簡単にエンコードするには、64ビットグリッドを使用します。これは、占有されている正方形の数も示します。ただし、32個以上の正方形を占有することはできないため、やや無駄があります。私の解決策は、1を使用して白の順番の場合に占有された正方形をエンコードし、0を使用して黒の順番の場合に占有された正方形をエンコードすることです。現在、すべての組み合わせが使用され、無駄はありません。

したがって、ターンを保存するために少し節約します。32の1未満、白のターン、32の1以上、黒のターンです。唯一のあいまいなケースは、すべての男性がボード上にいて、32個の1と32個の0がある場合です。したがって、この場合にのみ追加のビットが必要です。キャプチャが発生するまでプロモーションが行われない可能性があるため、この余分なビットは最悪のケース全体に影響しません（3人の男性がキャプチャされ、残り29人で発生します）。

正方形を占める男性の色

上記から、男性の人数がわかります。次のPascalの三角形の抜粋は、黒と白の異なる分布の可能性の数を示しています。たとえば、3人の男性の場合、可能性は次のとおりです。黒人男性3人（順列1人）黒2人、白1人（順列3人）、黒1人、白2人（順列3人）、白3人（順列1人）。3 = 8。一般的に、男性の数が少ない場合、2 nの可能性があります。ただし、すべての黒とすべての白の可能性は違法です（少なくとも各サイドのキングがボード上に存在する必要があります）。実際の法的な順列の数は2 n -2です（パスカルの三角形の1は無視してください）。

合計16人を超える男性の場合、ボード上の各色の男性は16人を超えてはならないという追加の制約があります。したがって、32人全員がボードにいる場合、それぞれ16人でなければならず、可能性のある総数は601080390であり、これは2 32よりもかなり少なくなります。

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

このパスカルの三角形の抽出物の「行」を合計することで、可能性の数を見つけることができます（これは、表のNE-SW対角線を意味します。これは、便利な表示のために三角形を反時計回りに45度回転したためです。必要なビット数したがって、男性のターン、占有されている正方形、および色をエンコードするには、次のようにします。

最大25人の男性：64+（男性の数）をわずかに下回る
25人を超える男性の場合：

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

2色については、どの男性とどの順序ですか？

以前の回答では、各ポーンは同じ列の反対色のポーンによってブロックされているため、キャプチャが発生するまでポーンを昇格させることはできません。ピーターの答えは、（上限として）すべてのキャプチャーが、キャプチャーされる側の1つのプロモーションとサイドのキャプチャーの2つのプロモーションにつながる可能性があると考えました。ただし、これをいくつかのケースに分割できます。

  1. 黒のポーンは白のポーンをキャプチャします。キャプチャポーンは現在、別の列にいるので自由に宣伝できます。同じコラムの彼の同僚も昇進できます。白いポーンの元の列の黒いポーンもプロモートできます。これは、3つのプロモーションを許可する唯一のケースです。

  2. 黒のポーンは、隣接する列の白のポーンを通過し、後ろの白いポーン（ポーン以外）をキャプチャします。これにより、キャプチャするポーンと元の列にいた白いポーンがプロモートできます。両側に1つのプロモーション。

  3. 白のポーンは（ポーン以外で）ピースごとにキャプチャされます。これにより、通常、黒のプロモーションのみが許可されます。唯一の例外は、ポーンを同じ列に移動する複数のキャプチャによって既に引き起こされたブロックされたポーン形成を解放する場合です。

そのため、基本的なケースとして、各キャプチャでは両側でそれぞれ1つのプロモーションが許可されると考えることができます。捕獲された男がポーンの場合、捕獲側に追加のプロモーションがあるかもしれません。

私はピーターのプログラムに似たプログラムを書きました。多少粗雑ですが、重要な追加機能があります。プレーヤーが通常の8ポーンより少ないポーンで開始するときに可能な順列の数を計算できます。以下は、プログラムによって生成されるデータです。

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

8個のポーン、15人の男性、0個のプロモーションの場合、順列の数は8個のポーン、16人の男性、0個のプロモーションよりもわずかに少ないことがわかります。しかし、7個のポーン、15個の男性、0個のプロモーション（男性が間違いなくポーンであると考えるのと同じです）のようなケースを考えた場合、約半数の順列が得られます。

したがって、黒に16人の男性が、白に15人の男性がいる場合、黒の2つのプロモーションと白の1つのプロモーションの上限推定値を考慮することができます。

5383778400 x 660810150 = 3.55766E+18 possibilities

ただし、次のように進めれば、より良い結果が得られます。

A.ホワイトが失った男性がどんなタイプであってもよいと仮定して、ブラックとホワイトに対してそれぞれ1つのプロモーションを検討してください。

843242400 x 660810150 = 5.57223E+17 possibilities

B. 2つのプロモーションがある場合、黒の追加の可能性を考慮し、ポーンを失った白の可能性のみを掛けます。 

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

これら2つを合計すると、2.25072E + 18になります。これは、3.55766E + 18よりも小さい数値です。最大3つのキャプチャ（残り29人）のすべての可能性を以下に示します。

(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

したがって、片方が15人、もう片方が14人の最悪の場合、67.804ビットが必要です。

これをどの正方形と色を指定するために必要な92.116ビットに追加すると、合計67.804 + 92.116 = 159.92ビットが得られます。

— レベルリバーストリート
ソース
1
小数点のコンマを小数点に変更してくれた@Einacioに感謝します。私はスペインのコンピューターのExcelで多くのテーブルを作成しましたが、これを投稿するのは大きな仕事でした。私が言うように、私はまだこの投稿を終えていません。時間があれば、順列カウントプログラムとエンコード/デコードに関するコードの断片を追加します。PS。多くの人がこれを読んでいるとは思いもしませんでした:-)
— Level River St 14
最後に、あなたは読者に、いくつかのcinfusionを引き起こす可能性がありますが、意味の事は、ある代わりにビットのバイトのTAKするために管理
— masterX244
13

177ビットの最悪の場合

このアルゴリズムは、ほとんど単純ではありませんが、キングが2人しか残っていない場合、177ビットの最悪ケース（実際には184b = 23B）、13b（16b = 2B）のベストケースシナリオになります。

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
— FIQ
ソース
非常に素晴らしい。ビット14-105（92ビット）を多項係数に基づくエンコードに置き換えることにより、これをさらに効率的にすることができます。sum_{i=0}^{15} sum_{j=0}^{15} 62! / (i! j! (62-i-j)!) < 2^87.45。
— ピーターテイラー14年
私が変更する唯一のことは、通行人エリアのために、より単純なバージョンを作成することです。たとえば、基数5の30個をエンコードし、最大5つの傍観者の位置がある場合、5 ^ 31 <2 ^ 72になります。それらをenpassant（13）とnon-enpassant（59）に分割する場合と同じですが、余分な複雑さはありません。
— アリンストイアン14年
これを行うと、実際には1ビット余分に使用されます。その理由は、（最悪の場合）5つの共感者の可能性があるからです。しかし、私はまだ「共感者なし」、つまり6番目の状態の可能性を宣言する必要があります。この場合、余分な1ビットはenpassantの宣言の可能性または不可能になります（そしてこのアプローチでは、enpassantブロックをスキップして30個をエンコードするさらにシンプルなアプローチを使用でき、3ビットをenpassantチェックに別々に使用できます。 +1ビットの使用にもつながります）。次の5行目では、5人の潜在的な通行人（ホワイトのターン）が有効になります。BWBBWBBW
— FIQ
はい、あなたが正しい。
— アリンストイアン14年
7

166ビット

  • 1 ビット：誰の番ですか？
  • 2ビット：どのキャスティングオプションが開いていますか？（質問をよく読んで、順番が回っているプレイヤーのキャスティングオプションを記録するだけです。）
  • lg 6 ~= 2.585ビット：どのenpassantオプションが開いていますか？（他の答えを参照）
  • lg sum_{i=1}^{16} sum_{j=1}^{16} 64! / (i! j! (64-i-j)! = lg 3629590441720924477681996172 ~= 91.552 ビット：どの正方形がどの色の男性で占められていますか？
  • 最悪のlg 451366131803622235200 ~= 68.613場合、どの男性とどの順序で表示されるか（以下を参照）

算術エンコーディングを使用して（各ステップで均一な分布を適用しているため）、ceil(3 + 2.585 + 91.552 + 68.613) = 166ビットを達成できます。

男性のエンコード：特定の色の男性の数がわかっている場合、男性のすべての可能な分布/マルチセットを簡単に列挙できます（たとえば、5人の男性では、1人の王、1人の女王、2人のルーク、 Pawn）そして、各分布のすべての可能な順列を考慮することができます。

ただし、相互依存関係を考慮することでさらに改善できます。私はこれを非常に基本的なレベルでのみ行っています：可能なプロモーションはいくつですか？ポーンは「パス」されて、3つの方法でプロモートできるようになります。キャプチャして、別の列に移動します。またはその反対側のポーンがキャプチャし、別の列に移動します。またはその反対のポーンがキャプチャされます。したがって、白のキャプチャは、白と黒の2つの渡されたポーンを作成する可能性があります。

プロモーションの上限の部分的なテーブルを作成できます。

(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)

また、プレーヤーがN男性を持ち、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

2つを組み合わせると、両側の男性の数を指定すると、両方の順列を指定するために必要なビット数を取得できます。

           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

表のこのセクションにない場合、両側に最大8つのプロモーションがあり、最悪のケース（一方が14人、もう一方が15人の場合の68.613ビット）よりも優れていると仮定できます。

これは多くの違法なポジションを許可するため、完全な表現からはまだ長い道のりであることに注意してください。

順列テーブルを計算するためのコード：

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();
        }

    }
}
— ピーター・テイラー
ソース
王の地位をどのように推測しますか？計算には15人の男性を使用し、キングポジションには特別なビットは使用しません。
— アリンストイアン14年
@AlinStoian、おっと。私が持っていた<のではなく、<=私のプログラムの出力ループインチ それを指摘してくれてありがとう。ボードに参加している32人の男性全員を特別にケーシングすることで、以前のスコアを回復することはできましたが、今はそれを行いません。
— ピーターテイラー14年
興味深いデータ！捕獲された3人の男性との理論的な最悪のケース
— レベル川セント
@steveverrill、私が本当にやりたいことは、ポーンの位置とプロモーションの数を1つの「ブロック」にエンコードし、次にピースの位置と値をエンコードすることです。しかし、プロモーションを考慮に入れずに少なくとも2 ^ 38個のポーンポジションがあり、それらを効率的に列挙することは今のところ私を免れました。
— ピーターテイラー14年
@petertaylorボードに16個のポーンしかなく、48マスに制限されている場合、48！/ 32！/ 8！/ 8！= 29019905518636890の可能性があります。わずかに2 ^ 54以上！これらのうち、一部は違法であり、ボードの片側に1色のポーンをすべて置くことはできません。
— レベル川セント14年
5

178ビット（ピンチで174！）最悪の場合

こんにちは、コーディングに戻りましたが、私は大学から実際にやっていません。このサイトを見て、これが面白そうだと思った。私は少し理論的なチェックをしましたが、完璧なアルゴリズムには少なくとも146ビットが必要であるようです。おそらくもっと多くのことでしょう（しばらくしてコメントで説明します）。

とにかく、これは私がデータを構造化する方法です。基本的な概念は178ビットで提供されますが、いくつかのジグリーポケリーを使用すると、174（21 3/4バイト）まで下げることができます。175はプログラミングがやや簡単で、人間が読める形式で、22バイト以内です。

A）両方のキングの位置：白と黒の各12ビットに対して6ビット

B）残りの62個の正方形のうち、どれが占有されていますか？62 BITSのマトリックス

C）誰の番ですか？1ビット

総計：75ビット

D）En Passant。移動する白人の番である場合、最大5個の黒のポーンがEn Passantで捕獲できるように見えます。黒のポーンは行5（下から上にゼロから開始）にあり、横に白いポーンがなければなりません。可能なキャプチャの最大数がある1つの状況は次のようになります。

BWBBWBBW

行5に6個の黒のポーンがあった場合、白には2個の正方形しかなく、4個の黒のポーンしか脅かすことができなかったため、明らかにEn Passantからの脅威にさらされている5個を超える黒のポーンを持つことはできません。必要我々は5に番号1をその隣（この場合、白色）敵対を有する行5にポーンポーンがどの（最大5）を示すと、2つの最終ターンに正方形（高度たまたは、ゼロないポーン場合この状況では、最後のターンにこの方法で移動しました。）

E）最大30の占有された正方形（キングを含まない）に含まれるもの

10の可能性があり、それぞれ10進数で表されます。

最下位ビットは色を表します。

したがって、偶数は白、奇数は黒です。

白黒

Pawn 0/1（またはキャッスルを許可されているルーク*）

騎士2/3

ビショップ4/5

ルーク6/7

クイーン8/9

*キャッスルを許可されている（したがって、最初または最後の行から移動されていない）ルークは、6または7ではなく0または1で表されます。または最後の行。

これにより、最大30桁の10進数が得られます。これに6を掛けて、En Passantのコードを追加できます。結果の数値は103ビットに収まり、上記の75に追加すると103 + 75 = 178ビットになります。実際、単純に6ではなく10を掛けると、使用するビット数に違いはなく、デコードが容易になります。

これは、22バイトより2ビット多いだけです。ただし、以下で説明するように、174ビットにプッシュダウンできます。

ピースがキャプチャされていない場合、ポーンを昇格させることは不可能です。

その証拠は次のとおりです。ゲームの最初から（たとえば）列Eでポーンを宣伝することに夢中になっている白を想像してください。邪魔になっているこのポーンの反対側に黒いポーンがあります。したがって、このポーンをプロモートするには、次のいずれかが発生する必要があります。

1）黒のポーンがキャプチャされます。

2）黒のポーンは別の駒を捕らえるため、邪魔にならない。

3）白いポーンは、列Dなどの隣接する列のポーンをキャプチャします。

4）白のポーンが隣接する列の黒のポーンを通過（または通過）し、次に同じ隣接する列のピースをキャプチャして、白のポーンの列を変更します。

ケース4が最も興味深いのは、列Eで始まった白いポーンだけではなく、プロモーションへの明確な道筋が明らかになったためです。列Eに残っている列の黒いポーンも昇格できます。したがって、1回のキャプチャで、各色の1つのポーンが昇格する方法をクリアできます。

とにかく、駒がキャプチャされるまでポーンが昇格できないという事実は、30番目の駒を保存する必要がないことを意味します。ゲームの開始時にピースコードの完全なセットが常に同じ量= 80になるため、除去（または減算）で解決できます。1つの小さなポイントは、ルークの正方形を確保する必要があることです。ゲームの最初のスタンドは最初にスキャンされたものです（最後の場合、ルークがキャッスルできるかどうかはわかりません）。これは行0をスキャンしてから行7〜1をスキャンすることで簡単に実行できます。 8対1のスキャン行[r mod 8]。

したがって、（B）のビットのマトリックスは、（キングを除く）ピースの数を示します。完全な30がある場合、エンコード時に最後のピースを無視すると、デコーダーはそれが何であるかを判断します。現在、最大29桁の10進数があり、これに6を掛けてEn Passantコードに追加します。結果の数値は99ビットに圧縮され、合計99 + 75 = 174ビットになります。

例として、これが実際の位置です。白は彼の最初の動き（進んだ王のポーン）をしたばかりで、それは黒の番です。

rnbqkbnr
pppppppp


    P

PPPP PPP
RNBQKBNR

A）キングの位置（8進数で白/黒、12ビット）：03 73 = 000011 111011

B）どの正方形が占有されていますか？行0（一番下の行）から始めて、他のすべての行を上から下へ、キングをスキップします：

1111 111

1111 111
11111111
00000000
00000000
00001000
00000000
11110111

C）黒のターン：ターンビット= 1

D）En Passant。黒のポーンの隣に白のポーンが存在しないため、（このポーンが最後の動きを進めたとしても）パッサンントに連れて行けるポーンがないため、D = 0です。敵対的なポーンが横にあるポーンのみを考慮するのではなく、両側に友好的なピースのないポーンをすべて考慮すると、このようなポーンが1つあるため、Dは1になります。実際、ポーンは最後のターンに移動しました。

E）再び、一番下の行を最初に、次に他のすべての行を上から下へ、キングをスキップし、4つのキャッスルされていないルークを0または1と呼びます（数字は通常ポーン用に予約されています）。

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

（括弧内の）30桁目は破棄できます。

ここではあまり明確ではありませんが、白が進んだポーンは実際にはポーンのリストの一方の端にあります。これは行ごとにスキャンするためです。

データは次のようになり、正方形の内容を表す29個のコードとEn Passantコードが追加されています。 

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

デコードするときは右から左に、エンコードするときは左から右（逆順）にスキャンするのが最適です。最大の一貫性を維持しながら、より少ない部分があるときに我々は、より少ない数を持っていることを、この手段は、（つまり、我々は空白/ゼロがまばら占有ボードの圧縮を可能にするために、末尾のない、リードすることにしたい。）我々は唯一の2人の王を持っている場合ボードには、上記の75ビットに加えて、通過データを格納するための3ビット=最良の場合は78ビットがあります。追加の各断片は、3.5ビットよりわずかに小さくなります（100 <128であるため、2つの断片は7ビットで格納できます）。

99ビット整数が大きすぎて64ビット整数変数に収まらないという実用的な問題があります。これは、多くのプログラミング言語がサポートしていないことを意味します（29から30桁の文字列表現を単純に変換することはできません）整数への数。）22のバイトをコードする簡単な方法として、我々は50ビットに収まるそれぞれが2つの15桁の数字それぞれ（合計100ビットに30桁の番号（29のピースコード+ ENアンパッサンコード）を破ることができますさらに、上記の75を使用すると、175ビットが最悪のケースになります。

前述のように、最大​​圧縮の場合、29桁の10進数とEn Passantコード（6種類の値）が99ビット（合計174ビット）にほぼ適合しますが、このサイズの整数のサポートはありませんプログラムが複雑。29色のビットを分離し、色（70ビット、ほぼ64ビット変数にほぼ収まる）とは別にピース型コード（5つの可能性）およびEnパッサントコード（6つの可能性）を処理する方が簡単な場合があります。

— レベルリバーストリート
ソース
最後の男との素敵なトリック。
— ピーターテイラー14年
5

完全なソリューション、実際の最悪の場合181ビットはここにあります

ここでの焦点は、簡単に理解できるシンプルなプログラムです

入力はFEN、ここは開始位置、6つのフィールドがあります（5と6は無視されます）：

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

最初のフィールド（ピース配置）が解析されます

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

生産するには：

rnbqkbnrpppppppp________________________________PPPPPPPPRNBQKBNR

フィールド1：キングの位置をエンコードします（12ビット）：

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

フィールド2：ピースをエンコード（ピースごとに最大5ビット）：

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//

フィールド3：アクティブな色（1ビット）

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

フィールド4：キャスティングの可用性（4ビット）

m/K/?1:0
m/k/?1:0
m/Q/?1:0
m/q/?1:0
  • FIQは、このフィールドを完全に削除できることを示しています。

フィールド5：en passant（ゼロまたは3ビット）

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

素朴な最悪ケース200ビット

  • 2つのキングプレースメント-12ビット
  • ボード
    • QRRBBNN QQQQQQQQ -75ビット
    • qrrbbnn qqqqqqqq -75ビット
    • 空の正方形-30ビット
  • アクティブな色-1ビット
  • キャスリング-4ビット
  • En Passant -3ビット

実際の最悪の場合

各プレイヤーは他の駒をキャプチャしないですべてのポーンをプロモートすることはできません。ピースキャプチャのエントロピー効果を次に示します。

  • PpR（3 + 3 + 5 = 11ビット）=> Qq_（5 + 5 + 1 = 11ビット）
  • PPpp（3 + 3 + 3 + 3 = 12ビット）=> QQq_（5 + 5 + 5 + 1 = 16ビット）

実際、最悪の場合のボードは次のとおりです。

  • QRRBBNN QQQQQQQQ -75ビット
  • qrrbbnn qqqq -55ビット
  • 空の正方形-34ビット

最悪の場合は、ポーンを一時的に渡すのではなく、すべてのピースをプロモートすることです。

表示コード 12 + 75 + 55 + 34 + 1 + 4 = 181ビットの実際の最悪ケースの合計

FIQは、この単純なスキームに対して2つの改善を示していますが、コーディングはより困難です。

  • ポーンがそこに行けないため、行1および8のピースエンコーディングからビット2を削除します（最大16ビット節約）
  • ポーンを使用してキャスト可能なルークをエンコードします（4ビット節約）

（簡潔にするために）この答えに示されていない残りのコードは、フィールド（split /\s/）の入力FENを壊すことと変数の割り当てです。

— ウィリアム・エントリーケン
ソース
プレイヤーは自分のすべてのポーンをプロモートできます（敵のポーンをキャプチャできることを考えると）。Qn4QQ / Qb6 / Qq1k4 / Qr6 / Qb6 / Qr6 / Qn4NK / RNB2B1R b--0 84
— Krzysztof Szewczyk
@KrzysztofSzewczyk、はい、上記のPPpp=> で指摘されていますQQq_
— ウィリアム・エントリケン
4

合計データには33バイトが必要です

（コメントの誰かに感謝しますが、これはポーンプロモーションには機能しません。解決できたら更新します）

最初のバイトには5ビットを使用します。

  • 最初のビット：プレイヤーのターン、1 =白
  • 2番目のビット：ブラックキングサイドキャッスル、1 =キャンキャッスル
  • 3番目のビット：ブラッククイーンサイドキャッスル、1 =キャンキャッスル
  • 4番目のビット：ホワイトキングサイドキャッスル、1 =キャンキャッスル
  • 5番目のビット：ホワイトクイーンサイドキャッスル、1 =キャンキャッスル

次の32バイトは、事前に定義された順序で各チェスの駒を表すために使用されます

  • 3ビット：行を表します
  • 3ビット：列を表します
  • 1-bit：en-passantを表します、1 = can en-passant
  • 1ビット：「can en-passant」ビットが1の場合、どちらの側を示す
    か、0 =左の場合はキャプチャされたかどうかを表します。0 =キャプチャされない
    （en-passantできる場合、キャプチャされないことは間違いありません）

このアイデアを表すCコード（実際には機能しません）

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;
}
— ace_HongKongIndependence
ソース
-1、これは答えではありません...
— ドアノブ
1
ポーンが8位になり、ナイト、ビショップ、ルーク、またはクイーンに昇格した場合、事前に定義された順序はあまり役に立ちません。
— squeamish ossifrage 14年
私は、アルゴリズムに取り組んでいる雪の@Doorknobは大丈夫、それは夜だけ少し遅れだと私は疲れているので、私は少し遅く、それをやっている
— ace_HongKongIndependence
それでは、解決策さえないのになぜこれを投稿したのですか？
— ドアノブ
3
それでもこの答えがくだらないとここに価値がないと人々が思っているなら、先に進んでそれを削除して投票し、ここで私のアカウントを削除することもできます。考えられることだけを共有したいのですが、どうしてそんなに意地悪である必要があるのですか？
— ace_HongKongIndependence 14年
4

256 242ビット

以下は、特定の違法な位置が表示から除外されないため、おそらく改善できる基本的な圧縮アルゴリズムです。

ボードは、次の5ビットのヘッダー情報で始まります。

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

次に、キングの位置を表す12ビットの文字列。

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

次に、基数11の巨大な64桁の数字に9を掛けて、通過者の状態を表す別の数字を最後に追加します。基数11の各数字は、ボード上の正方形を表し、次の値があります。

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.

そして、基数9の数字：

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

11 64 ×9は約2 224.57で、エンコードには225ビットが必要です。さらに、上部の17ヘッダービットは合計242ビットです。

改善してくれたugorenに感謝します。

— ジョー・Z
ソース
これはエースのアルゴリズムに非常に似ていますが、駒の代わりにボードの位置を事前に決められた順序で使用します。
— ジョーZ. 14年
en-passantを0から8の間の1つの数値として保存できます（現在のプレイヤーがen-passantをキャプチャできるのはどの列ですか？）。13^64 * 9239.99で、11ビットを節約します。キングポジションを個別にエンコードすることでさらに節約できます。
— ウゴレン14年
私の投稿にコメントしたSnowのDoorknobによると、この種の答えは「答えではない」ということです。ただ言って。参考までに、Cコードを回答に追加する前に彼のコメントが投稿されました。
— ace_HongKongIndependence 14年
@ugoren：私はそれを忘れていました。あなたは正しい、私は1つのポーンだけが同時に通行できることを忘れていました。
— ジョーZ. 14年
@ace：エンコードとデコードのコードが含まれていないため、答えは無効ではありません。ポーンプロモーションのケースを考慮していないため無効です（この場合、事前に定義されたピースの順序は何もしません）。問題の核は、データエンコーディングスキームを求めていることです。プログラムは、それとインターフェースするためのものです。
— ジョーZ. 14年
3

？ビット

（≥最悪の場合217、最高の場合17、初期ボードの場合179）

エンコーディングの説明

追加のメタデータは、順番（1ビット）とキャスティング（4ビット、つまり王の側にある白い城、女王の側にある、黒の場合と同様）で構成されます。

ボードの位置自体については、アクティブなピースのセットとしてエンコードします。まあ、実際には、少し説明する理由のために、特定の順序でピースを列挙するようにします。各ピースについて、その色（1ビット）、その種類（6種類を含む3ビットに加えて、「通行人によって取られる可能性のあるポーン」の1種類）、およびその位置を格納します。

興味深い部分は次のとおりです。ピースを座標として保存するのではなく、ピースの位置をエンコードするために、左から右、上から下の順序でピースを列挙するときに最後のピースからの相対距離を保存します、B8、...、G1、H1）。また、我々が使用して、可変長の数として距離を格納する1、この作品は、すぐ隣前にあることを意味するように0xx、1-3個をスキップするために000xxx、4-10個をスキップするために000000xxxx、11-25のために0000000000xxxxx26から56のためそして最後000000000000000xxxに57-62。

例

このエンコードでコーディングされたいくつかの位置の要点を作成し、いくつかのコメントを付けて初期位置の注釈を付けました。

最悪の場合のビットサイズを分析する方法はわかりませんが、要点の例を見ると、アルゴリズムは少なくともある程度効率的であると考えています。

デコーダーの実装

以下は、このエンコーディングのクイックダーティデコーダです（上記の注釈の例のように、テキストでエンコードされたバイナリデータを入力として受け取り、「0」または「1」ではないものをスキップします）。Unicodeチェスボードを標準出力に作成します。

#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;
}
— ホタル
ソース
最悪の場合のビットカウントが何であるかはわかりませんが、179ビットよりかなり大きいと思われます。たとえば、アルゴリズムはこのレイアウトをどのように処理しますか？（それはある方法で、有効な、私はそれがでエディタを使用して作られたchess.com）
— うるさいossifrage
@squeamishossifrageは217ビットを必要とするようです：gist.github.com/FireyFly/8639791（テストケースのおかげで、私は
— もっと難しい
ねえ、それは悪くない。立ち止まるな！
— squeamish ossifrage 14年
2

最大：184ビット、最小：75ビット

@AdamSpeightのハフマンによる作品のコーディングに触発され、独自のスキームを作成してみました。私はこれが勝つことを疑いますが、計算可能な制限があります。

このスキームは、チェスの駒を11種類の駒があるかのように扱います。ハフマンコーディングアルゴリズムにほぼ従い、これらのクラスを周波数と実際のタイプでグループ化して、次のエンコーディングを生成しました。

 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

各ピースのコードの前に2ビットを付けて、どのチームに属しているかを示すことができます（10白の場合11、黒の場合）。 0空のスペースをエンコードするために使用できます。これらのアイデアにより、必要な手順を使用してボード全体の正方形ごとのエンコードを構築できます。反復順序を仮定しますa1, b1, c1, ... f8, g8, h8。これは、上記のようにこれらのコードをリストするだけで、誰の番であるかを除くすべての情報がエンコードされることを意味します。非常に単純なチェスエンジンは、ポーン、ルーク、キングの「クラス」を使用して、キャスティングとパッサンが合法かどうかを判断できます。さらに、このスキームはポーンプロモーションを簡単に処理します。プレイヤーがポーンをルークにプロモートする場合、「移動された」バリアントが選択されている限り、キングサイドまたはクイーンサイドのコードが使用されます。

私は考えられない病理学的位置を除いて、このエンコーディングの最悪のシナリオは、すべてのピースがまだボード上にあり、前のプレーヤーがポーンを2スペース前に移動した場合です。例として、以下のボードはエンコードし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

つまり、ワーストケースエンコーディングには184ビットがあります。プレーヤーを示すために1、空いているスペースに32、移動していないポーンに45、2スペースジャンプポーンに6、ナイトに24、司教に24ルークのための28、女王のための12、および王のための12。

断片が動き回って取り込まれると、エンコードのサイズが小さくなります。最良のシナリオは、ボード上の2人のキングのみで表されます。プレーヤーを示す1ビット+空の四角を示す62ビット+キングを示す12ビットは、最小長が75ビットです。

戻ってきて、このレスポンスを編集して、今日または明日の後半にこのエンコードを実際に実行することを実証するコードを作成します。今のところ、私は他の人がこのエンコーディングをどう思うか見てみたいです。

— 貞勝
ソース
1
ルークのビットを節約できます。位置に基づいてクイーンサイドとキングサイドを決定することができ、ムーブドルークがどちらのサイドから来たかを知る必要はありません。そのため、ルークに関する情報が少しだけ必要です-移動済みまたは未移動。
— はないチャールズ
...実際には、そのデータをピースレベルで保存するとエンコード/デコードが容易になりますが、最初にマーカーを保存しただけであれば、全体的な最悪のケース（マーカー11001手段などB'S MOVE W CAN KSC W CANT QSC B CANT KSC B CAN QSC）を節約できます。これは、エンコーディングのサイドごとに5ビットではなく、4ビット、またはルークのサイドマーカーを削除する場合はサイドごとに3ビットです。（KSC=キングズサイド城。 QSC=クイーンズサイド城）
— チャールズではない
また、プロモーションのために、最大9人のクイーンまたは10人の騎士（またはその他の非正規、非ポーンのピース）を持つことは非常に可能です
— チャールズではない
1

184ビット= 23バイトの最悪の場合、複雑すぎない：

A.占有された正方形：64ビット= 8バイトB. <= 32占有された正方形の色：32ビット= 4バイトそして、現在、非キングが占有している<= 30の正方形のみを使用：B. 5、5 ^ 30の可能性。32 * 31 * 2 * 4 * 4 * 9のキングポジション、ムーバーカラー、白と黒のキャスティング権、エンパッサンスクエア（8つの可能性のうち、9番目）。この数5 ^ 30 * 32 * 31 * 2 * 4 * 4 * 9 = 266075134277343750000000000 = 2 ^ 87.782は、エンコード全体で合計64 + 32 + 88 = 184ビットの88ビットに適合します。

これは減らすことができます。たとえば、ファクトを使用して、32 * 31 * 2 * 4 * 4 * 9 = 285696を2 *（32 * 31 + 31 * 3 + 31 * 3 + 3 * 3）* 6 = 14244に減らすことができます。最大6人の受難者の犠牲者候補（なしを含む）、ファクトキャスティング権を使用して同じセット内のキャスティング権とキングポジションをエンコードすることは、最初のスクエアのキングでのみ重要です。これにより、4ビット節約されます。

18バイトを達成することは不可能だと信じる理由があります。つまり、合法的なチェスの位置の総数が2 ^ 144を超えています。

160ビットスキームは非常に巧妙ですが、完全に自信を持つ前にエンコード/デコードプログラムとして提供する必要があると思います。

— ウォーレン・D・スミス
ソース
1

171ビットの最悪の場合：

いくつかのアイデアと、自分の考えをいくつか組み合わせました。

64ビットボードから始めます。各ビットは、ボード上の占有スペースを表します。行に沿って塗りつぶします。そのため、開始は次のようになります。1111 1111 1111 1111 0000 0000 0000 0000 0000 0000 0000 0000 1111 1111 1111 1111

これで、各ピースは4ビットで表されます。1ビット目：色（0=white, 1=black）2-4ビット目：8種類のいずれか。

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

最後に、ターンを指定するビットを含めます。0=white, 1=black。

4ビット* 32個= 128ビットで、ターンとボードからすでに64 + 1を得ています。合計128 + 64 + 1 = 193になります。私は、パッサンまたはキャスリングで始めたことがありません。何もせずに私の限界をはるかに超えています-ターンさえもしない これがトリックの始まりです。

さて、あなたは上記のタイプを見ましたか？Bishop0とBishop1？Pawn0とpawn1？これらのタイプは、この部分の後に挿入するビットを示しているため、そのように指定されています。したがって、Bishop0は、その後に0が存在すること、つまり次のピースが白であることを意味します。Bishop1は、次のピースが黒であり、pawn0とpawn1が同じように機能することを示しています。（このピースが列挙される最後のピースである場合、代わりに次のターンについて通知されます）。

私の最悪の場合、ボード上のすべてのピースが関係するため、16個のポーンと4個の司教がいるため、20ビット節約できます。173になりました。

はい。私の最悪の場合の別のビットについては-エンコードされた色が16になったら、色のエンコードを停止します-それが進むとわかっています。私の最悪のケースは、白い​​部分がキャプチャなしで遠いコーナーに到達することです。そこで、1ビットだけを保存します。172。

ここで、ピースに名前を付ける順序を変更します。外側に向かって移動する列に沿って名前を付けます。最初に名前が付けられたボードは同じままですが、その上にピースを配置すると、右下の白から始まり、その列を上に移動します。次に、黒の右下にジャンプして、その列を上に移動します。ホワイトの右下の不明なセルにジャンプします。これは、最悪の場合が再び始まりであることを意味します。私の理由は、不幸なトリック、私が失う次の2ビット、キャスティングに関係しています。

ここで、ポーンをプロモートするには（詳細に説明したとおり）、ピースをキャプチャする必要があります。したがって、32個あることがわかっている場合は、そのうち31個だけを示す必要があります。最後のピースは一意に識別されます。結局のところ、これは2ビットしか節約しません-私の最後のピースはポーン/ビショップ（次のピースに1つ保存するので通常3ビットかかります）である可能性があるためです2ビット。私は170ビットになりました。

ポーンがプロモートされると、単にタイプを変更します。ボードから外れた各ピースについて、私は（最低）3ビットを取り除き、2つのポーンプロモーションに2ビットのコストがかかったため、プロモーションを（ゆっくりと）減らしています。

キャスリング。キャスリングが発生するためには、キングもルークも移動していない可能性があります。したがって、ルークがキャスティングできる場合、ルークとキングは元の場所にいます。そのため、鋳造可能なルークはその色の王と同じ場所にリストされます。これは違法（ボード上の同じ色の2人のキングまたは3人のキング）であり、各色の3つの可能なセットアップでのみ発生するため（左、右、両方のルークがキングとしてリストされています）、デコードは完全に可能です。そのため、キャスリングはエンコードされていません。

En Passantここでは、違法なポジションも使用します。一度に1人のポーンだけが不注意の危険にさらされる可能性があります。4行目になければなりません。脆弱なポーンは、ホーム行に「反転」されます-そこにあるものと切り替えられます。そのポーンはそれ自体の最初の行（違法な位置です）であるため、状況はデコーダーに明らかです-位置を逆にし、ポーンをパッサントに対して脆弱であるとマークします。

最後の作品は「一意に識別される」必要があるため、注文をいじる必要がありました。標準的な順序では、バックコーナーのルークがキャッスルできるかどうかはわかりませんが、それは不明です。外から作業する場合、そのルークが「リスト」されている場所はどこでも、それが自分のコーナーにあるか、ボードの真ん中にあることを保証しますそれ-だから私たちはルークのタイプを知らされます。ポーンが脆弱になるには、その内部にポーンがなければならないため、その後にピースが存在することがわかります（これは、上記の手順に従って後でエンコードされます）。

ああ、最悪のケースがボード上のすべてのピースに関係することを確認するために、32ピース未満になったら、64ビットボードを使用してターンと占有位置を識別することができます。ターンし、それが黒人の場合は1がターンします。

だから私たちは無料でパタンとキャスティングを手に入れました。私たちは最後の作品を無料で手に入れましたが、それはパッサンとキャスリングのルールでそのプレイをうまくするために少し苦労しました。標準ピースには20ビットを捨てました。ここでの最悪のケースは、すべてのピースがボードに載っている間に、真ん中の白いポーンが前方に移動し、それとそのクイーンとの間に黒いピースが含まれることだと思います。クイックダブルチェック：最初のピースがキャプチャされます-ポーンと呼びます、ポーンでボードから3ビット外れ、ボード上の3ビットで最後のピースの形で、ターンマーカーで1ビット外れて消えます。ボード上の2つのポーンを2ビット昇格させます。あぁ、171歳です。

編集（動作中の？）デコーダーのコードをRに追加しました。入力としてブール値のベクトルを取ります-（申し訳ありませんが、実際にビットを使用できるようなものはうまくコーディングできません）開始位置も含めました。

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))

このコードは4つの関数を作成します。ピースとボード構造を基本的に分離し、ピースの種類と「暗黙の」ピースを把握するもの。次の関数は、ボード構造を少し奇妙な（そして私の最初のアルゴリズムとは異なる）順序でそれらのピースで埋めます（コードコメントで説明されています）。次の関数は、埋められたボードを取得し、違法な位置を検出します。それから、それらを修正し、パッサンント「x pawn-e」および「x rook-c」をキャッシングできるルークに対して脆弱なポーンの名前を変更します。最後の関数は、これらの関数を順番に実行し、現在のボードおよびターンである出力を提供するラッパーです。

開始位置のエンコードも含めました（これを確認するには、呼び出す必要がc(startboard,newpieces)あり、コードはその位置でラッパー関数を呼び出します）。

— user5957401
ソース
これは面白い。実用的な実装を概念実証として見たいです。
— メゴ
実装は通常、概念実証を超えた数ステップですが、デコーダを追加しました。これはRにあるため、ビットではなくブール値を使用します（申し訳ありませんが、あまり時間を使いたくありませんでした）。しかし、私はそれが概念実証であるべきだと信じています。
— user5957401
0

229/226ビット

これはあまり成功していないことがわかりますが、同じ道を進んでいる他の人を救うかもしれません。

簡単なバージョン：

  • 1 誰の番のためのビット
  • 4 4つのキャスティングの可能性のためのビット
  • 3エンパッサンの可能性のためのビット。これには、私が最初に理解したより多くの深さがあります。パッサンは、捕まえられたポーンと同じランク（行）から移動するポーンによって行われなければなりません。事例分析では、我々は最後の移動の色の多くのポーンが正確に2つの正方形を進めているか知っていれば、最大で6があるだろうことを示してアンパッサン（に脆弱一切のポーンがない場合などのケースエンアンパッサンは）。最悪のケースは5つのポーンです（潜在的にすべての脆弱性があります。たとえばPpPPpPPp、5つの脆弱性がありますP）。6つのポーンと最大で2つのポーンを脅かすことができ、それぞれが同じランクでせいぜい2つの敵のポーンがあるアンパッサンは。したがって、ceil(lg 6) = 3ここにビットが必要です。

それからボード。ボードには64個の正方形があるため、正方形のインデックスは6ビットでエンコードできます。私たちは男性をランク別に、色を交互に、王から順にリストします。

  • 6ビット：白王の位置。（ボード上にあることが保証されています）。
  • 6ビット：黒王の位置。（ボード上にあることが保証されています。最悪の場合、白い王が角にいる場合、60の可能性のある場所があります。最良の場合、白が縁にない場合は55です）。
  • 6ビット：白の女王の位置。白の女王がいない場合は、信号として白の王の位置を繰り返します。
  • ホワイトクイーンを追加するごとに、1ビットの後に位置が6ビット続きます。
  • Aの0ビット。
  • 黒の女王のための同上。
  • ルーク、司教、騎士、ポーンについても同様のプロセスがありますが、すでにその色の16人の男性がいる場合は、色のポーンをスキップできます。
  • 最後の0ビットを削除します。

これに12は、王には一定のコストがかかり2*7*5-1 = 69、他の男には少額がかかります。最悪の場合、32人の男性全員がボードに参加しているため7、キング以外の各男性の合計額はわずかです12 + 7*30 - 1 = 221 bits。したがって、8グローバル状態の初期ビットでは229ビットになります。

高度なバージョン：

算術コーディングを使用することで、最後に1つだけを使用するのでlg num_possibilitiesはなく、ceil(lg num_possibilities)1つだけを使用することができますceil。

  • 1 誰の番のためのビット
  • 4 4つのキャスティングの可能性のためのビット
  • lg 6エンパッサンの可能性のためのビット。
  • 6 白い王のためのビット
  • lg 60 黒王のためのビット（最悪の場合）
  • lg 63 白の女王のためのビット（私は小切手を見るレベルまで複雑にしたくないので）
  • 各追加白女王のために、1ビットは、続いてlg 62、lg 61彼女の位置のために、等ビット。
  • Aの0ビット。
  • lg 63 黒の女王のためのビット（または、白の女王がいる場合はそれ以下）。
  • 等

実際に存在するn番目の男性には、66-n可能な値があります。タイプが色に欠けている場合、それを66-#men so far記録するためにビットを費やしました（さらに、セパレーターに1ビット）。極端な場合は次のとおりです。

  1. 両側から少なくとも1人のプロモートされていないポーンを含む、すべての男性が参加します。私たちは5+lg 6、グローバルな状態、6+lg 60キング、29セパレータービット、SUM_{n=32}^{63} lg nポジションのビットに費やします。総計：ceil(225.82)ビット。がっかり。
  2. プロモーションされていないポーンのみが残ります。私たちは5+lg 6、グローバルな状態、6+lg 60キング、29セパレータービット、8*lg 63他のピースはないと言ってSUM_{n=48}^{63} lg n、ポーンの位置に費やします。総計：ceil(188.94)ビット。より良い-各側の2番目のルーク、ナイト、ビショップを保存することで、少し前に進みました。

したがって、最悪のケースは226ビットであり、わずか3の節約になりそうです。

平均的なケースでは、駒の前に64個ではなく48個の正方形に制限されているため、ポーンをエンコードすることで間違いなくより良い結果を得ることができます。男性を数えるのではなく「ポーンなし」フラグが必要になるため、これは最終的に2ビット高くなります。

— ピーター・テイラー
ソース
0

これはチェスサークルのディスカッショントピックです。

164ビットhttps://groups.google.com/forum/#!topic/rec.games.chess.computer/vmvI0ePH2kI 155を使用した1つの非常に簡単な証明を次に示します。http：//homepages.cwi.nl/~tromp /chess/chess.html

単純化された戦略：

  • ポーンを見つけることができる場所にポーンを制限します
  • オリジナルのピースと可能なポーンプロモーションを考慮して軍隊を制限する
  • プロモーションとプロモーションが不可能な状況について真剣に考える
— ウィリアム・エントリーケン
ソース
2
リンクのみの回答は良い回答ではありません。回答へのリンクだけでなく、投稿内で完全な回答を提供する必要があります。そして、あなたの答えがあなた自身の仕事ではないなら、おそらくあなたの投稿をコミュニティwikiにするべきです。
— ace_HongKongIndependence 14
投稿はオリジナルです。回答に詳細を追加します。
— ウィリアム・エントリケン14
1
これは、回答にコンテンツを含める理由の例です。2番目のリンクは無効です。これでしょうか？tromp.github.io/chess/chess.html
— mbomb007
-2

最小：0ビット

最大： 1734 243ビット（4.335 4.401ビット/ボード償却）

期待される： 351 177ビット（4.376 4.430ビット/ボード償却）

ただし、入力と出力を決定できるので、この時点までゲームの履歴をエンコードすることにしました。利点の1つは、誰がターンをするかという追加情報が通行人であり、誰がエンコード可能でエンコードできない場所をキャッスルできるかということです。

試行1：

単純に、各動きを12ビット、4つのトリプレットの形式（開始x、開始y、終了x、終了y）でエンコードでき、それぞれが3ビットであると考えました。

開始位置を想定し、そこからピースを移動し、白が最初になります。ボードは（0、0）が白の左下隅になるように配置されます。

たとえば、ゲーム：

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

次のようにエンコードされます。

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

これにより、12 mビットのエンコードが行われます。mは、行われた移動の数です。

一方で、これは非常に大きくなる可能性がありますが、他方では、各動きが独自のゲームであるとみなすことができるため、各エンコードは実際にm個の「チェスボード」をエンコードします。これを償却すると、各「チェスボード」が12ビットであることがわかります。しかし、私はこれが少し不正行為だと感じています...

試行2：

私は、以前の試みの各動きが多くの違法な動きをエンコードしていることに気付きました。そこで、合法的な動きのみをエンコードすることにしました。可能な動きを次のように列挙し、各正方形に（0、0）→0、（1、0）→1、（x、y）→x + 8 yのように番号を付けます。タイルを反復処理し、ピースがそこにあるかどうか、また動くことができるかどうかを確認します。その場合は、位置を追加してリストに移動できます。移動するリストインデックスを選択します。その数値を、1に可能な移動の数を加えた重みで表した移動の合計に加算します。

上記の例：開始位置から移動できる最初のピースは、正方形1の騎士であり、正方形16または18に移動できるため、それらをリストに追加します[(1,16),(1,18)]。次は、スクエア6のナイトです。動きを追加します。全体的に得られるもの：

[(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)]

移動（12、28）が必要なので、20の可能な移動があるため、これを基数20で13としてエンコードします。

そこで、ゲーム番号g 0 = 13 を取得します

次に、移動のリストを取得するためにタイルを逆順に番号付けする（必要に応じて簡単にするため）以外は、黒についても同じことを行います。

[(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)]

移動（11、27）が必要なので、20の可能な移動があるため、これをベース20の11としてエンコードします。

そこで、ゲーム番号g 1 =（11⋅20）+ 13 = 233 を取得します

次に、次の白の動きのリストを取得します。

[(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)]

移動（6、21）が必要なので、29の可能な移動があるため、これをベース29で13としてエンコードします。

したがって、ゲーム番号g 2 =（（13⋅20）+ 11）20 + 13 = 5433を取得します

次に、黒の次の動きのリストを取得します。 [(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)]

移動したいので$（10、18）$（10、18）

したがって、ゲーム数g 3 =（（（19⋅29 + 13）20）+ 11）20 + 13 = 225833

そして、残りのすべての動きに対してこのプロセスを続けます。gは関数g（x、y、z）= x y + zとして考えることができます。したがって、g 0 = g（1、1、13）、g 1 = g（g（1、1、11）、20、13）、g 2 = g（g（g（1、1、13）、20、 11）、20、13）、g 3 = g（g（g（g（g（1、1、19 ）、29、13）、20、11）、20、13 ）

ゲーム番号g 0をデコードするには、最初の位置から開始し、可能なすべての動きを列挙します。次に、g 1 = g 0 // l、m 0 = g 0％lを計算します。ここで、lは可能な移動の数、「//」は整数除算演算子、「％」はモジュラス演算子です。g 0 = g 1 + m 0を保持する必要があります。次に、m 0を移動して繰り返します。

上記の例から、g 0 = 225833の場合、g 1 = 225833 // 20 = 11291およびm 0 = 225833％20 =13。次に、g 2 = 11291 // 20 = 564およびm 1 = 11291％20 = 11。g 3 = 11291 // 20 = 564およびm 2 = 11291％20 =11。したがって、g 4 = 564 // 29 = 19 and_m_ 3 = 564％29 = 13.最後にg 5 = 19 // 29 = 0およびm 4 = 19％29 = 19。

このようにゲームをエンコードするために何ビットが使用されますか？

簡単にするために、各ターンに常に20の動きがあり、最悪のシナリオでは常に最大の19を選択するとします。得られる数は19⋅20 mです

+ 19⋅20 m-1 + 19⋅20 m-2 +⋯+ 19⋅20 + 19 = 20 m + 1 − 1ここで、_mは動きの数です。20 m + 1 − 1 をエンコードするに は、約（m + 1）∗ log 2 （20）= 4.3219 ∗（m + 1）で ある約log 2 （20 m + 1）ビットが必要です

平均してm = 80（プレーヤーあたり40の動き）であるため、これにはエンコードに351ビットが必要です。多くのゲームを録画する場合、各数値に必要なビット数がわからないため、ユニバーサルエンコーディングが必要になります。

m = 400（プレーヤーごとに200の移動）の場合の最悪のケースであるため、エンコードには1734ビットが必要です。

エンコードする位置は、ルールに従うことでそこに到達するための最短パスを介して与えられなければならないことに注意してください。たとえば、ここで理論化されたゲームは、最終位置をエンコードするためにm = 11741を必要としません。代わりに、幅優先検索を実行して、その位置への最短パスを見つけ、代わりにエンコードします。すべてのチェスのポジションを列挙するためにどれだけ深くする必要があるかはわかりませんが、400は過大評価であると思われます。

迅速な計算：

12個のユニークなピースがあるか、正方形が空になっている可能性があるため、チェスボードに配置するには13 64です。多くの無効なポジションが含まれているため、これは非常に過大評価です。私たちがしている場合は、m個のゲームに移動し、私たちは約20作成したm個の位置を。したがって、20 m = 13 64の場合を探しています。両側を記録して、m = 64 * log 20（13）= 54.797を取得します。これは、55の動きで任意の位置に到達できることを示しています。

今、私がする最悪の場合を計算していることメートル 55ではない= メートル、私は私の結果を= 400を編集します。m = 55の位置をエンコードするには243ビットかかります。また、平均的なケースはm = 40程度であり、エンコードに177ビットかかると言います。

以前の償却引数を使用すると、1734ビットで400個の「チェスボード」をエンコードするため、最悪の場合、各「チェスボード」は4.335ビットを占有します。

g = 0は有効なゲームを意味することに注意してください。これは、最も低い正方形のピースが可能な限り最も低い正方形に移動するゲームです。

その他の注意事項：

ゲーム内の特定の位置を参照する場合は、インデックスをエンコードする必要があります。これは手動で追加することができます。たとえば、インデックスをゲームに連結するか、各ターンで可能な最後の動きとして「エンド」ムーブを追加します。これは、負けたプレーヤー、または引き分けに同意したプレーヤーを示すために2つ続けてプレーヤーを説明できます。これは、ゲームが位置に基づいてチェックメイトまたはステイルメイトで終了しなかった場合にのみ必要です。この場合、それは暗黙的です。この場合、必要なビット数は平均で356、最悪の場合は1762になります。

— 鋭い
ソース
1
「償却」引数が機能しません。目標は、ユーザーが指定したボードをエンコードすることです。このボードをエンコードするコストを、途中で生成する可能性のある400個の補助ボードに分割することはできません。（これは、これらの400枚のボードがユーザーによって独立して選択され、チェスゲームを形成するための要件に制約されない場合にのみ問題ありません。）また、チェスゲームは理論的に何千もの動きを取ることができ、最悪の場合に興味があることを明確にします。
— アンダースカセオルグ
@AndersKaseorg：非常に本当です。それは本当に目的に依存します。他のすべてのアルゴリズムを使用してゲーム全体を保存しようとすると、m * cバイトが必要になります。ここで、mは移動数、cは出力のサイズです。したがって、160ビットソリューションを使用して80の移動ゲーム全体を保存しようとすると、12800ビットが必要になりますが、私の場合は351だけになります。競争のために、私はあなたが正しいことを認めますボードだけでなくゲーム全体を保存することが非常に一般的であるため、指摘します。
— エッジの効いた
目的は明確です。「目標は、そのターンのプレーヤーのすべての動きの可能性を決定するために使用できる（一度デコードされた）チェス盤の最小の表現を作成することです。…スコアは最悪のシナリオで決定されます
— Anders Kaseorg
@AndersKaseorg：曖昧だと主張したことはありません。別のアプローチを取ることにしました。注意すべきことの1つは、アルゴリズムを使用して最小のボードを見つけるには、この位置に到達するために最小のパスが必要だということです。たとえば、同じボードの位置に到達するためにリンクした11741ターンゲームでは、ボードだけが必要な場合は、そのパスをたどる必要はありません。それで、リンクされたゲームをエンコードするために、200ターン以下の正方形に2人の王が残っている最短のゲームを見つけました。これは、深さ優先検索で実行できます。
— エッジの効いた
すべてのポジションが200ターン以下で到達可能であることを実際に証明できる場合、より短い同等のゲームを使用することは問題ありません（現時点ではこれは単なる推測のように見えます）。また、100を超える合法的な移動でチェスのポジションを考慮する必要があります。ただし、建設中に発生しないことを証明できる場合を除きます。このチャレンジのルールでは、結果をゲーム内の動きの数で割ることはまだ許可されていません。
— アンダースカセオルグ
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.