문제:

체스에서는 반복에 의한 추첨에 대해 다소 잘 알려진 규칙이 있습니다. 동일한 위치가 3 회 이상 반복되면,이 반복을 유발할 이동을하려는 플레이어는 무승부를 요구할 수 있습니다.

마지막 몇 번의 움직임 만 플레이어가 앞뒤로 움직이는 경우 중재인이 쉽게 발견 할 수있는 작업입니다. 반복되는 위치 사이에서 조각이 크게 움직일 때 때로는 사소하지 않습니다.

이 문제의 문제는 주장 된 위치가 반복에 의해 그려지면 (3 회 이상 보았을 경우) 진실한 값을 출력하고, 좌표 표기법으로 이동 목록이 주어지면 주장 된 위치가 반복적으로 그려지지 않으면 거짓된 값을 출력하는 것입니다. 아래에 설명 된대로 또는 선택한 표기법을 사용합니다 (그러나 테스트 사례를 변환해야합니다).

직책은 무엇입니까?

실제 시나리오에서, 위치는 플레이어가 캐슬을 할 수 있는지 또는 범인이 가능한지와 같은 것들에 의해 영향을받을 것이다; 문제점에 대한 솔루션에서이를 고려 해서는 안됩니다 . 이 문제에서 위치는 단순히 보드의 조각 구성에 의해 정의됩니다. 따라서이 문제의 목적을 위해 두 보드의 각 정사각형이 동일한 유형의 동일한 색상 조각으로 채워져 있으면 두 위치가 동일한 것으로 보입니다. 예를 들어 백인 기사들이 정사각형을 바꿀 수있는 정확한 조각 일 필요는 없으며 다른 모든 조각이 기준을 충족하면 여전히 동일한 위치에있게됩니다.

유효한 표기법은 무엇입니까?

좌표 표기법을 계속 설명하지만, 선택한 표기법 시스템으로 자유롭게 입력 할 수 있습니다. 제공 :

• 표기법의 각 항목은 다음 중 하나 또는 모두를 설명합니다. 수표, 수표, 이중 수표, 수표 또는 교착 상태 여부; 동반자 캡처가 발생한 경우; 초기 위치; 최종 위치.
• 표기법에 반복에 대한 정보 가 없을 수 있습니다 .

이러한 기준이 충족되는 한, 답변, 표기법에 명시되어있는 한 기꺼이 받아들입니다. 이것은 예를 들어 0 인덱스 행, 열 튜플 또는 프로그램에 적합한 것이 될 수 있습니다.

좌표 표기법

좌표 표기법은 동작을 좌표 시스템으로 만 설명하는 표기법입니다.

이동은 먼저 세트에서 초기 좌표로, {A1-H8}그런 다음 동일한 세트에서 대상 좌표로 다시 설명됩니다. 따라서 King 's Gambit 은 (줄 모음으로)

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

나는이 문제에 사용하는 것이 가장 좋은 표기법이라고 생각합니다. 왜냐하면 검사가 발생했는지 또는 조각 이동 유형과 같은 외부 정보로 가득 차 있지 않기 때문입니다. 이전에 언급 된 표기법을 선택할 수 있으므로 대수 표기법 과 같은 다른 표기법을 사용 하거나이 표기법을 적용 할 수 있습니다 (예 : 대시를 제거하거나 튜플 목록으로 사용).

규칙 :

• 당신은해야 하지 가 반복 발생 여부 만, 위치 또는 이동이 유효한지 여부를 고려
• 거세 및 폰 프로모션이 발생 하지 않을 것이라고 가정 할 수 있습니다.
• 문자열 목록을 입력으로 가져 와서 마지막 이동에서 세 번째 (또는 그 이상) 반복이 발생했는지 여부에 해당하는 참 또는 거짓 값을 출력해야합니다.
• 게임은 항상 체스의 표준 시작 위치에서 시작합니다. 초기 위치는 반복으로 계산 될 수 있습니다.
• 최종 이동으로 위치가 반복되지 않으면 반복에 의한 드로우가 발생하지 않습니다

일반 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하지 마십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙 은 기본 I / O 규칙으로 답변에 적용 되므로 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

ngn 덕분에 -4입니다.

전체 프로그램. 반전 된 좌표 쌍의 반전 된 목록을 요구하는 프롬프트 :
 예 : {"B1-C3","B8-C6"}is[[[8,2],[6,3]],[[1,2],[3,3]]]

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

온라인으로 사용해보십시오! ( CoordsOP 형식을 변환 하는 유틸리티 기능 포함 )

상태 목록을 설정하십시오.

s←3 세 지정 s(대한 의의 tates를)

3은 유효한 보드 상태가 아니기 때문에 반복 횟수에 영향을 미치지 않으며 할당의 통과 값이 필요합니다.

체스 판 표현을 만듭니다.

5... (5)와 (3) 사이의 다음의 유도 함수를 적용한 결과를 버리는 것을 :
 ⍥⍳ 이들 모두에 인수 연장 ɩ의 ndices;
  [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을 (각 행에) 붙입니다;
 [[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으로 채워지는 음수 (즉, 마지막) 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 . 0
  , 다음
  ∘ 에
  ⊃ 첫 번째 값 ^이 오면
^{첫 번째 좌표의 값을 두 번째 좌표로 효과적으로 "이동하여"0 뒤에 남습니다.}

최종 상태가 3 개 이상 있는지 확인하십시오.

s∩ 모든 국가와 그 최종 국가의 교차점; 그것과 동일한 상태의 부분 집합

≢ 그들을 집계

2≤ 2 개 이상 (즉, 최종 상태를 포함하여 3 개 이상)이 있는지 확인

* 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의 바닥 글 코드는 OP에서 제공 한 이동을 숫자 형식으로 변환하지만 질문 아래의 논의에 따라 숫자 형식은 유효한 입력이었습니다.

설명

Ø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

자바 스크립트 (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 / A / 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

자바 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-indexed) 인 숫자 쌍의 배열로 입력을 취 합니다. 예를 들어 첫 번째 테스트 사례는로 표시되고 위치가 반복에 의한 추첨 인 경우 [[[1, 18], [57, 42], [18, 1], [42, 57], [1, 18], [57, 42], [18, 1], [42, 57]]]a를 출력합니다 -. 전환 프로그램. 하나로. 설명:

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

숫자 23456432를 개별 숫자로 나눕니다. 이들은 흰색 조각을 나타냅니다.

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

폰과 빈 행에 추가하십시오. 하얀 폰은 가치가 1있고 검은 폰은 -1있습니다.

Ｆ…η⁸⊞η±ι

검은 조각을 나타내는 흰색 조각의 부정 사본을 추가하십시오.

Ｆθ«

움직임을 반복합니다.

⊞υ⮌η

보드 사본을 저장하십시오. (반전은 보드를 복사하는 가장 골프적인 방법입니다.)

§≔η⊟ι§η§ι⁰

소스 부분으로 대상을 업데이트하십시오.

§≔η⊟ι⁰

소스 조각을 제거하십시오.

»›№υ⮌η¹

현재 위치가 두 번 이상 표시되었는지 확인하십시오.

C # (Visual C # 대화식 컴파일러) 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
}

자바 (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
}