Проблема:

У шахах є дещо відоме правило щодо малювання шляхом повторення. Якщо однакова позиція повторюється 3 рази (або більше), гравець, який має намір зробити хід, що спричинить це повторення, може вимагати нічиї.

Іноді арбітр може виявити це легке завдання, якщо останні кілька рухів - це лише гравці, які рухаються вперед і вперед. Іноді це менш банально, коли шматки значно перемістилися між повторними положеннями.

Проблема в цьому виклику полягає у виведенні триєтного значення, якщо заявлена ​​позиція витягується шляхом повторення (бачили 3 рази або більше) та значення фальси, якщо заявлена ​​позиція не намальована повтором, з урахуванням переліку ходів у позначенні координат як описано нижче, або будь-яке позначення на ваш вибір (але вам доведеться конвертувати тестові випадки).

Що таке посада?

У реальному сценарії на позицію впливатимуть такі речі, як, наприклад, чи може гравець грати в замок, чи можливий обхід; ви повинні НЕ враховувати їх у вашому рішенні цієї проблеми. У цій проблемі позиція визначається просто конфігурацією частин на дошці. Отже, для цієї проблеми дві позиції вважаються однаковими, якщо кожен квадрат на обох дошках займає один і той же тип шматка одного кольору. Це не повинно бути точним твором, наприклад, білі рицарі можуть міняти квадрати, і якби всі інші шрифти відповідали критеріям, це все одно буде однаковою.

Як виглядає дійсне позначення?

Хоча я продовжуватиму пояснювати позначення координат, ви можете взяти на себе інформацію із обраної вами системи нотацій. За умови, що:

• Кожен елемент нотації описує будь-який або всі: задіяний фрагмент / шматок; чи були доставлені чек, мат, подвійний чек, мат або патч; якщо відбулося безперервне захоплення; вихідне положення; кінцева позиція.
• Ви можете не мати інформації про повторення в нотації.

Поки ці критерії виконуються, я з радістю приймаю, доки ви вказуєте у своїй відповіді, вашу систему нотацій. Це може бути, наприклад, 0 індексованих рядків, кортежів стовпців або будь-якого сенсу для вашої програми.

Позначення координат

Позначення координат - це позначення, яке суто описує рухи як систему координат.

Рух описується як спочатку початкова координата з набору, {A1-H8}а потім цільова координата знову з того ж набору. Так виглядав Гамбіт короля (як колекція струн)

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

Я вважаю, що найкраще позначити цю проблему, оскільки вона не заповнена сторонньою інформацією, наприклад, чи відбулася перевірка чи тип переміщення шматка. Як згадувалося раніше, позначення можуть бути на ваш вибір, тому ви можете використовувати інше позначення, наприклад, алгебраїчне позначення або ви можете адаптувати це позначення (наприклад, видаліть тире або взяти як список кортежів)

Правила:

• Ви повинні НЕ розглянути чи положення або рух дійсно, викликає тільки повторення
• Ви можете припустити, що просування по службі та пішака не відбудеться.
• Ви повинні взяти список рядків як введення та виведення значення truthy або falsey, що відповідає тому, чи відбулося третє (або більше) повторення під час остаточного ходу
• Гра завжди починається зі стандартної вихідної позиції для шахів. Початкова позиція може рахуватися з повторенням.
• Нічия шляхом повторення не відбулося, якщо позиція не повторилася остаточним ходом

Загальні правила:

• Це код-гольф , тому найкоротша відповідь у байтах виграє.
  Не дозволяйте мовам з кодовим гольфом відштовхувати вас від публікації відповідей з мов, що не кодують гольф. Спробуйте придумати якомога коротшу відповідь на "будь-яку" мову програмування.
• Для вашої відповіді застосовуються стандартні правила з правилами вводу / виводу за замовчуванням , тому вам дозволяється використовувати STDIN / STDOUT, функції / метод із відповідними параметрами та повним програмами типу повернення. Твій дзвінок.
• Лазівки за замовчуванням заборонені.
• Якщо можливо, додайте посилання з тестом для вашого коду (тобто TIO ).
• Також настійно рекомендується додавати пояснення до своєї відповіді.

Випробування

Ви повинні повернути триєдні значення для:

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

І значення фальси для:

{}
{"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 байт ^SBCS

-4 завдяки ngn.

Повна програма. Підказки до переверненого списку обернених пар координат:
 наприклад, {"B1-C3","B8-C6"}є[[[8,2],[6,3]],[[1,2],[3,3]]]

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

Спробуйте в Інтернеті! (включає функцію утиліти, Coordsяка перекладає формат ОП)

Налаштування списку станів:

s←3 призначити трьох s(для s tates)

Оскільки 3 не є дійсним станом плати, це не вплине на кількість повторень, і нам потрібно прохідне значення завдання…

Побудуйте подання на шаховій дошці:

5... відмовтеся від того, що в результаті застосування наступної похідної функції між 5 і 3: розкладіть
 ⍥⍳  обидва аргументи на свої ɩɩdices; ...  лівий бік з'єднаний із зворотним боком правого боку, це представляють офіцери
  [1,2,3,4,5][1,2,3]
 ,∘⌽
  [1,2,3,4,5,3,2,1]

⍪ скласти в стіл;
 [[1],
  [2],
  [3],
  [4],
  [5],
  [3],
  [2],
  [1]]

6, додайте (до кожного ряду) шість, що представляє пішаки;
 [[6,1],
  [6,2],
  [6,3],
  [6,4],
  [6,5],
  [6,3],
  [6,2],
  [6,1]]

⍉ переносити;
 [[6,6,6,6,6,6,6,6],
  [1,2,3,4,5,3,2,1]]

¯4↑ візьміть від’ємні (тобто останні) чотири (ряди), забивши нулями, представляючи порожні квадрати;
 [[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]]

(… ) Застосувати до цього таку негласну функцію:

 - негативні (це являє собою протилежний колір);
  [[ 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]]

  ⊖⍪ складіть перевернутий аргумент поверх цього, даючи нам повний пансіон;
  [[ 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]]

Побудуйте список кроків, що супроводжуються початковим станом:

⊂ додайте до цього (трактувати це як єдину одиницю)

⎕, підкажіть список переходів та додайте його до початкового стану

Зменшити * функцією, яка додає поточний стан до списку та робить крок:

{… }/ Зменшити на анонімну лямбда:

 ⍵ правильний аргумент (поточний стан)

 ⊂ додайте його, щоб розглянути його як одиницю

 s,← на місці додайте його до списку штатів

 ⊃ розкрийте його, щоб використовувати цей стан

 … @⍺ У елементах з двома координатами, які представляє лівий аргумент, поставте:
  0 нуль,
  , за
  ∘ яким
  ⊃ перше значення,
^{це ефективно «переміщує» значення на першій координаті до другої координати, залишаючи позаду нуль}

Перевірте, чи є у нас три чи більше остаточного стану:

s∩ перетин усіх станів із тим кінцевим; підмножина ідентичних йому станів

≢ підрахуйте їх

2≤ перевірити, чи є дві або більше (тобто три чи більше, включаючи кінцевий стан)

* APL є право-асоціативною, тому спочатку функція викликається початковим станом як аргумент права, а початковий хід - як аргумент ліворуч, а потім його результат, новий стан, стає новим правим аргументом, а другий рухається як новий лівий аргумент та ін. Кінцевим результатом є

R , 180 177 144 байт

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}

Спробуйте в Інтернеті!

-3 байти завдяки Джузеппе
-29 байтів завдяки використанню Ніка Кеннеді Reduceта -rev(l)
4 байти за допомогою зворотного ходуz

В якості введення приймає вектор цілих чисел між 1 і 64, що позначає квадрати. TIO включає функцію перетворення в цей формат. Різні шматки зберігаються у вигляді цілих чисел між 1 і 6 та між -1 і -6.

Пояснення:

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
}

Желе , 41 37 байт

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

Спробуйте в Інтернеті!

Монадічне посилання, яке сприймає вхід як список пар 1-індексованих рядків-основних рухів [from, to]і повертає 1 для малюнків і 0 для не.

Зверніть увагу, що код нижнього колонтитулу в TIO переводить ходи, надані ОП, в цифровий формат, але відповідно до обговорення під питанням, цифровий формат був би коректним вводом.

Пояснення

Ø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 байт

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

Повертає булеве значення.

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

Спробуйте в Інтернеті!

Як?

Шматки

Значення, які використовуються для ідентифікації шматочків, насправді не мають значення, якщо існує одне унікальне значення на тип шматка.

Ми використовуємо:

• 0 для порожніх квадратів
• 1 / 8 / 9 / / B / C для ♟ / ♜ / ♞ / ♝ / ♛ / ♚
• 2 / 3 / 4 / 5 / 6 / 7 для ♙ / ♖ / ♘ / ♗ / ♕ / ♔

Рада та початкова позиція

$b$

• '89ABCA981111111' → 8 основних чорних шматочків, а потім перші 7 чорних пішаків
• 10n**32n$\text{h7}$$1$$0$
• 0x7e5196ee74377→ всі білі шматки (витрачаються до 2222222234567543десяткової)

що призводить до:

    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

Відстеження позицій

$b$$b$

Ось чому ми робимо:

b[b] = -~b[b]

Прокоментував

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 байт

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 байт завдяки @Arnauld , змінивши 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.

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

Спробуйте в Інтернеті.

Пояснення:

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

Значення шматочків після їх заповнення 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

Спробуйте в Інтернеті.

Вугілля деревне , 62 байти

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Приймає вхідний сигнал в вигляді масиву пар чисел , де пронумеровані квадрати A1, B1, ... H8(0-індексований) , так, наприклад , перший тестовий випадок буде представлений в вигляді [[[1, 18], [57, 42], [18, 1], [42, 57], [1, 18], [57, 42], [18, 1], [42, 57]]]і виводить , -якщо позиція нічия повторенням. Програма перетворення. Все в одному. Пояснення:

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

Розділіть число 23456432на окремі цифри. Вони представляють білі шматки.

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

Додайте в пішаки та порожні ряди. Білі пішаки мають значення, 1а чорні пішаки -1.

Ｆ…η⁸⊞η±ι

Додайте заперечну копію білих шматочків, які представляють чорні шматки.

Ｆθ«

Петля за ходами.

⊞υ⮌η

Збережіть копію дошки. (Реверсування - це найголовніший спосіб копіювання дошки.)

§≔η⊟ι§η§ι⁰

Оновіть призначення за допомогою вихідного фрагмента.

§≔η⊟ι⁰

Вийміть шматочок джерела.

»›№υ⮌η¹

Визначте, чи бачили поточну позицію не раз.

C # (Visual C # Interactive Compiler) , 204 байти

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

Вводиться в якості списку кортезів цілих чисел, де перше ціле число - куди рухатися, а друге - куди рухатися. 0 являє собою A1, 1 є A2, а 63 є H8.

Спробуйте в Інтернеті!

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 байт

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

Спробуйте в Інтернеті!

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
}