Peg solitaire là một trò chơi phổ biến thường được chơi một mình. Trò chơi bao gồm một số chốt và một bảng được chia thành một lưới - thường thì bảng không phải là hình chữ nhật nhưng đối với thử thách này, chúng tôi sẽ giả sử như vậy.

Mỗi di chuyển hợp lệ cho phép một người loại bỏ một chốt duy nhất và mục tiêu là chơi theo cách, sao cho có một chốt duy nhất còn lại. Bây giờ, một di chuyển hợp lệ phải theo một hướng duy nhất (bắc, đông, nam hoặc đông) và nhảy qua một chốt có thể được gỡ bỏ.

Ví dụ

Đặt .các khoảng trống trên bảng và các số là các chốt, bước di chuyển sau sẽ di chuyển 1sang phải và xóa 2khỏi bảng:

.....     .....
.12..  -> ...1.
.....     .....

Di chuyển sẽ luôn phải nhảy qua một chốt duy nhất, vì vậy những điều sau đây không hợp lệ:

......    ......
.123.. -> ....1.
......    ......

Dưới đây là một số cấu hình hợp lệ sau mỗi lần di chuyển:

...1...        ...1...        ..71...        ..71...
.2.34.5  --->  .24...5  --->  .2....5  --->  ......5
.678...  (4W)  .678...  (7N)  .6.8...  (2S)  ...8...
.......        .......        .......        .2.....

Thử thách

Đưa ra một cấu hình bảng ban đầu và một số cấu hình khác, xuất ra liệu có thể đạt được cấu hình khác hay không bằng cách di chuyển các chốt xung quanh như mô tả ở trên.

Quy tắc

• Đầu vào sẽ là một ma trận / danh sách các danh sách / ... của các giá trị biểu thị một khoảng trống (ví dụ: 0 hoặc sai) hoặc các chốt (ví dụ: khác không hoặc đúng) $n \times m$
  • bạn có thể giả sử và$n \geq 3$$m \geq 3$
  • bạn có thể sử dụng true / non-zero để chỉ ra các khoảng trống và ngược lại nếu nó giúp
• Đầu ra sẽ có hai riêng biệt (một trong những giá trị có thể khác nhau) giá trị chỉ ra cho dù cuối cấu hình có thể đạt được (ví dụ. Falsy / truthy , []/ [list of moves]..)

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

initial  goal -> output
[[1,0,0],[1,1,0],[0,1,0]]  [[0,0,0],[0,1,0],[1,1,0]] -> True
[[1,0,0],[1,1,0],[0,1,0]]  [[0,0,1],[0,1,1],[0,0,0]] -> False
[[0,0,0],[1,0,0],[0,0,0]]  [[0,0,0],[0,0,1],[0,0,0]] -> False
[[0,0,0],[1,1,0],[0,0,0]]  [[0,0,0],[0,1,1],[0,0,0]] -> False
[[0,0,0,0],[1,1,1,0],[0,0,0,0]]  [[0,0,0,0],[0,0,0,1],[0,0,0,0]] -> False
[[1,0,0],[1,1,0],[1,1,1],[1,1,1]]  [[0,0,1],[0,1,0],[1,0,0],[0,0,1]] -> True
[[1,0,0],[1,1,0],[1,1,1],[1,1,1]]  [[1,0,0],[0,0,0],[0,0,0],[0,0,0]] -> False
[[1,0,1,1],[1,1,0,0],[1,1,1,0],[1,0,1,0]]  [[0,0,1,0],[1,0,0,0],[1,0,1,0],[1,0,0,1]] -> True
[[1,0,1,1],[1,1,0,0],[1,1,1,0],[1,0,1,0]]  [[0,0,0,0],[0,0,0,0],[0,0,1,0],[0,0,0,0]] -> False
[[1,0,0,0],[1,1,0,0],[1,1,1,0],[1,0,1,0]]  [[0,0,0,0],[0,0,0,0],[0,0,1,0],[0,0,0,0]] -> True
[[0,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,0]]  [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]] -> False
[[0,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,0]]  [[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]] -> False
[[0,0,0,1,0,0,0],[0,1,0,1,1,0,1],[0,1,1,1,0,0,0],[0,0,0,0,0,0,0]]  [[0,0,0,1,0,0,0],[0,1,0,1,1,0,1],[0,1,1,1,0,0,0],[0,0,0,0,0,0,0]] -> True
[[0,0,0,1,0,0,0],[0,1,0,1,1,0,1],[0,1,1,1,0,0,0],[0,0,0,0,0,0,0]]  [[0,0,0,1,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,0,0]] -> True
[[0,0,1,1,1,0,0],[0,0,1,1,1,0,0],[1,1,1,1,1,1,1],[1,1,1,0,1,1,1],[1,1,1,1,1,1,1],[0,0,1,1,1,0,0],[0,0,1,1,1,0,0]]  [[0,0,1,1,1,0,0],[0,0,1,1,1,0,0],[1,1,1,1,1,1,1],[1,1,1,1,0,0,1],[1,1,1,1,1,1,1],[0,0,1,1,1,0,0],[0,0,1,1,1,0,0]] -> True
[[0,0,1,1,1,0,0],[0,0,1,1,1,0,0],[1,1,1,1,1,1,1],[1,1,1,0,1,1,1],[1,1,1,1,1,1,1],[0,0,1,1,1,0,0],[0,0,1,1,1,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,1,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,0,0]] -> True

JavaScript (ES6),  184 178  173 byte

Đưa đầu vào là (initial_board)(target_board). Trả về hoặc .$0$$1$

a=>g=b=>a+''==b|a.some((r,y)=>r.some((v,x,A,X,R)=>[-1,0,1,2].some(h=>(A=a[y+(R=~-h%2)]||0)[X=x+(h%=2)]&v>(R=a[y+R*2]||0)[h+=x+h]&&g(b,A[X]=r[x]=R[h]++)&(A[X]=r[x]=R[h]--))))

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

(đã xóa hai trường hợp thử nghiệm cuối cùng mất quá nhiều thời gian cho TIO)

Đã bình luận

a =>                             // main function taking the initial board a[]
  g = b =>                       // g = recursive function taking the target board b[]
    a + '' == b |                // yield a truthy result if a[] is matching b[]
    a.some((r, y) =>             // for each row r[] at position y in a[]:
      r.some((v, x, A, X, R) =>  //   for each value v at position x in r[]:
        [-1, 0, 1, 2]            //     list of directions (West, North, East, South)
        .some(h =>               //     for each direction h:
          ( A =                  //       A = a[y + dy]
            a[y + (R = ~-h % 2)] //       R = dy
            || 0                 //       use a dummy row if we're out of the board
          )[X = x + (h %= 2)]    //       h = dx, X = x + dx
          &                      //       yield 1 if there's a peg on the skipped cell
          ( R =                  //       R = target row
            a[y + R * 2]         //         = a[y + 2 * dy]
            || 0                 //       use a dummy row if we're out of the board
          )[h += x + h]          //       h = x + 2 * dx = target column
          < v                    //       yield 1 if there's no peg on the target cell
          &&                     //       and there's a peg on the source cell (0 < 1)
          g(                     //       if the above result is true, do a recursive call:
            b,                   //         pass b[] unchanged
            A[X] = r[x] =        //         clear the source and skipped cells
            R[h]++               //         set the target cell
          ) & (                  //       and then restore the board to its initial state:
            A[X] = r[x] =        //         set the source and skipped cells
            R[h]--               //         clear the target cell
          )                      //
        )                        //     end of some() over directions
      )                          //   end of some() over columns
    )                            // end of some() over rows

Sạch , 232 byte

import StdEnv,Data.List
r=reverse
@[a:t=:[b,c:u]]=[[a:v]\\v<- @t]++take(a*b-c)[[0,0,1:u]];@l=[]

flip elem o\c=limit(iterate(nub o concatMap\l=[l]++[f(updateAt i p(f l))\\f<-[id,transpose],q<-f l&i<-[0..],p<- @q++(map r o@o r)q])[c])

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

Đây là một trong những dịp hiếm hoi mà tôi có thể sử dụng thành phần và cà ri trong khi lưu byte.

Giải thích:

@ :: [Int] -> [[Int]]là một hàm trợ giúp được sử dụng để tạo các hàng / cột mới tiềm năng khác nhau có thể dẫn đến việc di chuyển được thực hiện. Nó tránh được trường hợp đặc biệt [1,1,0:_]bằng cách nhận thấy rằng a*b-c>0chỉ khi nào [a,b,c]=[1,1,0], và do đó take(a*b-c)...đưa ra []bằng cách lấy -1hoặc 0các yếu tố cho tất cả các cấu hình không phải là một động thái hợp lệ.

flip elem o...đảo ngược thứ tự của các đối số thành elem(làm cho nó "không x chứa một y" thay vì "là thành viên xa của y") và áp dụng hàm ẩn danh ccho đối số đầu tiên.

\c=limit(iterate(nub o concatMap ...)[c])tạo ra mọi bảng tiềm năng có thể tạo ra từ việc ctham gia nhóm bảng hiện tại với tất cả các động thái có thể xảy ra trên tất cả các bảng và loại bỏ các bản sao, cho đến khi kết quả ngừng thay đổi.

\l=[l]++...sắp xếp bảng lvào danh sách tất cả các bảng mới tiềm năng cách xa một lần di chuyển, được tạo bằng cách áp dụng @cho các hàng của mỗi hướng của bảng (xoay 0, 90, 180, 270 độ) và thay thế hàng thay đổi tương ứng bằng hàng mới hàng.