Problem:

W szachach istnieje dość dobrze znana zasada losowania przez powtarzanie. Jeśli ta sama pozycja zostanie powtórzona 3 razy (lub więcej), gracz zamierzający wykonać ruch, który spowoduje to powtórzenie, może ubiegać się o remis.

Czasami jest to łatwe zadanie dla arbitra, jeśli kilka ostatnich ruchów to tylko gracze poruszający się do tyłu i do przodu. Czasami jest to mniej banalne, gdy elementy przesunęły się znacznie między powtarzanymi pozycjami.

Problemem w tym wyzwaniu jest wyprowadzenie prawdziwej wartości, jeśli zadeklarowana pozycja jest losowana przez powtórzenie (było widziane 3 razy lub więcej) i wartość falsey, jeśli zadeklarowana pozycja nie jest losowana przez powtórzenie, biorąc pod uwagę listę ruchów w notacji współrzędnych zgodnie z opisem poniżej lub dowolną wybraną notacją (ale będziesz musiał przekonwertować przypadki testowe).

Jaka jest pozycja?

W prawdziwym scenariuszu na pozycję wpływ miałyby takie rzeczy, jak to, czy gracz może zamek, czy też możliwe jest użycie umiejętności en-passant; należy nie uważają tych w rozwiązanie problemu. W tym problemie pozycja jest definiowana po prostu przez konfigurację elementów na planszy. Tak więc, dla celów tego problemu, dwie pozycje są uważane za takie same, jeśli każdy kwadrat na obu planszach jest zajęty przez ten sam typ kawałka tego samego koloru. Nie musi to być dokładny element, na przykład rycerze biali mogą zamieniać kwadraty, a jeśli wszystkie inne elementy spełniają kryteria, nadal byłaby to ta sama pozycja.

Jak wygląda poprawna notacja?

Chociaż przejdę do wyjaśnienia notacji współrzędnych, masz swobodę przyjmowania danych przez wybrany przez siebie system notacji. Pod warunkiem że:

• Każda pozycja w notacji opisuje którekolwiek lub wszystkie z następujących elementów: część / części, których to dotyczy; czy dostarczono czek, mat, podwójny czek, mat lub pat; jeśli nastąpiło przechwycenie en-passant; pozycja początkowa; ostateczna pozycja.
• W notacji możesz nie mieć informacji o powtórzeniach.

Tak długo, jak te kryteria są spełnione, z przyjemnością akceptuję, o ile w odpowiedzi określisz swój system notacji. Może to być np. Indeksowany wiersz, krotki kolumn lub cokolwiek innego, co ma sens dla twojego programu.

Notacja współrzędnych

Notacja współrzędnych to notacja, która opisuje ruchy jako układ współrzędnych.

Ruch jest opisywany jako pierwsza początkowa współrzędna z zestawu, {A1-H8}a następnie współrzędna docelowa ponownie z tego samego zestawu. Tak wyglądałby Gambit Króla (jako zbiór strun)

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

Uważam, że jest to najlepsza notacja do zastosowania w przypadku tego problemu, ponieważ nie jest zaśmiecona dodatkowymi informacjami, takimi jak informacja o tym, czy nastąpiło sprawdzenie lub jaki jest rodzaj ruchu elementu. Jak wspomniano wcześniej, notacja może być do wyboru, więc możesz użyć innej notacji, np. Notacji algebraicznej lub możesz ją dostosować (np. Usunąć myślniki lub wziąć jako listę krotek)

Zasady:

• Należy nie rozważy, czy stanowisko lub ruch jest ważny, tylko czy to powoduje powtórzenie
• Możesz założyć, że promocja roszowania i pionków nie nastąpi.
• Powinieneś wziąć listę ciągów jako dane wejściowe i wyprowadzić prawdziwą lub falsey wartość odpowiadającą temu, czy trzecie (lub więcej) powtórzenie miało miejsce w ostatnim ruchu
• Gra rozpoczyna się zawsze od standardowej pozycji początkowej dla szachów. Pozycja początkowa może się liczyć do powtórzeń.
• Remis przez powtórzenie nie wystąpił, jeśli pozycja nie zostanie powtórzona przez ostatni ruch

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki kod-golfowe zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi mają zastosowanie standardowe reguły z domyślnymi regułami We / Wy , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i typem zwracanych, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem kodu (tj. TIO ).
• Zalecane jest również dodanie wyjaśnienia do odpowiedzi.

Przypadki testowe

Powinieneś zwrócić prawdziwe wartości dla:

{"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"}

I wartości falsey dla:

{}
{"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 bajtów ^SBCS

-4 dzięki ngn.

Pełny program Zachęty do odwróconej liście odwróconych współrzędnych parach
 przykład {"B1-C3","B8-C6"}jest[[[8,2],[6,3]],[[1,2],[3,3]]]

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

Wypróbuj online! (zawiera funkcję narzędzia, Coordsktóra tłumaczy format OP)

Skonfiguruj listę stanów:

s←3 przypisać do trzech s(na s tates)

Ponieważ 3 nie jest prawidłowym stanem planszy, nie wpłynie to na naszą liczbę powtórzeń i potrzebujemy wartości przejścia zadania…

Zbuduj reprezentację szachownicy:

5... odrzutów, że dla wyniku zastosowania następującej funkcji pochodzącej między 5 i 3:
 ⍥⍳ rozszerzyć oba argumenty do ich ɩ ndices;
  [1,2,3,4,5]… [1,2,3]
 ,∘⌽ Lewa strona połączona z rewersem prawej strony
  [1,2,3,4,5,3,2,1]reprezentuje oficerów

⍪ zrobić w stół;
 [[1],
  [2],
  [3],
  [4],
  [5],
  [3],
  [2],
  [1]]

6, dodaj (do każdego wiersza) sześć, reprezentujących pionki;
 [[6,1],
  [6,2],
  [6,3],
  [6,4],
  [6,5],
  [6,3],
  [6,2],
  [6,1]]

⍉ transponować;
 [[6,6,6,6,6,6,6,6],
  [1,2,3,4,5,3,2,1]]

¯4↑ weź ujemne (tj. ostatnie) cztery (wiersze), wypełnione zerami, reprezentujące puste kwadraty;
 [[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]]

(… ) Zastosuj do tego następującą milczącą funkcję:

 - negacja (reprezentuje przeciwny kolor);
  [[ 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]]

  ⊖⍪ ułóż na wierzchu wywrócony argument, dając nam pełne wyżywienie;
  [[ 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]]

Zbuduj listę ruchów, a następnie stan początkowy:

⊂ dołącz to (aby traktować to jako pojedynczą jednostkę)

⎕, zapytaj o listę ruchów i przygotuj ją do stanu początkowego

Zmniejsz * o funkcję, która dołącza bieżący stan do listy i wykonuje ruch:

{… }/ Zredukuj o następującą anonimową lambda:

 ⍵ właściwy argument (aktualny stan)

 ⊂ załącz go, aby traktować jako jednostkę

 s,← w miejscu dołącz go do listy stanów

 ⊃ ujawnić, aby użyć tego stanu

 … @⍺ W elementach z dwoma współrzędnymi reprezentowanymi przez lewy argument: wstaw:
  0 zero,
  , po
  ∘ którym
  ⊃ następuje pierwsza wartość,
^{to skutecznie „przenosi” wartość z pierwszej współrzędnej do drugiej współrzędnej, pozostawiając za sobą zero}

Sprawdź, czy mamy trzy lub więcej stanu końcowego:

s∩ przecięcie wszystkich państw z tym ostatnim; podzbiór stanów identyczny z nim

≢ zliczyć je

2≤ sprawdź, czy są dwa lub więcej (tj. trzy lub więcej, w tym stan końcowy)

* APL jest asocjacyjnie prawy, więc najpierw wywoływana jest funkcja ze stanem początkowym jako prawym argumentem, a początkowy ruch jako lewym argumentem, a następnie jego wynik, nowy stan, staje się nowym prawym argumentem z drugim ruchem jako nowym lewym argumentem itp. Ostatecznym wynikiem jest

R , 180 177 144 bajtów

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}

Wypróbuj online!

-3 bajty dzięki Giuseppe
-29 bajtów dzięki użyciu Nicka Kennedy'ego Reducei -rev(l)
-4 bajty przez odwróceniez

Przyjmuje jako wejście wektor liczb całkowitych od 1 do 64 oznaczających kwadraty. TIO zawiera funkcję przekształcania do tego formatu. Różne elementy są przechowywane jako liczby całkowite od 1 do 6 oraz od -1 do -6.

Wyjaśnienie:

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
}

Galaretka , 41 37 bajtów

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

Wypróbuj online!

Łącze monadyczne, które przyjmuje dane wejściowe jako listę par 1-indeksowanych ruchów rzędów głównych [from, to]i zwraca 1 dla losowań, a 0 dla nie.

Uwaga: kod stopki na TIO tłumaczy ruchy dostarczone przez OP na format numeryczny, ale zgodnie z dyskusją pod pytaniem format numeryczny byłby prawidłowym wprowadzeniem.

Wyjaśnienie

Ø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 bajtów

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

Zwraca wartość logiczną.

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

Wypróbuj online!

W jaki sposób?

Kawałki

Wartości użyte do identyfikacji kawałków nie mają tak naprawdę znaczenia, o ile istnieje jedna unikalna wartość na rodzaj kawałka.

Używamy:

• 0 dla pustych kwadratów
• 1 / 8 / 9 / / B / C na ♟ / ♜ / ♞ / ♝ / ♛ / ♚
• 2 / 3 / 4 / 5 / 6 / 7 do ♙ / ♖ / ♘ / ♗ / ♕ / ♔

Zarząd i pozycja początkowa

$b$

• '89ABCA981111111' → 8 głównych czarnych pionków, a następnie pierwszych 7 czarnych pionków
• 10n**32n$\text{h7}$$1$$0$
• 0x7e5196ee74377→ wszystkie białe elementy (wydaje się 2222222234567543w systemie dziesiętnym)

Co skutkuje w:

    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

Śledzenie pozycji

$b$$b$

Oto dlaczego:

b[b] = -~b[b]

Skomentował

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

Java 10, 336 330 287 285 282 276 bajtów

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

-11 bajtów dzięki @Arnauld , zmieniając i%56<8?"ABCDECBA".charAt(i%56%7):i%48<16?1:0na i%56<8?i%8*35%41%10%8+2:9>>i/16&1.

$a1=0, b1=1, ..., h8=63${"E2-E4",...[[12,28],...

Wypróbuj online.

Wyjaśnienie:

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

Wartości sztuk po ich wypełnieniu A[i]=(i%56<8?i%8*35%41%10%8+2:9>>i/16&1)*(i/32*2-1)to:

     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

Wypróbuj online.

Węgiel , 62 bajty

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

Wypróbuj online! Link jest do pełnej wersji kodu. Staje wejście jest tablicą pary liczb, a kwadraty są ponumerowane A1, B1... H8(0-indeksowane) tak, na przykład, pierwszy sprawdzian będzie reprezentowane [[[1, 18], [57, 42], [18, 1], [42, 57], [1, 18], [57, 42], [18, 1], [42, 57]]]i wyprowadza -Jeżeli pozycja jest ciągnący powtórzeń. Program konwersji Wszystko w jednym. Wyjaśnienie:

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

Podziel liczbę 23456432na poszczególne cyfry. Reprezentują one białe kawałki.

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

Dodaj pionki i puste rzędy. Białe pionki mają wartość, 1a czarne pionki -1.

Ｆ…η⁸⊞η±ι

Dołącz negowaną kopię białych elementów, które reprezentują czarne kawałki.

Ｆθ«

Pętla nad ruchami.

⊞υ⮌η

Zapisz kopię planszy. (Cofanie to najbardziej golfowy sposób na skopiowanie planszy.)

§≔η⊟ι§η§ι⁰

Zaktualizuj cel za pomocą elementu źródłowego.

§≔η⊟ι⁰

Usuń kawałek źródłowy.

»›№υ⮌η¹

Ustal, czy bieżąca pozycja była widoczna więcej niż raz.

C # (interaktywny kompilator Visual C #) , 204 bajty

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

Pobiera dane wejściowe jako listę krotek liczb całkowitych, gdzie pierwsza liczba całkowita oznacza miejsce, z którego należy się przenieść, a druga to miejsce, do którego należy się przenieść. 0 oznacza A1, 1 oznacza A2, a 63 oznacza H8.

Wypróbuj online!

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 bajtów

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

Wypróbuj online!

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
}