Problema:

En ajedrez, hay una regla algo bien conocida sobre el sorteo por repetición. Si la misma posición se repite 3 veces (o más), el jugador que intente hacer el movimiento que provocará esta repetición puede reclamar un empate.

A veces es una tarea fácil de detectar para un árbitro, si los últimos movimientos son solo los jugadores que se mueven hacia adelante y hacia atrás. A veces es menos trivial, cuando las piezas se han movido significativamente entre posiciones repetidas.

El problema en este desafío es generar un valor verdadero si la posición reclamada se dibuja por repetición (se ha visto 3 veces o más) y un valor falso si la posición reclamada no se dibuja por repetición, dada una lista de movimientos en notación coordinada como se describe a continuación, o cualquier anotación de su elección (pero tendrá que convertir los casos de prueba).

¿Qué es un puesto?

En un escenario del mundo real, la posición se vería afectada por cosas tales como si un jugador puede enrolar o si es posible pasarlo; usted debe no tener en cuenta estos en su solución al problema. En este problema, una posición se define simplemente por la configuración de las piezas en el tablero. Entonces, para los propósitos de este problema, se considera que dos posiciones son iguales si cada cuadrado en ambos tableros está ocupado por el mismo tipo de pieza del mismo color. Esta no tiene que ser la pieza exacta, por ejemplo, los caballeros blancos podrían intercambiar cuadrados y si todas las otras piezas cumplen los criterios, esta sería la misma posición.

¿Cómo se ve una notación válida?

Aunque continuaré explicando la notación coordinada, usted es libre de recibir información mediante el sistema de notación que elija. Siempre que:

• Cada elemento de la notación describe una o todas las partes involucradas; si se ha entregado cheque, jaque mate, doble cheque, jaque mate o estancamiento; si se ha producido una captura pasajera; la posición inicial La posición final.
• Es posible que no tenga información sobre la repetición en su notación.

Por lo tanto, siempre que se cumplan estos criterios, me complace aceptar, siempre y cuando especifique en su respuesta, su sistema de notación. Esto podría ser, por ejemplo, 0 filas indexadas, tuplas de columnas o lo que tenga sentido para su programa.

Notación coordinada

La notación coordinada es una notación que describe puramente los movimientos como un sistema de coordenadas.

Un movimiento se describe primero como la coordenada inicial del conjunto {A1-H8}y luego la coordenada de destino nuevamente desde el mismo conjunto. Así se vería el Gambito del Rey (como una colección de cadenas)

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

Creo que es la mejor notación para usar en este problema porque no está llena de información extraña como si se ha producido un control o cuál es el tipo de movimiento de la pieza. Como se mencionó anteriormente, la notación puede ser de su elección, por lo que podría usar otra notación, por ejemplo, notación algebraica o podría adaptar esta notación (por ejemplo, eliminar los guiones o tomar como una lista de tuplas)

Reglas:

• Usted debe no considerar si una posición o movimiento es válido, solamente si causa la repetición
• Puede suponer que la promoción de castillos y peones no producirán .
• Debe tomar una lista de cadenas como entrada y salida de un valor verdadero o falso correspondiente a si la tercera (o más) repetición se produjo en el movimiento final
• El juego siempre comienza en la posición inicial estándar para el ajedrez. La posición inicial puede contar para la repetición.
• El sorteo por repetición no se ha producido si la posición no se repite en el movimiento final

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolfing. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Las reglas estándar se aplican a su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba

Debe devolver valores verdaderos para:

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

Y los valores de falsey para:

{}
{"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 bytes ^SBCS

-4 gracias a ngn.

Programa completo Solicita una lista inversa de pares de coordenadas invertidas:
 por ejemplo, {"B1-C3","B8-C6"}es[[[8,2],[6,3]],[[1,2],[3,3]]]

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

Pruébalo en línea! (incluye la función de utilidad Coordsque traduce el formato de OP)

Configure una lista de estados:

s←3 asignar tres a s(para s stados)

Dado que 3 no es un estado de tablero válido, no afectará nuestro recuento de repeticiones, y necesitamos el valor de transferencia de la tarea ...

Construye una representación en el tablero de ajedrez:

5… Descarte eso por el resultado de aplicar la siguiente función derivada entre 5 y 3:
 ⍥⍳ extender ambos argumentos a sus ɩ ndices;
  [1,2,3,4,5]... [1,2,3]
 ,∘⌽ el lado izquierdo concatenado con el reverso del lado derecho
  [1,2,3,4,5,3,2,1]esto representa a los oficiales

⍪ hacer en la mesa;
 [[1],
  [2],
  [3],
  [4],
  [5],
  [3],
  [2],
  [1]]

6, anteponer (a cada fila) un seis, que representa peones;
 [[6,1],
  [6,2],
  [6,3],
  [6,4],
  [6,5],
  [6,3],
  [6,2],
  [6,1]]

⍉ transponer;
 [[6,6,6,6,6,6,6,6],
  [1,2,3,4,5,3,2,1]]

¯4↑ tomar cuatro (filas) negativas (es decir, las últimas), rellenando con ceros, que representan cuadrados vacíos;
 [[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]]

(… ) Aplica la siguiente función tácita a eso:

 - negar (esto representa el color opuesto);
  [[ 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]]

  ⊖⍪ apile el argumento invertido encima de eso, dándonos la pensión completa;
  [[ 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]]

Construya una lista de movimientos seguidos del estado inicial:

⊂ adjunte eso (para tratarlo como una sola unidad)

⎕, solicite la lista de movimientos y añádala al estado inicial

Reduce * por una función que agrega el estado actual a la lista y realiza un movimiento:

{… }/ Reducir por la siguiente lambda anónima:

 ⍵ el argumento correcto (el estado actual)

 ⊂ adjuntarlo para tratarlo como una unidad

 s,← en el lugar anexarlo a la lista de estados

 ⊃ revelarlo para usar ese estado

 ... @⍺ a los elementos con las dos coordenadas que el argumento de la izquierda representa, puesto:
  0 un cero
  , seguido
  ∘ por
  ⊃ el primer valor
^{de manera eficaz "mueve" el valor de la primera coordenada a la segunda coordenada, dejando tras de sí un cero}

Verifique si tenemos tres o más del estado final:

s∩ la intersección de todos los estados con ese último; el subconjunto de estados idénticos a él

≢ contarlos

2≤ comprobar si hay dos o más (es decir, tres o más, incluido el estado final)

* APL es asociativo a la derecha, por lo que primero se llama a la función con el estado inicial como argumento derecho y el movimiento inicial como argumento izquierdo, y luego su resultado, el nuevo estado, se convierte en el nuevo argumento derecho con el segundo movimiento como nuevo argumento izquierdo , etc. El resultado final es el

R , 180 177 144 bytes

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}

Pruébalo en línea!

-3 bytes gracias a Giuseppe
-29 bytes gracias al uso de Nick Kennedy de Reducey-rev(l)
-4 bytes invirtiendoz

Toma como entrada un vector de enteros entre 1 y 64 que denota los cuadrados. El TIO incluye una función para transformar en ese formato. Las diferentes piezas se almacenan como enteros entre 1 y 6 y entre -1 y -6.

Explicación:

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
}

Jalea , 41 37 bytes

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

Pruébalo en línea!

Un enlace monádico que toma la entrada como una lista de pares de movimientos principales de fila indexados con 1 [from, to]y devuelve un 1 para sorteos y 0 para no.

Tenga en cuenta que el código de pie de página en TIO traduce los movimientos proporcionados por el OP al formato numérico, pero según la discusión debajo de la pregunta, el formato numérico habría sido una entrada válida.

Explicación

Ø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 bytes

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

Devuelve un valor booleano.

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

Pruébalo en línea!

¿Cómo?

Piezas

Los valores utilizados para identificar las piezas realmente no importan siempre que haya un valor único por tipo de pieza.

Usamos:

• 0 0 para cuadrados vacíos
• 1 / 8 / 9 / A / B / C para ♟ / ♜ / ♞ / ♝ / ♛ / ♚
• 2 / 3 / 4 / 5 / 6 / 7 para ♙ / ♖ / ♘ / ♗ / ♕ / ♔

Junta y posición inicial

$b$

• '89ABCA981111111' → las 8 piezas principales negras, seguidas de los primeros 7 peones negros
• 10n**32n$\text{h7}$$1$$0$ )
• 0x7e5196ee74377→ todas las piezas blancas (se gasta 2222222234567543en decimal)

lo que resulta en:

    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

Hacer un seguimiento de las posiciones

$b$$b$

Por eso hacemos:

b[b] = -~b[b]

Comentado

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 bytes

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 bytes gracias a @Arnauld cambiando i%56<8?"ABCDECBA".charAt(i%56%7):i%48<16?1:0a i%56<8?i%8*35%41%10%8+2:9>>i/16&1.

Ingrese como una matriz 2D de enteros donde $a1=0, b1=1, ..., h8=63$( {"E2-E4",...es decir, es [[12,28],...).

Pruébalo en línea.

Explicación:

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

Los valores de las piezas después de llenarlas A[i]=(i%56<8?i%8*35%41%10%8+2:9>>i/16&1)*(i/32*2-1)son:

     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

Pruébalo en línea.

Carbón , 62 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Toma de entrada como una serie de pares de números donde se numeran los cuadrados A1, B1, ... H8(0-indexada) así por ejemplo, el primer caso de prueba se representa como [[[1, 18], [57, 42], [18, 1], [42, 57], [1, 18], [57, 42], [18, 1], [42, 57]]]y emite una -si la posición es un empate por repetición. Programa de conversión. Todo en uno. Explicación:

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

Divide el número 23456432en dígitos individuales. Estos representan las piezas blancas.

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

Agregue los peones y las filas vacías. Los peones blancos tienen valor 1y los peones negros -1.

Ｆ…η⁸⊞η±ι

Agregue una copia negada de las piezas blancas, que representan las piezas negras.

Ｆθ«

Recorre los movimientos.

⊞υ⮌η

Guarde una copia de la pizarra. (Revertir es la forma más elegante de copiar el tablero).

§≔η⊟ι§η§ι⁰

Actualice el destino con la pieza fuente.

§≔η⊟ι⁰

Retire la pieza fuente.

»›№υ⮌η¹

Determine si la posición actual se vio más de una vez antes.

C # (compilador interactivo de Visual C #) , 204 bytes

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

Toma información como una lista de tuplas de enteros, donde el primer entero es desde dónde moverse, y el segundo es hacia dónde moverse. 0 representa A1, 1 es A2 y 63 es H8.

Pruébalo en línea!

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 bytes

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

Pruébalo en línea!

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
}