Vấn đề:

Trong cờ vua, có một quy tắc khá nổi tiếng về vẽ bằng cách lặp lại. Nếu cùng một vị trí được lặp lại 3 lần (hoặc nhiều hơn) thì người chơi có ý định thực hiện di chuyển sẽ gây ra sự lặp lại này có thể yêu cầu rút thăm.

Đôi khi đây là một nhiệm vụ dễ dàng để một trọng tài phát hiện ra, nếu một vài động tác cuối cùng chỉ là những người chơi di chuyển lùi và tiến. Đôi khi nó ít tầm thường hơn, khi các mảnh đã di chuyển đáng kể giữa các vị trí lặp đi lặp lại.

Vấn đề trong thử thách này là đưa ra một giá trị trung thực nếu vị trí được yêu cầu được rút ra bởi sự lặp lại (đã được nhìn thấy 3 lần trở lên) và giá trị falsey nếu vị trí được yêu cầu không được vẽ bởi sự lặp lại, đưa ra một danh sách các bước di chuyển trong ký hiệu phối hợp như được mô tả dưới đây, hoặc bất kỳ ký hiệu nào bạn chọn (nhưng bạn sẽ phải chuyển đổi các trường hợp thử nghiệm).

Một vị trí là gì?

Trong một kịch bản trong thế giới thực, vị trí sẽ bị ảnh hưởng bởi những thứ như liệu người chơi có thể xây lâu đài hay liệu người đi đường có khả thi hay không; bạn không nên xem xét những điều này trong giải pháp của bạn cho vấn đề. Trong bài toán này, một vị trí được xác định đơn giản bởi cấu hình của các mảnh trên bảng. Vì vậy, đối với các mục đích của vấn đề này, hai vị trí được coi là giống nhau nếu mỗi ô vuông trên cả hai bảng được chiếm bởi cùng một loại mảnh cùng màu. Đây không phải là mảnh ghép chính xác, ví dụ các hiệp sĩ của người da trắng có thể hoán đổi hình vuông và nếu tất cả các mảnh khác đáp ứng các tiêu chí thì đây vẫn sẽ là vị trí tương tự.

Một ký hiệu hợp lệ trông như thế nào?

Mặc dù tôi sẽ tiếp tục giải thích ký hiệu tọa độ, bạn có thể tự do lấy đầu vào bằng một hệ thống ký hiệu bạn chọn. Với điều kiện:

• Mỗi mục trong ký hiệu mô tả bất kỳ hoặc tất cả: phần / mảnh liên quan; cho dù kiểm tra, checkmate, kiểm tra kép, checkmate hay bế tắc đã được chuyển giao; nếu bắt giữ en-passant đã xảy ra; vị trí ban đầu; vị trí cuối cùng.
• Bạn có thể không có thông tin về sự lặp lại trong ký hiệu của bạn.

Vì vậy, miễn là các tiêu chí này được đáp ứng, tôi rất vui lòng chấp nhận, miễn là bạn chỉ định trong câu trả lời của mình, hệ thống ký hiệu của bạn. Điều này có thể là ví dụ 0 hàng được lập chỉ mục, bộ dữ liệu cột hoặc bất cứ điều gì có ý nghĩa cho chương trình của bạn.

Ký hiệu phối hợp

Ký hiệu tọa độ là ký hiệu mô tả hoàn toàn các bước di chuyển như một hệ tọa độ.

Di chuyển được mô tả là đầu tiên tọa độ ban đầu từ tập hợp {A1-H8}và sau đó tọa độ đích lại từ cùng một tập hợp. Vì vậy, King Gambit sẽ trông như thế (như một bộ sưu tập các chuỗi)

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

Tôi tin rằng đó là ký hiệu tốt nhất để sử dụng cho vấn đề này bởi vì nó không chứa đầy thông tin bên ngoài như liệu kiểm tra đã xảy ra hay loại mảnh di chuyển là gì. Như đã đề cập trước khi ký hiệu có thể là lựa chọn của bạn, vì vậy bạn có thể sử dụng một ký hiệu khác, ví dụ ký hiệu đại số hoặc bạn có thể điều chỉnh ký hiệu này (ví dụ: xóa dấu gạch ngang hoặc lấy làm danh sách các bộ dữ liệu)

Quy tắc:

• Bạn không nên xem xét một vị trí hoặc di chuyển là hợp lệ, chỉ khi nó gây ra sự lặp lại
• Bạn có thể cho rằng khuyến mãi đúc và cầm đồ sẽ không xảy ra.
• Bạn nên lấy một danh sách các chuỗi làm đầu vào và đầu ra một giá trị trung thực hoặc falsey tương ứng với việc lặp lại lần thứ ba (hoặc nhiều hơn) đã xảy ra ở bước cuối cùng
• Trò chơi luôn bắt đầu ở vị trí bắt đầu tiêu chuẩn cho cờ vua. Vị trí ban đầu có thể được tính vào sự lặp lại.
• Vẽ bởi sự lặp lại đã không xảy ra nếu vị trí không được lặp lại bởi bước di chuyển cuối cùng

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn (ví dụ TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

Các trường hợp thử nghiệm

Bạn nên trả về các giá trị trung thực cho:

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

Và giá trị falsey cho:

{}
{"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 mở rộng) , 55 49 47 45 44 byte ^SBCS

-4 cảm ơn ngn.

Chương trình đầy đủ. Lời nhắc cho danh sách các cặp tọa độ đảo ngược:
 vd {"B1-C3","B8-C6"}là[[[8,2],[6,3]],[[1,2],[3,3]]]

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

Hãy thử trực tuyến! (bao gồm chức năng tiện ích Coordsdịch định dạng của OP)

Thiết lập danh sách các trạng thái:

s←3 gán ba cho s(cho s tates)

Vì 3 không phải là trạng thái bảng hợp lệ, nó sẽ không ảnh hưởng đến số lần lặp lại của chúng tôi và chúng tôi cần giá trị chuyển qua của phép gán

Xây dựng một đại diện bàn cờ:

5... loại bỏ rằng đối với kết quả của việc áp dụng các chức năng có nguồn gốc sau đây giữa 5 và 3:
 ⍥⍳ mở rộng cả đối số của họ ɩ ndices;
  [1,2,3,4,5]... [1,2,3]
 ,∘⌽ phía bên trái nối với mặt trái của phía bên phải
  [1,2,3,4,5,3,2,1]này đại diện cho cán bộ

⍪ làm thành bàn;
 [[1],
  [2],
  [3],
  [4],
  [5],
  [3],
  [2],
  [1]]

6, trả trước (cho mỗi hàng) một sáu, đại diện cho cầm đồ;
 [[6,1],
  [6,2],
  [6,3],
  [6,4],
  [6,5],
  [6,3],
  [6,2],
  [6,1]]

⍉ chuyển vị;
 [[6,6,6,6,6,6,6,6],
  [1,2,3,4,5,3,2,1]]

¯4↑ lấy bốn âm (tức là cuối cùng) bốn (hàng), đệm bằng số không, biểu thị các ô vuông trống;
 [[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]]

(... ) áp dụng các chức năng ngầm sau đó:

 - phủ định (điều này đại diện cho màu đối diện);
  [[ 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]]

  ⊖⍪ xếp chồng đối số lên trên đó, cho chúng ta bảng đầy đủ;
  [[ 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]]

Xây dựng danh sách các bước di chuyển theo trạng thái ban đầu:

⊂ kèm theo đó (để coi nó như một đơn vị)

⎕, nhắc nhở danh sách các di chuyển và đưa nó vào trạng thái ban đầu

Giảm * bởi một chức năng nối thêm trạng thái hiện tại vào danh sách và thực hiện di chuyển:

{... }/ giảm bởi lambda ẩn danh sau đây:

 ⍵ đối số đúng (trạng thái hiện tại)

 ⊂ kèm theo nó để coi nó như một đơn vị

 s,← tại chỗ nối nó vào danh sách các tiểu bang

 ⊃ tiết lộ nó để sử dụng trạng thái đó

 ... @⍺ tại các yếu tố với hai tọa độ mà các lập luận trái đại diện, đặt:
  0 một số không
  , theo sau
  ∘ bởi
  ⊃ giá trị đầu tiên
^{này một cách hiệu quả "di chuyển" giá trị tại đầu tiên phối hợp với phối hợp thứ hai, để lại đằng sau một số không}

Kiểm tra xem chúng tôi có ba hoặc nhiều trạng thái cuối cùng không:

s∩ giao điểm của tất cả các trạng thái với trạng thái cuối cùng đó; tập hợp con của các trạng thái giống hệt nó

≢ kiểm đếm chúng lên

2≤ kiểm tra xem có hai hoặc nhiều hơn (tức là ba hoặc nhiều hơn bao gồm cả trạng thái cuối cùng)

* APL là liên kết phải, do đó, đầu tiên hàm được gọi với trạng thái ban đầu là đối số bên phải và di chuyển ban đầu là đối số bên trái, và sau đó kết quả của nó, trạng thái mới, trở thành đối số bên phải mới với di chuyển thứ hai là đối số bên trái mới , vv Kết quả cuối cùng là

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}

Hãy thử trực tuyến!

-3 byte nhờ Giuseppe
-29 byte nhờ sử dụng Reducevà -rev(l)
-4 byte của Nick Kennedy bằng cách đảo ngượcz

Lấy đầu vào là một vectơ số nguyên từ 1 đến 64 biểu thị các hình vuông. TIO bao gồm một chức năng để chuyển đổi sang định dạng đó. Các mảnh khác nhau được lưu trữ dưới dạng số nguyên giữa 1 và 6 và giữa -1 và -6.

Giải trình:

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
}

Thạch , 41 37 byte

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

Hãy thử trực tuyến!

Một liên kết đơn âm lấy đầu vào là một danh sách các cặp di chuyển chính 1 hàng được lập chỉ mục [from, to]và trả về 1 cho các lần rút và 0 cho không.

Lưu ý mã chân trang trên TIO chuyển các bước di chuyển do OP cung cấp sang định dạng số, nhưng theo cuộc thảo luận bên dưới câu hỏi, định dạng số sẽ là một đầu vào hợp lệ.

Giải trình

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

Trả về giá trị Boolean.

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

Hãy thử trực tuyến!

Làm sao?

Miếng

Các giá trị được sử dụng để xác định các mảnh không thực sự quan trọng miễn là có một giá trị duy nhất cho mỗi loại mảnh.

Chúng tôi sử dụng:

• 0 cho hình vuông trống
• 1 / 8 / 9 / Một / B / C cho ♟ / ♜ / ♞ / ♝ / ♛ / ♚
• 2 / 3 / 4 / 5 / 6 / 7 cho ♙ / ♖ / ♘ / ♗ / ♕ / ♔

Hội đồng quản trị và vị trí ban đầu

$b$ được khởi tạo bằng cách chia phần nối của các phần sau:

• '89ABCA981111111' → 8 mảnh lớn màu đen, tiếp theo là 7 con tốt đầu tiên
• 10n**32n$\text{h7}$$1$$0$ )
• 0x7e5196ee74377→ tất cả các mảnh màu trắng (kéo dài đến 2222222234567543thập phân)

kết quả là:

    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

Theo dõi các vị trí

$b$$b$ và hoàn toàn bị ép buộc thành một chuỗi.

Đây là lý do tại sao chúng tôi làm:

b[b] = -~b[b]

Đã bình luận

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 nhờ @Arnauld bằng cách thay đổi i%56<8?"ABCDECBA".charAt(i%56%7):i%48<16?1:0thành i%56<8?i%8*35%41%10%8+2:9>>i/16&1.

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

Hãy thử trực tuyến.

Giải trình:

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

Các giá trị của các mảnh sau khi điền chúng A[i]=(i%56<8?i%8*35%41%10%8+2:9>>i/16&1)*(i/32*2-1)là:

     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

Hãy thử trực tuyến.

Than , 62 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Lấy đầu vào là một mảng các cặp số trong đó các ô vuông được đánh số A1, B1... H8(được lập chỉ mục 0), ví dụ, trường hợp thử nghiệm đầu tiên sẽ được biểu diễn dưới dạng [[[1, 18], [57, 42], [18, 1], [42, 57], [1, 18], [57, 42], [18, 1], [42, 57]]]và xuất ra -nếu vị trí được vẽ bằng cách lặp lại. Chương trình chuyển đổi. Tất cả hợp lại thành một. Giải trình:

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

Chia số 23456432thành các chữ số riêng lẻ. Chúng đại diện cho các mảnh màu trắng.

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

Thêm vào những con tốt và hàng trống. Những con tốt trắng có giá trị 1và những con tốt màu đen -1.

Ｆ…η⁸⊞η±ι

Nối một bản sao phủ định của các mảnh màu trắng, đại diện cho các mảnh màu đen.

Ｆθ«

Vòng qua di chuyển.

⊞υ⮌η

Lưu một bản sao của bảng. (Đảo ngược là cách tốt nhất để sao chép bảng.)

§≔η⊟ι§η§ι⁰

Cập nhật điểm đến với phần nguồn.

§≔η⊟ι⁰

Loại bỏ các phần nguồn.

»›№υ⮌η¹

Xác định xem vị trí hiện tại đã được nhìn thấy nhiều hơn một lần trước đây.

C # (Trình biên dịch tương tác 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;}

Lấy đầu vào là một danh sách các bộ số nguyên, trong đó số nguyên đầu tiên là nơi để di chuyển và thứ hai là nơi để di chuyển đến. 0 đại diện cho A1, 1 là A2 và 63 là H8.

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

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
}