Sorun:

Satrançta, tekrar ile beraber çekme konusunda iyi bilinen bir kural vardır. Aynı pozisyon 3 kez (veya daha fazla) tekrarlanırsa, bu tekrarlamaya neden olacak hamleyi yapmak isteyen oyuncu berabere kalabilir.

Bazen, son birkaç hamle sadece ileri ve geri hareket eden oyuncularsa, bir hakemin fark etmesi kolay bir iştir. Bazen parçalar tekrarlanan pozisyonlar arasında önemli ölçüde hareket ettiğinde daha az önemsizdir.

Bu meydan okumadaki sorun, talep edilen konum tekrar ile çizilirse (3 kez veya daha fazla görülmüşse) doğruluk değeri ve talep edilen konum tekrarla çizilmiyorsa, bir koordinat gösterimi, koordinat gösterimindeki hareketlerin bir listesi verilir aşağıda açıklandığı gibi veya seçtiğiniz herhangi bir gösterim (ancak test senaryolarını dönüştürmeniz gerekir).

Konum nedir?

Gerçek bir dünya senaryosunda, pozisyon bir oyuncunun kale yapıp yapamayacağı veya en-passant'ın mümkün olup olmadığı gibi şeylerden etkilenecektir; Eğer gereken değil sorununa da çözüm bu düşünün. Bu problemde, bir pozisyon basitçe tahtadaki parçaların konfigürasyonu ile tanımlanır. Bu nedenle, bu sorunun amaçları için, her iki karttaki her bir kare aynı renkteki aynı türden bir parça tarafından işgal edilirse, iki konumun aynı olduğu görülür. Bu, örneğin beyaz şövalyelerin kareleri değiştirebileceği tam bir parça olmak zorunda değildir ve diğer tüm parçalar kriterleri karşılarsa, yine de aynı pozisyonda olacaktır.

Geçerli bir gösterim neye benziyor?

Koordinat gösterimini açıklamaya devam etsem de, seçtiğiniz bir gösterim sistemi tarafından girdi almakta özgürsünüz. Şartıyla:

• Gösterimdeki her bir öğe aşağıdakilerden herhangi birini veya tümünü açıklar: ilgili parça / parçalar; çek, şah mat, çift çek, şah mat veya çıkmaz teslim edilip edilmediği; en-passant yakalama gerçekleşmişse; başlangıç ​​pozisyonu; son pozisyon.
• Sen olabilir değil sizin gösterimde tekrarı hakkında bilgi sahibi.

Bu kriterler karşılandığı sürece, cevabınızda belirttiğiniz sürece, gösterim sisteminizi kabul etmekten mutluluk duyuyorum. Bu, örneğin 0 dizinli satır, sütun tuplleri veya programınız için anlamlı olan herhangi bir şey olabilir.

Koordinat Gösterimi

Koordinat gösterimi, yalnızca hareketleri bir koordinat sistemi olarak tanımlayan bir göstergedir.

Bir hareket önce kümeden ilk koordinat, {A1-H8}sonra aynı kümeden tekrar hedef koordinat olarak tanımlanır. Bu yüzden Kralın Gambiti (bir dizeler koleksiyonu olarak)

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

Bu sorun için kullanmak için en iyi gösterim olduğuna inanıyorum, çünkü kontrolün gerçekleşip gerçekleşmediği veya parça hareketinin türü gibi yabancı bilgilerle dolmuyor. Daha önce de belirtildiği gibi, gösterim sizin tercihiniz olabilir, bu nedenle başka bir gösterimi kullanabilirsiniz, örneğin cebirsel gösterimi veya bu gösterimi uyarlayabilirsiniz (örneğin tireleri kaldırın veya tuples listesi olarak alın)

Kurallar:

• Sen gerektiğini değil o tekrarını neden sadece olsun, bir pozisyon ya da hareket geçerli olup olmadığını düşünün
• Göreceksin o rok ve piyon terfi varsayabiliriz değil oluşabilir.
• Girdi olarak dizelerin bir listesini almalı ve son hamlede üçüncü (veya daha fazla) tekrarın gerçekleşip gerçekleşmediğine karşılık gelen bir doğruluk veya falsey değeri çıkarmalısınız.
• Oyun her zaman satranç için standart başlangıç ​​konumunda başlar. Başlangıç ​​pozisyonu tekrarlamaya sayılabilir.
• Eğer pozisyon son hamleyle tekrarlanmazsa tekrar ile çizim yapılmadı

Genel kurallar:

• Bu kod golf , bayt en kısa cevap kazanır.
  Kod golf dillerinin, kod yazmayan dillerle yanıt göndermenizi engellemesine izin vermeyin. 'Herhangi bir' programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Varsayılan I / O kuralları ile cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT, fonksiyonlar / yöntem uygun parametreler ve dönüş tipi, tam programlar ile kullanılabilir. Çağrınız.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuz için bir test içeren bir bağlantı ekleyin (örn. TIO ).
• Ayrıca, cevabınız için bir açıklama eklemeniz önemle tavsiye edilir.

Test Durumları

Aşağıdakiler için doğruluk değerleri döndürmelisiniz:

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

Ve falsey değerleri:

{}
{"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 Genişletilmiş) , 55 49 47 45 44 bayt ^SBCS

-4 ngn sayesinde.

Tam program. Tersine çevrilmiş koordinat çiftlerinin ters listesi için istemler:
 ör {"B1-C3","B8-C6"}.[[[8,2],[6,3]],[[1,2],[3,3]]]

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

Çevrimiçi deneyin! ( CoordsOP'nin biçimini çeviren yardımcı program işlevini içerir )

Bir durum listesi oluşturun:

s←3 üç ila atamak siçin ( s tates)

3 geçerli bir yönetim kurulu durumu olmadığından, tekrar sayımımızı etkilemeyecektir ve ödevin geçiş değerine ihtiyacımız var…

Bir satranç tahtası temsili oluşturun:

5… Aşağıdaki türetilmiş işlevi 5 ile 3 arasında uygulama sonucu için:
 ⍥⍳ her iki argümanı da bulgularına genişletin;
  [1,2,3,4,5]… [1,2,3]
 ,∘⌽ Sol taraf sağ tarafın tersi ile birleştiğinde
  [1,2,3,4,5,3,2,1]bu, subayları temsil eder.

⍪ masaya yapmak;
 [[1],
  [2],
  [3],
  [4],
  [5],
  [3],
  [2],
  [1]]

6, piyonları temsil eden altı tane (her satıra);
 [[6,1],
  [6,2],
  [6,3],
  [6,4],
  [6,5],
  [6,3],
  [6,2],
  [6,1]]

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

¯4↑ boş kareleri temsil eden sıfırlarla doldurmak için negatif (yani son) dört (satır) almak;
 [[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]]

(… Buna ) aşağıdaki örtük işlevini uygulayın:

 - negatif (bu zıt rengi temsil eder);
  [[ 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]]

  ⊖⍪ ters çevrilmiş argümanı üst üste koyun, bize tam pansiyon verin;
  [[ 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]]

İlk durumun ardından bir hamle listesi oluşturun:

⊂ bunu ekleyin (tek bir birim olarak ele almak için)

⎕, hamle listesi istemi ve bunu başlangıç ​​durumuna getirme

Geçerli durumu listeye ekleyen ve taşıma yapan bir işlevle * azaltın:

{… }/ Aşağıdaki anonim lambda ile azaltın:

 ⍵ doğru argüman (mevcut durum)

 ⊂ bir birim olarak ele almak için içine alın

 s,← yerinde eyalet listesine ekle

 ⊃ bu durumu kullanmak için ifşa et

 ... @⍺ sol argüman temsil ettiği iki koordinat ile unsurları, koyun:
  0 sıfır
  , , ardından
  ∘ tarafından
  ⊃ ilk değer
^{, bu etkili bir şekilde "hareket" ilk değer sıfır geride bırakarak, ikinci koordinat koordinat}

Son durumdan üç veya daha fazlasına sahip olup olmadığımızı kontrol edin:

s∩ tüm devletlerin bu son devletle kesişimi; ona benzer durumların alt kümesi

≢ onları hesapla

2≤ iki veya daha fazla olup olmadığını kontrol edin (yani son durumu içeren üç veya daha fazla)

* APL sağ çağrışımcıdır, bu nedenle önce işlev ilk argüman olarak sağ argüman olarak ve ilk hamle sol argüman olarak çağrılır ve sonra sonucu, yeni durum, ikinci hamleyle yeni sağ argüman olur, yeni sol argüman olarak Nihai sonuç,

R , 180 177 144 bayt

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}

Çevrimiçi deneyin!

Giuseppe sayesinde -3 bayt
-Nick Kennedy'nin ters çevirerek -29 bayt Reduceve -rev(l)
-4 baytz

Girdi olarak kareleri gösteren 1 ile 64 arasında bir tamsayı vektörü alır. TIO, bu formata dönüştürmek için bir işlev içerir. Farklı parçalar 1 ile 6 ve -1 ile -6 arasında tamsayılar olarak saklanır.

Açıklama:

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
}

Jöle , 41 37 bayt

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

Çevrimiçi deneyin!

Girdiyi, 1 dizinli satır-büyük hareket çiftleri listesi olarak alan monadik bir bağlantı [from, to] çekilişler için 1, değil de 0 döndüren .

TIO'daki altbilgi kodunun, OP tarafından sağlanan hareketleri sayısal biçime çevirdiğini, ancak sorunun altındaki tartışma başına, sayısal biçimin geçerli bir girdi olacağını unutmayın.

açıklama

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

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

Bir Boolean değeri döndürür.

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

Çevrimiçi deneyin!

Nasıl?

parçalar

Parçaları tanımlamak için kullanılan değerler, parça türü başına benzersiz bir değer olduğu sürece gerçekten önemli değildir.

Kullanırız:

• Boş kareler için 0
• 1 / 8 / 9 / A / B / C ♟ / ♜ / ♞ / ♝ / ♛ / ♚ için
• 2 / 3 / 4 / 5 / 6 / 7 için ♙ / ♖ / ♘ / ♗ / ♕ / ♔

Kart ve başlangıç ​​pozisyonu

$b$

• '89ABCA981111111' → 8 siyah ana parça, ardından ilk 7 siyah piyon
• 10n**32n$\text{h7}$$1$$0$
• 0x7e5196ee74377→ tüm beyaz parçalar ( 2222222234567543ondalık sayıya kadar)

sonuç:

    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

Pozisyonların takibi

$b$$b$

Bu yüzden yapıyoruz:

b[b] = -~b[b]

Yorumlananlar

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 bayt

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 sayesinde bayt @Arnauld değiştirerek i%56<8?"ABCDECBA".charAt(i%56%7):i%48<16?1:0için i%56<8?i%8*35%41%10%8+2:9>>i/16&1.

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

Çevrimiçi deneyin.

Açıklama:

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

Doldurduktan sonra parçaların değerleri 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

Çevrimiçi deneyin.

Kömür , 62 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Kareler sayılı bir çift sayı, bir dizi olarak girişi alır A1, B1... H8(0-endeksli) böylece, mesela, birinci test durumda ile temsil edilir [[[1, 18], [57, 42], [18, 1], [42, 57], [1, 18], [57, 42], [18, 1], [42, 57]]]ve bir çıkış olarak -pozisyon tekrarı ile çekme ise. Dönüştürme programı. Hepsi bir arada. Açıklama:

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

Sayıyı 23456432tek tek rakamlara bölün. Bunlar beyaz parçaları temsil eder.

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

Piyonları ve boş satırları ekleyin. Beyaz piyonların değeri 1ve siyah piyonları vardır -1.

Ｆ…η⁸⊞η±ι

Siyah parçaları temsil eden beyaz parçaların negatif bir kopyasını ekleyin.

Ｆθ«

Hareketlerin üzerinden geçin.

⊞υ⮌η

Kartın bir kopyasını kaydedin. (Ters çevirme, tahta kopyalamanın en golf yoludur.)

§≔η⊟ι§η§ι⁰

Hedefi kaynak parça ile güncelleyin.

§≔η⊟ι⁰

Kaynak parçayı çıkarın.

»›№υ⮌η¹

Mevcut konumun daha önce birden fazla görülüp görülmediğini belirleyin.

C # (Görsel C # Etkileşimli Derleyici) , 204 bayt

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

Girdiyi, ilk tamsayının nereden taşınacağı ve ikincisinin nereye taşınacağı tamsayı gruplarının bir listesi olarak alır. 0, A1'i temsil eder, 1, A2'dir ve 63, H8'dir.

Çevrimiçi deneyin!

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 bayt

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

Çevrimiçi deneyin!

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
}