問題：

チェスでは、繰り返しによる引き分けについて、ある程度よく知られているルールがあります。同じ位置が3回（またはそれ以上）繰り返される場合、この繰り返しを引き起こす動きをしようとするプレーヤーは引き分けを要求できます。

最後のいくつかの動きが単にプレイヤーが前後に動いている場合、これはアービターが見つけやすいタスクである場合があります。ピースが繰り返される位置間で大幅に移動した場合、それはささいなことではありません。

この課題の問題は、座標表記の動きのリストが与えられた場合、主張された位置が繰り返しによって描画された場合（3回以上見られた場合）、主張された位置が繰り返しによって描画されない場合に偽の値を出力することです以下で説明するように、または選択した表記（ただし、テストケースを変換する必要があります）。

ポジションとは何ですか？

現実の世界のシナリオでは、位置は、プレイヤーがキャッスルできるかどうか、または通行人が可能かどうかなどの影響を受けます。これらを問題の解決策で考慮するべきではありません。この問題では、ボード上のピースの構成によって位置が簡単に定義されます。したがって、この問題の目的のために、両方のボード上の各正方形が同じ色の同じタイプのピースで占められている場合、2つの位置は同じであると見なされます。これは正確なピースである必要はありません。たとえば、白の騎士は正方形を入れ替えることができ、他のすべてのピースが基準を満たす場合、これは同じ位置になります。

有効な表記法はどのようなものですか？

座標表記について説明しますが、選択した表記システムで自由に入力できます。提供するもの：

• 表記法の各項目は、次のいずれかまたはすべてを説明しています。チェック、チェックメイト、ダブルチェック、チェックメイト、またはステイルメイトが配信されたかどうか。受動的なキャプチャが発生した場合。初期位置; 最終的な位置。
• 表記に繰り返しに関する情報がない場合があります。

したがって、これらの基準が満たされている限り、回答で指定する限り、表記法を受け入れます。これは、たとえば、0インデックス行、列タプル、またはプログラムにとって意味のあるものになります。

座標表記

座標表記は、純粋に動きを座標系として記述する表記です。

動きは、最初にセットからの初期座標として{A1-H8}、次に同じセットからの宛先座標として再び記述されます。だから、王のギャンビットは（文字列のコレクションとして）のようになります

{"E2-E4","E7-E5","F2-F4"}

チェックが発生したかどうか、ピース移動の種類などの外部情報が散らばっていないため、この問題に使用するのに最適な表記法であると考えています。前に述べたように、表記法は任意であるため、代数表記法などの別の表記法を使用したり、この表記法を適用したりできます（ダッシュを削除するか、タプルのリストとして取得します）

ルール：

• ポジションまたはムーブが有効かどうかを考慮すべきではなく、それが繰り返しを引き起こすかどうかだけを考慮すべきです
• キャスリングとポーンのプロモーションは行われないと想定できます。
• 入力として文字列のリストを取得し、最後の移動で3回目（またはそれ以上）の繰り返しが発生したかどうかに対応する真偽値または偽値を出力する必要があります。
• ゲームは常にチェスの標準的な開始位置から始まります。初期位置は繰り返しにカウントできます。
• 最終移動で位置が繰り返されない場合、繰り返しによる描画は発生していません

一般的なルール：

• これはcode-golfであるため、バイト単位の最短回答が優先されます。
  コードゴルフ言語では、非コードゴルフ言語で回答を投稿することを妨げないでください。「任意の」プログラミング言語の可能な限り短い答えを考えてみてください。
• 標準のルールがデフォルトのI / Oルールを使用した回答に適用されるため、STDIN / STDOUT、適切なパラメーターと戻り値型、完全なプログラムを持つ関数/メソッドを使用できます。あなたの電話。
• デフォルトの抜け穴は禁止されています。
• 可能であれば、コードのテストへのリンク（TIOなど）を追加してください。
• また、回答の説明を追加することを強くお勧めします。

テストケース

以下について真理値を返す必要があります。

{"B1-C3","B8-C6","C3-B1","C6-B8","B1-C3","B8-C6","C3-B1","C6-B8"} 
{"B1-C3","B8-C6","C3-B1","C6-B8","B1-C3","B8-C6","C3-B1","C6-B8","B1-C3","B8-C6","C3-B1","C6-B8"}
{"B1-C3","B8-C6","D2-D4","D7-D5","D1-D3","D8-D6","C3-B1","C6-B8","B1-C3","B8-C6","D3-D1","D6-D8","D1-D3","D8-D6"}
{"D2-D4","B8-C6","E2-E4","C6-D4","D1-E2","D4-E6","E2-F3","E6-D4","F3-D1","D4-C6","D1-E2","C6-D4","E1-D1","D4-C6","D1-E1","C6-D4"}
{"B1-C3","B8-C6","C3-B1","C6-B8","B1-C3","B8-C6","C3-B1","C6-B8","B1-C3","B8-C6","C3-B1","C6-B8","B1-C3"}

およびfalsey値：

{}
{"E2-E4","E7-E5","F2-F4"}
{"B1-C3","B8-C6","C3-B1","C6-B8","B1-C3","B8-C6","C3-B1","C6-B8","F2-F4","F7-F5"}
{"E2-E4","E7-E5","G1-F3","B8-C6","F1-C4","G8-F6","F3-G5","D7-D5","E4-D5","F6-D5","G5-F7"}
{"D2-D4","B8-C6","E2-E4","C6-D4","D1-E2","D4-C6","E2-D1","C6-D4","D1-E2","D4-C6","E2-D1"}
{"B1-C3","B8-C6","C3-B5","C6-B4","B5-D4","B4-D5","D4-C6","D5-C3","C6-B8","C3-B1","B8-C6","B1-C3","C6-B8","C3-B1"}
{"E2-E4","E7-E5","D1-E2","E8-E7","E1-D1","D8-E8","E2-E1","E7-D8","E1-E2","E8-E7","E2-E1","E7-E8"}

APL（Dyalog Extended）、55 49 47 45 44 バイト^SBCS

-4 ngnに感謝します。

完全なプログラム。逆座標ペアの逆リストのためのプロンプト：
 例えば{"B1-C3","B8-C6"}です[[[8,2],[6,3]],[[1,2],[3,3]]]

2≤≢s∩{0,∘⊃@⍺⊃s,←⊂⍵}/⎕,⊂(⊖⍪-)¯4↑⍉6,⍪5,∘⌽⍥⍳s←3

オンラインでお試しください！（CoordsOPの形式を変換するユーティリティ関数を含む）

状態のリストを設定します。

s←3 に3を割り当てますs（状態の場合）

3は有効なボードの状態ではないため、繰り返し回数には影響せず、割り当てのパススルー値が必要です…

チェス盤表現を構築します。

5…5から3の間に次の派生関数を適用した結果を破棄します。
 ⍥⍳ 両方の引数をそれらのɩndicesに拡張します。
  [1,2,3,4,5]… [1,2,3]
 ,∘⌽ 左側が右側の逆に連結され、
  [1,2,3,4,5,3,2,1]これが役員を表します

⍪ テーブルにする;
 [[1],
  [2],
  [3],
  [4],
  [5],
  [3],
  [2],
  [1]]

6, ポーンを表す6を（各行に）追加します。
 [[6,1],
  [6,2],
  [6,3],
  [6,4],
  [6,5],
  [6,3],
  [6,2],
  [6,1]]

⍉ 転置;
 [[6,6,6,6,6,6,6,6],
  [1,2,3,4,5,3,2,1]]

¯4↑ 負の（つまり最後の）4（行）を取り、空の正方形を表すゼロでパディングします。
 [[0,0,0,0,0,0,0,0],
  [0,0,0,0,0,0,0,0],
  [6,6,6,6,6,6,6,6],
  [1,2,3,4,5,3,2,1]]

(… ) 次の暗黙関数を適用します：

 - 否定（これは反対の色を表します）;
  [[ 0, 0, 0, 0, 0, 0, 0, 0],
   [ 0, 0, 0, 0, 0, 0, 0, 0],
   [-6,-6,-6,-6,-6,-6,-6,-6],
   [-1,-2,-3,-4,-5,-3,-2,-1]]

  ⊖⍪ その上に反転した議論を積み重ねて、私たちに完全なボードを与えます。
  [[ 1, 2, 3, 4, 5, 3, 2, 1],
   [ 6, 6, 6, 6, 6, 6, 6, 6],
   [ 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],
   [-6,-6,-6,-6,-6,-6,-6,-6],
   [-1,-2,-3,-4,-5,-3,-2,-1]]

移動のリストとそれに続く初期状態を作成します。

⊂ それを囲みます（単一のユニットとして扱うため）

⎕, 移動のリストを要求し、それを初期状態に追加します

リストに現在の状態を追加して移動する関数により、Reduce *を実行します。

{… }/ 次の匿名ラムダで削減します。

 ⍵ 正しい引数（現在の状態）

 ⊂ ユニットとして扱うためにそれを囲みます

 s,← 状態のリストにインプレースで追加します

 ⊃ その状態を使用するためにそれを開示する

 ... @⍺ 左引数が表す二つの座標を持つ要素に、置く：
  0 ゼロ
  , に続く
  ∘ ことによって
  ⊃ 最初の値を
^{、この効果的に「移動する」第一の値がゼロを残し、第2座標への座標}

最終状態が3つ以上あるかどうかを確認します。

s∩ すべての状態とその最終状態との交差点。それと同一の状態のサブセット

≢ それらを集計します

2≤ 2つ以上（最終状態を含む3つ以上）があるかどうかを確認します

* APLは右結合なので、最初に関数が初期引数を右引数として、初期移動を左引数として呼び出され、その結果である新しい状態が新しい右引数になり、2番目の移動を新しい左引数として、など。最終結果は

R、180の 177 144バイト

function(M,`+`=rep,l=c(1:5,3:1,6+8,0+16)){z=rev(Reduce(function(x,y){x[y[2:1]]=x[y]*1:0;x},M,c(l,-rev(l)),,T));sum(sapply(z,identical,el(z)))>2}

オンラインでお試しください！

-3バイトジュゼッペのおかげで
-29のニック・ケネディの使用のおかげでバイトReduceして-rev(l)
-4反転させることによりバイトz

入力として、正方形を表す1〜64の整数のベクトルを取ります。TIOには、その形式に変換する機能が含まれています。異なる部分は、1〜6および-1〜-6の整数として保存されます。

説明：

function(M,                                # M is the vector of moves 
         `+` = rep,
         l = c(1:5, 3:1, 6 + 8, 0 + 16)) { # initial position of white pieces
  z = rev(Reduce(function(x, y) {
    x[y[2:1]] = x[y] * 1:0                 # a piece moves from y[1] to y[2]; y[1] becomes 0
    x
  }, M, c(l, -rev(l)), , T))
  sum(sapply(z, identical, el(z))) > 2    # find number of past positions identical to the last position
}

ゼリー、41 37バイト

Ø0;6x8;“Ġ²F’D¤UN;ƊW;µị@⁹Ṫ¤¦0⁹¦$\ċṪ$>1

オンラインでお試しください！

入力を1インデックス付き行優先移動のペアのリストとして受け取り、[from, to]描画の場合は1を、そうでない場合は0を返すモナドリンク。

TIOのフッターコードは、OPによって提供される動きを数値形式に変換しますが、質問の下の議論では、数値形式は有効な入力であることに注意してください。

説明

Ø0                                    | 0,0
  ;6                                  | concatenate to 6 (pawn)
    x8                                | repeat each 8 times (two blank rows and 1 row of pawns)
      ;“Ġ²F’D¤                        | concatenate to 1,2,3,4,5,3,2,1
              UN;Ɗ                    | concatenate a negated flipped version to this one
                  W;                  | wrap as a list and concatenate the input list to the board
                    µ                 | start a new monadic chain
                              $\      | reduce using the two links below
                     ị@⁹Ṫ¤¦           | replace the item pointed to by the second coordinate by the value of the one at the first
                           0⁹¦        | replace the item at first coordinate with zero
                                ċṪ$   | finally count the items equal to the final one (not including it)
                                   >1 | and check of >1

JavaScript（Node.js）、 121  111バイト

[sq0, sq1]$[0..63]$$\text{a8}=0$$\text{b8}=1$$\text{h1}=63$

ブール値を返します。

a=>[a,...a].map(([x,y])=>r=b[b[b[y]=b[x],x]=0,b]=-~b[b],b=[...'89ABCA981111111'+10n**32n+0x7e5196ee74377])&&r>2

オンラインでお試しください！

どうやって？

個

ピースの種類ごとに一意の値が1つある限り、ピースの識別に使用される値は実際には重要ではありません。

を使用しております：

• 空の正方形の場合は0
• 1 / 8 / 9 / A / B / C ♟/♜/♞/♝/♛/♚用
• 2 / 3 / 4 / 5 / 6 / 7ため♙/♖/♘/♗/♕/♔

ボードと初期位置

ボードは配列に保存されます $b$ 次の部分の連結を分割することにより初期化されます：

• '89ABCA981111111' →8つの黒の主要なピース、その後に最初の7つの黒のポーン
• 10n**32n →最後の黒のポーン $\text{h7}$ （$1$）に続いて32個の空の四角（$0$）
• 0x7e5196ee74377→すべての白い部分（222222223456754310進数で消費）

その結果：

    a b c d e f g h
  +----------------
8 | 8 9 A B C A 9 8
7 | 1 1 1 1 1 1 1 1
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 | 0 0 0 0 0 0 0 0
2 | 2 2 2 2 2 2 2 2
1 | 3 4 5 6 7 5 4 3

位置の追跡

変数 $b$また、遭遇したすべての位置を追跡するオブジェクトとして使用されます。各ポジションのキーは$b$しかし、今回は配列として、文字列に暗黙的に強制されます。

これが私たちが行う理由です：

b[b] = -~b[b]

コメント済み

a =>                    // a[] = input
  [ a,                  // dummy entry to mark the initial position as encountered once
    ...a                // append the actual data
  ].map(([x, y]) =>     // for each pair of squares [x, y] in this array:
    r =                 //   store the last result in r
    b[                  //   update b[b]:
      b[                //     update b[x]:
        b[y] = b[x],    //       set b[y] to b[x]
        x               //       set b[x] ...
      ] = 0,            //     ... to 0
      b                 //     set b[b] ...
    ] = -~b[b],         //   ... to b[b] + 1 (or 1 if b[b] is undefined)
    b = [...(…)]        //   initialize b[] (see above)
  )                     // end of map()
  && r > 2              // return true if the last result is greater than 2

ジャワ10、336の 330 287 285 282 276バイト

m->{var V=new java.util.HashMap();int i=64,A[]=new int[i];var t="";for(;i-->0;)t+=A[i]=(i%56<8?i%8*35%41%10%8+2:9>>i/16&1)*(i/32*2-1);V.put(t,1);for(var a:m){for(t="",A[a[1]]=A[a[0]],A[a[0]]=0,i=64;i-->0;)t+=A[i];V.compute(t,(k,v)->v!=null?(int)v+1:1);}return(int)V.get(t)>2;}

に変更することにより、@ Arnauldのおかげで-11バイトi%56<8?"ABCDECBA".charAt(i%56%7):i%48<16?1:0i%56<8?i%8*35%41%10%8+2:9>>i/16&1。

整数の2D配列として入力 $a1=0, b1=1, ..., h8=63$（つまりは{"E2-E4",...あります[[12,28],...）。

オンラインでお試しください。

説明：

m->{                   // Method with 3D character array parameter and boolean return-type
  var V=new java.util.HashMap();
                       //  Create a Map to store the occurrences of the board-states
  int i=64,            //  Index integer, starting at 64
      A[]=new int[i];  //  Create the 8 by 8 board
  var t="";            //  Temp-String, starting empty
  for(;i-->0;)         //  Loop `i` in the range (64,0]:
    t+=                //    Append the string `t` with:
      A[i]=            //     Fill the `i`'th cell with:
        i%56<8?        //      If it's either the first or eighth row:
         i%8*35%41%10%8+2
                       //       Fill it with 2,7,3,5,9,3,7,2 based on index `i`
        :9>>i/16&1)    //      Else if it's either the second or seventh row:
                       //       Fill it with 1
                       //      Else (the third, fourth, fifth, or sixth rows):
                       //       Fill it with 0
        *(i/32*2-1);   //      Then multiply it by -1 or 1 depending on whether `i`
                       //      is below 32 or not
  V.put(t,1);          //  Then set string `t` in the map to 1 for the initial state
  for(var a:m){        //  Loop over each of the input's integer-pairs:
    for(t="",          //   Make the String empty again
        A[a[1]]=       //   Set the to-cell of the current integer-pair of the input to:
          A[a[0]],     //    The value in the from-cell of the same integer-pair
        A[a[0]]=0,     //   And then empty this from-cell
        i=65;i-->0;)   //   Inner loop `i` in the range (64,0]:
          t+=A[i];     //    Append the `i`'th value to the String `t`
    V.compute(t,(k,v)->v!=null?(int)v+1:1);}
                       //   Increase the value in the map for String `t` as key by 1
  return(int)V.get(t)  //  Return whether the value in the map for the last String `t`
          >2;}         //  is at least 3

埋めた後のピースの値A[i]=(i%56<8?i%8*35%41%10%8+2:9>>i/16&1)*(i/32*2-1)は次のとおりです。

     a  b  c  d  e  f  g  h
  +------------------------
1 | -2 -7 -3 -5 -9 -3 -7 -2
2 | -1 -1 -1 -1 -1 -1 -1 -1
3 |  0  0  0  0  0  0  0  0
4 |  0  0  0  0  0  0  0  0
5 |  0  0  0  0  0  0  0  0
6 |  0  0  0  0  0  0  0  0
7 |  1  1  1  1  1  1  1  1
8 |  2  7  3  5  9  3  7  2

オンラインでお試しください。

炭、62バイト

≔↨²³⁴⁵⁶⁴³²χηＦ⁴⁸⊞η÷⁻⁴⁰ι³²Ｆ…η⁸⊞η±ιＦθ«⊞υ⮌η§≔η⊟ι§η§ι⁰§≔η⊟ι⁰»›№υ⮌η¹

オンラインでお試しください！リンクは、コードの詳細バージョンです。正方形が番号付けされている数値のペアの配列として入力を受け取りA1、B1...、H8そう例えば、最初のテストケースのように表現される（0インデックス）[[[1, 18], [57, 42], [18, 1], [42, 57], [1, 18], [57, 42], [18, 1], [42, 57]]]と出力-位置が繰り返しによって引き分けである場合。変換プログラム。 すべてを1つに。説明：

≔↨²³⁴⁵⁶⁴³²χη

数字23456432を個々の数字に分割します。これらは白い部分を表しています。

Ｆ⁴⁸⊞η÷⁻⁴⁰ι³²

ポーンと空の行を追加します。白いポーンには価値が1あり、黒いポーンには価値があり-1ます。

Ｆ…η⁸⊞η±ι

黒い部分を表す白い部分の否定コピーを追加します。

Ｆθ«

動きをループします。

⊞υ⮌η

ボードのコピーを保存します。（反転は、ボードをコピーする最も簡単な方法です。）

§≔η⊟ι§η§ι⁰

ソース部分で宛先を更新します。

§≔η⊟ι⁰

ソースピースを削除します。

»›№υ⮌η¹

現在位置が以前に複数回表示されたかどうかを判別します。

C＃（Visual C＃Interactive Compiler）、204バイト

n=>{var j=new List<char[]>();var d=("ABCDECBATTTTTTTT"+new string('Z',32)+7777777712345321).ToArray();foreach(var(a,b)in n){j.Add(d.ToArray());d[b]=d[a];d[a]='Z';}return j.Count(r=>r.SequenceEqual(d))>1;}

入力を整数のタプルのリストとして受け取ります。最初の整数は移動元であり、2番目の整数は移動先です。0はA1、1はA2、63はH8を表します。

オンラインでお試しください！

n=>{
  var j=new List<char[]>();    //Initialize a list to save states of a board
  var d=("ABCDECBATTTTTTTT" +  //White pieces
  new string('Z',32) +         //Empty spaces
  7777777712345321)            //Black pieces
  .ToArray(); //Initialize the chessboard
  foreach(var(a,b)in n){       //Foreach (source square, destination square) in the input
    j.Add(d.ToArray());        //  Add the current board to the list
    d[b]=d[a];                 //  Set the destination square to the source square's value
    d[a]='Z';                  //  And set the souce square to empty
  }
  return j.Count(         //Return that the amount...
    r=>r.SequenceEqual(d) //  of past positions that are equal to the current position...
  )>1;                    //is at least two
}

Java（JDK）、246 245 244バイト

import java.util.*;n->{var j=new ArrayList<char[]>();var d=("ABCDECBATTTTTTTT"+"".repeat(32)+7777777712345321l).toCharArray();for(var k:n){j.add(d.clone());d[k[1]]=d[k[0]];d[k[0]]=1;}return j.stream().filter(x->Arrays.equals(d,x)).count()>1;}

オンラインでお試しください！

import java.util.*;                   //Import the java.util package

n->{                                  //Function taking in int[][], 
                                      //where each int[] is a a pair of numbers
  var j = new ArrayList<char[]>();    //List to save each position of the chessboard
  var d =                             //The chessboard's starting position
    ("ABCDECBATTTTTTTT" +             //  All the white pieces
    "&#1".repeat(32) +                //  Plus the empty squares
    7777777712345321l)                //  And the black pieces
  .toCharArray();                     //Split to array of chars
  for(var k:n){                       //Foreach [sourceSquare, destinationSquare] in input
    j.add(d.clone());                 //  Add the current position to the list
    d[ k[1] ] = d[ k[0] ];            //  Set the destination square's value
                                      //  to the source squares
    d[ k[0] ] = 1;                    //  And clear the source square 
}                                     //End foreach
return j.stream()                     //Convert list of states to stream
  .filter(x ->                        //Filter each position by
    Arrays.equals(d,x)                //  if the position equals the final position 
  ).count() > 1;                      //And return if there are at least two
                                      //positions that are left
}