Problème:

Aux échecs, il existe une règle assez bien connue concernant le tirage par répétition. Si la même position est répétée 3 fois (ou plus) alors le joueur ayant l'intention de faire le coup qui provoquera cette répétition peut réclamer un match nul.

Parfois, c'est une tâche facile pour un arbitre de repérer, si les derniers mouvements ne sont que les joueurs se déplaçant en arrière et en avant. Parfois, c'est moins trivial, lorsque les pièces se sont déplacées de manière significative entre des positions répétées.

Le problème dans ce défi est de produire une valeur vraie si la position revendiquée est dessinée par répétition (a été vue 3 fois ou plus) et une valeur de falsey si la position revendiquée n'est pas dessinée par répétition, étant donné une liste de mouvements en notation coordonnée comme décrit ci-dessous, ou toute notation de votre choix (mais vous devrez convertir les cas de test).

Qu'est-ce qu'un poste?

Dans un scénario du monde réel, la position serait affectée par des choses telles que si un joueur peut roquer ou si le passage est possible; vous ne devez pas en tenir compte dans votre solution au problème. Dans ce problème, une position est définie simplement par la configuration des pièces sur la planche. Ainsi, pour les besoins de ce problème, deux positions sont considérées comme identiques si chaque carré des deux planches est occupé par le même type de pièce de la même couleur. Il n'est pas nécessaire que ce soit la pièce exacte, par exemple les chevaliers blancs pourraient échanger des carrés et si toutes les autres pièces remplissent les critères, ce serait toujours la même position.

À quoi ressemble une notation valide?

Bien que je vais continuer à expliquer la notation des coordonnées, vous êtes libre de saisir les informations par un système de notation que vous choisissez. À condition que:

• Chaque élément de la notation décrit tout ou partie: de la ou des pièces concernées; si le chèque, le mat, le double contrôle, le mat et le blocage ont été livrés; si une capture en passant s'est produite; la position initiale; la position finale.
• Vous ne pouvez pas avoir d'informations sur la répétition dans votre notation.

Donc, tant que ces critères sont remplis, je suis heureux d'accepter, tant que vous spécifiez dans votre réponse, votre système de notation. Cela peut être par exemple 0 ligne indexée, tuples de colonne ou tout ce qui a du sens pour votre programme.

Notation de coordonnées

La notation des coordonnées est une notation qui décrit purement les mouvements comme un système de coordonnées.

Un déplacement est décrit comme étant d'abord la coordonnée initiale de l'ensemble {A1-H8}, puis à nouveau la coordonnée de destination du même ensemble. Ainsi, le King's Gambit ressemblerait (comme une collection de cordes)

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

Je crois que c'est la meilleure notation à utiliser pour ce problème car elle n'est pas jonchée d'informations étrangères comme si la vérification a eu lieu ou quel est le type de pièce en mouvement. Comme mentionné précédemment, la notation peut être de votre choix, vous pouvez donc utiliser une autre notation, par exemple la notation algébrique ou vous pouvez adapter cette notation (par exemple, supprimer les tirets ou prendre comme liste de tuples)

Règles:

• Vous ne devez pas considérer si une position ou un mouvement est valide, mais seulement s'il provoque la répétition
• Vous pouvez supposer que la promotion du roque et du pion n'aura pas lieu.
• Vous devez prendre une liste de chaînes en entrée et sortir une valeur true ou falsey correspondant à la troisième (ou plus) répétition qui s'est produite lors du dernier mouvement.
• Le jeu commence toujours à la position de départ standard pour les échecs. La position initiale peut compter pour la répétition.
• Le tirage par répétition n'a pas eu lieu si la position n'est pas répétée par le coup final

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues non-golfeur de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse avec des règles d'E / S par défaut , vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code (par exemple TIO ).
• De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

Cas de test

Vous devez renvoyer des valeurs véridiques pour:

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

Et les valeurs de falsey pour:

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

-4 grâce à ngn.

Programme complet. Demande une liste inversée de paires de coordonnées inversées:
 par exemple, {"B1-C3","B8-C6"}est[[[8,2],[6,3]],[[1,2],[3,3]]]

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

Essayez-le en ligne! (inclut la fonction utilitaire Coordsqui traduit le format OP)

Établissez une liste d'états:

s←3 attribuer trois à s(pour les États)

Étant donné que 3 n'est pas un état de carte valide, cela n'affectera pas notre nombre de répétitions, et nous avons besoin de la valeur de transmission de l'affectation…

Construisez une représentation de l'échiquier:

5… Jetez cela pour le résultat de l'application de la fonction dérivée suivante entre 5 et 3: étendez les
 ⍥⍳ deux arguments à leurs ɩ ndices;
  [1,2,3,4,5]… [1,2,3]
 ,∘⌽ Le côté gauche concaténé avec le revers du côté droit
  [1,2,3,4,5,3,2,1] cela représente les officiers

⍪ transformer en table;
 [[1],
  [2],
  [3],
  [4],
  [5],
  [3],
  [2],
  [1]]

6, ajouter (à chaque ligne) un six, représentant des pions;
 [[6,1],
  [6,2],
  [6,3],
  [6,4],
  [6,5],
  [6,3],
  [6,2],
  [6,1]]

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

¯4↑ prendre les quatre (lignes) négatives (c.-à-d. les dernières), avec des zéros, représentant des carrés vides;
 [[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]]

(… ) Appliquer à cela la fonction tacite suivante:

 - nier (cela représente la couleur opposée);
  [[ 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]]

  ⊖⍪ empilez l'argument inversé en plus de cela, nous donnant la pension complète;
  [[ 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]]

Construisez une liste de mouvements suivie de l'état initial:

⊂ joindre cela (pour le traiter comme une seule unité)

⎕, demander la liste des mouvements, et l'ajouter à l'état initial

Réduisez * d'une fonction qui ajoute l'état actuel à la liste et effectue un mouvement:

{… }/ Réduire par le lambda anonyme suivant:

 ⍵ le bon argument (l'état actuel)

 ⊂ l'enfermer pour le traiter comme une unité

 s,← en place l'ajouter à la liste des états

 ⊃ divulguer pour utiliser cet état

 … @⍺ Aux éléments avec les deux coordonnées que l'argument de gauche représente, mettez:
  0 un zéro
  , suivi
  ∘ de
  ⊃ la première valeur
^{ceci "déplace" effectivement la valeur de la première coordonnée à la deuxième coordonnée, laissant derrière un zéro}

Vérifiez si nous avons trois ou plus de l'état final:

s∩ l'intersection de tous les États avec ce dernier; le sous-ensemble d'états lui étant identique

≢ les compter

2≤ vérifier s'il y en a deux ou plus (c.-à-d. trois ou plus, y compris l'état final)

* APL est associative à droite, donc d'abord la fonction est appelée avec l'état initial comme argument de droite et le mouvement initial comme argument de gauche, puis son résultat, le nouvel état, devient le nouvel argument de droite avec le deuxième mouvement comme nouvel argument de gauche , etc. Le résultat final est

R , 180 177 144 octets

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}

Essayez-le en ligne!

-3 octets grâce à Giuseppe
-29 octets grâce à l'utilisation de Nick Kennedy Reduceet-rev(l)
-4 octets en inversantz

Prend en entrée un vecteur d'entiers compris entre 1 et 64 désignant les carrés. Le TIO comprend une fonction pour se transformer en ce format. Les différentes pièces sont stockées sous forme d'entiers compris entre 1 et 6 et entre -1 et -6.

Explication:

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
}

Gelée , 41 37 octets

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

Essayez-le en ligne!

Un lien monadique qui prend l'entrée comme une liste de paires de mouvements majeurs de ligne indexés 1 [from, to]et retourne 1 pour les tirages et 0 pour non.

Notez que le code de pied de page sur TIO traduit les mouvements fournis par l'OP au format numérique, mais selon la discussion ci-dessous la question, le format numérique aurait été une entrée valide.

Explication

Ø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) ,  121111  octets

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

Renvoie une valeur booléenne.

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

Essayez-le en ligne!

Comment?

Pièces

Les valeurs utilisées pour identifier les pièces n'ont pas vraiment d'importance tant qu'il existe une valeur unique par type de pièce.

Nous utilisons:

• 0 pour les cases vides
• 1 / huit / 9 / A / B / C pour ♟ / ♜ / ♞ / ♝ / ♛ / ♚
• 2 / 3 / quatre / 5 / 6 / sept pour ♙ / ♖ / ♘ / ♗ / ♕ / ♔

Conseil et poste initial

$b$ qui est initialisé en divisant la concaténation des parties suivantes:

• '89ABCA981111111' → les 8 pièces majeures noires, suivies des 7 premiers pions noirs
• 10n**32n$\text{h7}$$1$$0$ )
• 0x7e5196ee74377→ toutes les pièces blanches (s'étendent 2222222234567543en décimales)

ce qui se traduit par:

    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

Garder une trace des positions

La variable $b$est également utilisé comme objet pour garder une trace de toutes les positions rencontrées. La clé de chaque poste est$b$ lui-même, mais cette fois en tant que tableau et implicitement contraint à une chaîne.

C'est pourquoi nous faisons:

b[b] = -~b[b]

Commenté

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 octets

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 octets grâce à @Arnauld en passant i%56<8?"ABCDECBA".charAt(i%56%7):i%48<16?1:0à i%56<8?i%8*35%41%10%8+2:9>>i/16&1.

Entrée sous forme de tableau 2D d'entiers où $a1=0, b1=1, ..., h8=63$(c'est {"E2-E4",...-à- dire est [[12,28],...).

Essayez-le en ligne.

Explication:

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

Les valeurs des pièces après les avoir remplies A[i]=(i%56<8?i%8*35%41%10%8+2:9>>i/16&1)*(i/32*2-1) sont:

     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

Essayez-le en ligne.

Fusain , 62 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend entrée comme un tableau de paires de nombres dont les carrés sont numérotés A1, B1... H8(0 indexée) de telle sorte , par exemple , le premier test serait représenté par [[[1, 18], [57, 42], [18, 1], [42, 57], [1, 18], [57, 42], [18, 1], [42, 57]]]et sort un -si la position est nulle par répétition. Programme de conversion. Tout en un. Explication:

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

Divisez le numéro 23456432en chiffres individuels. Ceux-ci représentent les pièces blanches.

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

Ajoutez les pions et les rangées vides. Les pions blancs ont de la valeur 1et les pions noirs -1.

Ｆ…η⁸⊞η±ι

Ajoutez une copie niée des pièces blanches, qui représentent les pièces noires.

Ｆθ«

Boucle sur les mouvements.

⊞υ⮌η

Enregistrez une copie du tableau. (L'inversion est la façon la plus golfique de copier la planche.)

§≔η⊟ι§η§ι⁰

Mettez à jour la destination avec la pièce source.

§≔η⊟ι⁰

Retirez la pièce source.

»›№υ⮌η¹

Déterminez si la position actuelle a été vue plus d'une fois auparavant.

C # (Visual C # Interactive Compiler) , 204 octets

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

Prend l'entrée comme une liste de tuples d'entiers, où le premier entier est l'endroit où se déplacer et le second où aller. 0 représente A1, 1 est A2 et 63 est H8.

Essayez-le en ligne!

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 octets

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

Essayez-le en ligne!

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
}