Problema:

Negli scacchi, esiste una regola in qualche modo ben nota sul pareggio per ripetizione. Se la stessa posizione viene ripetuta 3 volte (o più), il giocatore che intende effettuare la mossa che causerà questa ripetizione può richiedere un pareggio.

A volte questo è un compito facile da individuare per un arbitro, se le ultime mosse sono solo i giocatori che si muovono avanti e indietro. A volte è meno banale, quando i pezzi si sono spostati in modo significativo tra posizioni ripetute.

Il problema in questa sfida è quello di produrre un valore di verità se la posizione richiesta è disegnata per ripetizione (è stata vista 3 volte o più) e un valore di falsa se la posizione richiesta non è disegnata per ripetizione, dato un elenco di mosse in notazione coordinata come descritto di seguito o qualsiasi notazione di tua scelta (ma dovrai convertire i casi di test).

Che cos'è una posizione?

In uno scenario del mondo reale, la posizione sarebbe influenzata da cose come se un giocatore può castigare o se è possibile l'invasore; si dovrebbe non prendere in considerazione questi nella vostra soluzione al problema. In questo problema una posizione è definita semplicemente dalla configurazione dei pezzi sulla scacchiera. Quindi, ai fini di questo problema, due posizioni sono considerate uguali se ogni quadrato su entrambe le assi è occupato dallo stesso tipo di pezzo dello stesso colore. Questo non deve essere il pezzo esatto, ad esempio i cavalieri bianchi potrebbero scambiare i quadrati e se tutti gli altri pezzi soddisfano i criteri questa sarebbe comunque la stessa posizione.

Che aspetto ha una notazione valida?

Sebbene continuerò a spiegare la notazione delle coordinate, sei libero di ricevere input da un sistema di notazione che scegli. Purché:

• Ogni articolo nella notazione descrive alcuni o tutti: il pezzo / i pezzi coinvolti; se sono stati consegnati check, checkmate, double check, checkmate o stallo; se si è verificata l'acquisizione en-passant; la posizione iniziale; la posizione finale.
• Potresti non avere informazioni sulla ripetizione nella tua notazione.

Quindi, fintanto che questi criteri sono soddisfatti, sono felice di accettare, fintanto che specifichi nella tua risposta, il tuo sistema di notazione. Questo potrebbe essere ad esempio 0 righe indicizzate, tuple di colonne o qualunque cosa abbia senso per il tuo programma.

Notazione coordinata

La notazione di coordinate è una notazione che descrive semplicemente le mosse come un sistema di coordinate.

Una mossa viene descritta come prima la coordinata iniziale dall'insieme {A1-H8}e poi di nuovo la coordinata di destinazione dallo stesso insieme. Quindi il King's Gambit sarebbe simile (come una raccolta di stringhe)

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

Credo che sia la migliore notazione da utilizzare per questo problema perché non è disseminata di informazioni estranee come se si è verificato un controllo o quale sia il tipo di movimento del pezzo. Come accennato in precedenza, la notazione può essere di vostra scelta, quindi è possibile utilizzare un'altra notazione, ad esempio notazione algebrica o è possibile adattare questa notazione (ad esempio rimuovere i trattini o prendere come elenco di tuple)

Regole:

• Si dovrebbe non considerare se una posizione o mossa è valida, solo se si provoca la ripetizione
• Puoi presumere che non si verifichino promozioni per il castling e il pedone .
• Dovresti prendere un elenco di stringhe come input e produrre un valore di verità o falsità corrispondente al fatto che si sia verificata la terza (o più) ripetizione nell'ultima mossa
• Il gioco inizia sempre nella posizione di partenza standard per gli scacchi. La posizione iniziale può contare per la ripetizione.
• Il pareggio per ripetizione non si è verificato se la posizione non è ripetuta dalla mossa finale

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard con regole I / O predefinite , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Le scappatoie predefinite sono vietate.
• Se possibile, aggiungi un link con un test per il tuo codice (ad es. TIO ).
• Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi test

Dovresti restituire valori veritieri per:

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

E valori falsi per:

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

-4 grazie a ngn.

Programma completo. Prompt per elenco inversa di coppie di coordinate invertito:
 ad esempio {"B1-C3","B8-C6"}è[[[8,2],[6,3]],[[1,2],[3,3]]]

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

Provalo online! (include la funzione di utilità Coordsche traduce il formato di OP)

Imposta un elenco di stati:

s←3 assegnare tre a s(per s tati)

Poiché 3 non è uno stato di board valido, non influirà sul conteggio delle ripetizioni e abbiamo bisogno del valore pass-through dell'assegnazione ...

Costruisci una rappresentazione della scacchiera:

5... scarto che per il risultato dell'applicazione della seguente funzione derivata tra 5 e 3:
 ⍥⍳ estendono entrambi gli argomenti a loro ɩ ndices;
  [1,2,3,4,5]...[1,2,3]
 ,∘⌽  la parte sinistra concatenata con il retro della parte destra
  [1,2,3,4,5,3,2,1]rappresenta gli ufficiali

⍪ trasformarsi in tavolo;
 [[1],
  [2],
  [3],
  [4],
  [5],
  [3],
  [2],
  [1]]

6, anteporre (a ciascuna riga) un sei, che rappresenta i pedoni;
 [[6,1],
  [6,2],
  [6,3],
  [6,4],
  [6,5],
  [6,3],
  [6,2],
  [6,1]]

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

¯4↑ prendere negativo (cioè l'ultimo) quattro (righe), riempiendo di zeri, che rappresentano quadrati vuoti;
 [[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]]

(...)  applica la seguente funzione tacita a quella:

 - negare (questo rappresenta il colore opposto);
  [[ 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]]

  ⊖⍪ impila l'argomento capovolto in cima a quello, dandoci la pensione 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]]

Costruire un elenco di mosse seguite dallo stato iniziale:

⊂ allegalo (per trattarlo come una singola unità)

⎕, richiede l'elenco delle mosse e antepone quello allo stato iniziale

Riduci * con una funzione che aggiunge lo stato corrente all'elenco e fa una mossa:

{... }/ riduci con la seguente lambda anonima:

 ⍵ l'argomento giusto (lo stato attuale)

 ⊂ racchiuderlo per trattarlo come un'unità

 s,← sul posto aggiungerlo all'elenco degli stati

 ⊃ divulgarlo per usare quello stato

 ... @⍺ agli elementi con le due coordinate rappresentate dall'argomento sinistro, inserisci:
  0 uno zero
  , seguito
  ∘ dal
  ⊃ primo valore
^{questo "sposta" efficacemente il valore dalla prima coordinata alla seconda coordinata, lasciandosi dietro uno zero}

Controlla se abbiamo tre o più dello stato finale:

s∩ l'intersezione di tutti gli stati con quello finale; il sottoinsieme di stati identici ad esso

≢ raccoglierli

2≤ controlla se ce ne sono due o più (ovvero tre o più incluso lo stato finale)

* APL è associativo a destra, quindi prima la funzione viene chiamata con lo stato iniziale come argomento destro e la mossa iniziale come argomento sinistro, quindi il suo risultato, il nuovo stato, diventa il nuovo argomento destro con la seconda mossa come nuovo argomento sinistro , ecc. Il risultato finale è il

R , 180 177 144 byte

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}

Provalo online!

-3 byte grazie a Giuseppe
-29 byte grazie all'utilizzo di Reducee-rev(l)
-4 byte invertendoz

Prende come input un vettore di numeri interi compresi tra 1 e 64 che indica i quadrati. Il TIO include una funzione per trasformarsi in quel formato. I diversi pezzi sono memorizzati come numeri interi compresi tra 1 e 6 e tra -1 e -6.

Spiegazione:

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
}

Gelatina , 41 37 byte

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

Provalo online!

Un collegamento monadico che accetta l'input come un elenco di coppie di mosse principali a 1 indice [from, to] e restituisce 1 per i sorteggi e 0 per i non.

Si noti che il codice piè di pagina su TIO traduce le mosse fornite dall'OP nel formato numerico, ma per la discussione sotto la domanda, il formato numerico sarebbe stato un input valido.

Spiegazione

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

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

Restituisce un valore 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

Provalo online!

Come?

pezzi

I valori usati per identificare i pezzi non contano davvero finché c'è un valore unico per tipo di pezzo.

Noi usiamo:

• 0 per quadrati vuoti
• 1 / 8 / 9 / A / B / C per ♟ / ♜ / ♞ / ♝ / ♛ / ♚
• 2 / 3 / 4 / 5 / 6 / 7 per ♙ / ♖ / ♘ / ♗ / ♕ / ♔

Consiglio di amministrazione e posizione iniziale

$b$

• '89ABCA981111111' → gli 8 pezzi principali neri, seguiti dai primi 7 pedoni neri
• 10n**32n$\text{h7}$$1$$0$
• 0x7e5196ee74377→ tutti i pezzi bianchi (si estende 2222222234567543in decimale)

che si traduce in:

    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

Tenere traccia delle posizioni

$b$$b$stesso, ma questa volta come un array e implicitamente costretto a una stringa.

Questo è il motivo per cui facciamo:

b[b] = -~b[b]

Commentate

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 byte

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 byte grazie a @Arnauld passando 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.

Input come una matrice 2D di numeri interi dove $a1=0, b1=1, ..., h8=63$(cioè {"E2-E4",...è [[12,28],...).

Provalo online.

Spiegazione:

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

I valori dei pezzi dopo averli riempiti A[i]=(i%56<8?i%8*35%41%10%8+2:9>>i/16&1)*(i/32*2-1)sono:

     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

Provalo online.

Carbone , 62 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Prende input come una matrice di coppie di numeri in cui vengono numerati piazze A1, B1... H8(0-indicizzato) così per esempio il primo test sarà rappresentata da [[[1, 18], [57, 42], [18, 1], [42, 57], [1, 18], [57, 42], [18, 1], [42, 57]]]ed emette un -se la posizione è patta per ripetizione. Programma di conversione. Tutto in uno. Spiegazione:

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

Dividi il numero 23456432in singole cifre. Questi rappresentano i pezzi bianchi.

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

Aggiungi i pedoni e le righe vuote. Le pedine bianche hanno valore 1e le pedine nere -1.

Ｆ…η⁸⊞η±ι

Aggiungi una copia negata dei pezzi bianchi, che rappresentano i pezzi neri.

Ｆθ«

Passa sopra le mosse.

⊞υ⮌η

Salva una copia della scheda. (L'inversione è il modo più golfoso per copiare la tavola.)

§≔η⊟ι§η§ι⁰

Aggiorna la destinazione con il pezzo sorgente.

§≔η⊟ι⁰

Rimuovi il pezzo sorgente.

»›№υ⮌η¹

Determina se la posizione corrente è stata vista più di una volta prima.

C # (compilatore interattivo Visual C #) , 204 byte

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

Prende l'input come un elenco di tuple di numeri interi, in cui il primo numero intero è dove spostarsi e il secondo è dove spostarsi. 0 rappresenta A1, 1 è A2 e 63 è H8.

Provalo 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 byte

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

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