Đồng hồ là một trò chơi bài thú vị, vì nó không đòi hỏi kỹ năng. Đây là một trò chơi một người chơi và cùng một cấu hình thẻ luôn dẫn đến thắng hoặc thua. Trong thử thách này, bạn cần tìm hiểu xem một cấu hình thẻ nhất định sẽ thắng hay thua . Bạn có thể chơi trò chơi ở đây .

Trò chơi được chơi như sau:

1. Mười ba đống thẻ được úp xuống. Mỗi cọc được đánh số từ 0 đến 12.
2. Chúng tôi đặt cọc thứ 0 là cọc hiện tại
3. Chúng tôi lật thẻ trên cùng của mặt cọc hiện tại lên.
4. Chúng tôi di chuyển thẻ úp lên ở dưới cùng của đống tương ứng (Thẻ A 4 nằm dưới cọc thứ 4) . Thẻ vẫn úp. Cọc này trở thành cọc hiện tại.
5. Nếu đống hiện tại hoàn toàn ngửa mặt, thì trò chơi kết thúc. Nếu không, quay lại bước 3.

Mẹo: Trò chơi sẽ luôn kết thúc ở cọc thứ 0

Trò chơi được chiến thắng nếu tất cả các thẻ kết thúc trực diện và bị mất nếu còn lại các thẻ úp.

Đầu ra đầu vào

Một mảng 2D chứa mỗi cọc. Thẻ được thể hiện với các số từ 0 đến 12 (bộ đồ không liên quan và không được cung cấp). Thẻ trên cùng của mỗi cọc là phần tử đầu tiên của mỗi mảng.

Bạn có thể giả định rằng đầu vào sẽ được hình thành tốt: nó sẽ chứa 52 thẻ từ 0 đến 12 (bao gồm) và chứa mỗi số chính xác 4 lần.

Bạn phải trả về một giá trị trung thực nếu trò chơi có thể giành chiến thắng và giả mạo nếu không thể.

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

Sự thật:

[[11, 11, 7, 7], [8, 6, 5, 0], [2, 10, 9, 1], [12, 3, 0, 6], [8, 7, 4, 8], [3, 10, 5, 12], [11, 7, 1, 10], [3, 1, 6, 0], [2, 3, 0, 6], [5, 10, 5, 4], [12, 9, 11, 2], [9, 4, 12, 4], [1, 9, 8, 2]]
[[0, 9, 4, 8], [1, 4, 11, 3], [10, 12, 4, 0], [5, 9, 11, 5], [7, 0, 11, 2], [6, 5, 6, 0], [5, 7, 6, 7], [1, 10, 3, 4], [10, 11, 12, 3], [9, 9, 3, 6], [12, 12, 2, 1], [1, 8, 8, 2], [7, 2, 10, 8]]
[[11, 11, 9, 5], [3, 0, 1, 7], [6, 2, 9, 4], [6, 9, 11, 2], [10, 9, 6, 1], [12, 8, 10, 0], [2, 3, 12, 3], [3, 12, 5, 11], [4, 1, 8, 12], [7, 0, 2, 5], [4, 1, 10, 4], [7, 10, 6, 5], [8, 8, 0, 7]]
[[2, 3, 4, 11], [6, 12, 5, 9], [11, 0, 5, 9], [1, 8, 0, 12], [11, 9, 5, 8], [12, 7, 1, 0], [10, 3, 1, 11], [3, 12, 7, 2], [2, 7, 1, 5], [6, 3, 4, 10], [10, 10, 9, 8], [6, 2, 4, 4], [6, 8, 0, 7]]
[[1, 2, 12, 9], [5, 6, 4, 11], [0, 0, 7, 10], [9, 7, 12, 0], [12, 1, 8, 6], [10, 1, 4, 8], [9, 2, 6, 11], [10, 12, 1, 8], [6, 7, 0, 3], [2, 2, 5, 5], [8, 11, 9, 3], [4, 7, 3, 10], [5, 11, 4, 3]]
[[8, 12, 5, 3], [3, 10, 0, 6], [4, 11, 2, 12], [6, 1, 1, 12], [7, 6, 5, 0], [0, 8, 8, 7], [4, 8, 1, 2], [2, 3, 11, 6], [11, 10, 5, 2], [10, 1, 9, 4], [12, 5, 9, 7], [7, 3, 10, 9], [9, 0, 11, 4]]
[[3, 4, 8, 7], [2, 2, 8, 9], [12, 7, 0, 4], [4, 7, 10, 11], [5, 10, 3, 11], [10, 9, 8, 7], [5, 2, 11, 8], [6, 0, 3, 10], [9, 1, 4, 12], [12, 3, 12, 6], [2, 5, 1, 1], [6, 11, 5, 1], [6, 9, 0, 0]]
[[11, 9, 11, 1], [1, 3, 2, 8], [3, 3, 6, 5], [8, 11, 7, 4], [9, 4, 5, 1], [6, 4, 12, 6], [12, 10, 8, 7], [3, 9, 10, 0], [2, 8, 11, 9], [2, 4, 1, 0], [12, 5, 6, 0], [10, 7, 10, 2], [5, 0, 12, 7]]
[[9, 9, 6, 5], [7, 5, 11, 9], [8, 12, 3, 7], [1, 2, 4, 10], [11, 3, 3, 10], [2, 0, 12, 11], [4, 7, 12, 9], [3, 6, 11, 1], [1, 10, 12, 0], [5, 6, 8, 0], [4, 10, 2, 5], [8, 8, 1, 6], [0, 7, 2, 4]]
[[4, 0, 7, 11], [1, 5, 2, 10], [2, 9, 10, 0], [4, 12, 1, 9], [10, 12, 7, 0], [9, 4, 1, 8], [6, 6, 9, 12], [5, 3, 6, 2], [11, 3, 6, 4], [7, 3, 5, 5], [11, 8, 1, 11], [10, 7, 2, 8], [8, 12, 0, 3]]

Giả mạo:

[[8, 1, 6, 1], [7, 9, 0, 12], [11, 12, 12, 12], [11, 5, 9, 3], [2, 10, 9, 7], [11, 2, 0, 8], [0, 10, 4, 6], [8, 0, 4, 2], [6, 5, 3, 8], [4, 10, 3, 1], [5, 11, 9, 6], [7, 5, 1, 4], [2, 7, 3, 10]]
[[1, 4, 4, 6], [3, 11, 1, 2], [8, 5, 10, 12], [7, 10, 7, 5], [12, 8, 3, 7], [4, 0, 12, 12], [1, 1, 9, 6], [8, 7, 5, 10], [11, 0, 11, 0], [5, 10, 3, 11], [3, 2, 9, 8], [9, 6, 0, 2], [2, 6, 9, 4]]
[[10, 1, 10, 7], [12, 3, 11, 4], [0, 5, 10, 7], [5, 11, 1, 3], [6, 6, 9, 4], [9, 0, 8, 6], [9, 12, 7, 10], [1, 6, 3, 9], [0, 5, 0, 2], [4, 8, 1, 11], [7, 12, 11, 3], [8, 2, 2, 2], [8, 4, 12, 5]]
[[3, 8, 0, 6], [11, 5, 3, 9], [11, 6, 1, 0], [3, 7, 3, 10], [6, 10, 1, 8], [11, 12, 1, 12], [8, 11, 7, 7], [1, 8, 2, 0], [9, 4, 0, 10], [10, 2, 12, 12], [7, 4, 4, 2], [9, 4, 5, 5], [6, 2, 9, 5]]
[[0, 1, 9, 5], [0, 1, 11, 9], [12, 12, 7, 6], [3, 12, 9, 4], [2, 10, 3, 1], [6, 2, 3, 2], [8, 11, 8, 0], [7, 4, 8, 11], [11, 8, 10, 6], [7, 5, 3, 6], [0, 10, 9, 10], [1, 4, 7, 12], [5, 5, 2, 4]]
[[9, 8, 0, 6], [1, 1, 7, 8], [3, 2, 3, 7], [9, 10, 12, 6], [6, 12, 12, 10], [11, 4, 0, 5], [10, 11, 10, 7], [5, 3, 8, 8], [1, 2, 11, 4], [0, 5, 6, 0], [5, 9, 2, 4], [4, 2, 3, 11], [9, 1, 12, 7]]
[[4, 3, 5, 7], [1, 9, 1, 3], [7, 9, 12, 5], [9, 0, 5, 2], [7, 2, 11, 9], [1, 6, 6, 4], [11, 0, 6, 4], [3, 0, 8, 10], [2, 10, 5, 3], [10, 11, 8, 12], [8, 1, 12, 0], [7, 12, 11, 2], [10, 6, 8, 4]]
[[9, 5, 11, 11], [7, 7, 8, 5], [1, 2, 1, 4], [11, 11, 12, 9], [0, 12, 0, 3], [10, 6, 5, 4], [4, 5, 6, 8], [10, 9, 7, 3], [12, 6, 1, 3], [0, 4, 10, 8], [2, 0, 1, 12], [3, 9, 2, 6], [2, 7, 8, 10]]
[[4, 1, 5, 7], [7, 12, 6, 2], [0, 11, 10, 5], [10, 0, 0, 6], [10, 1, 6, 8], [12, 7, 2, 5], [3, 3, 8, 12], [3, 6, 9, 1], [10, 9, 8, 4], [3, 9, 2, 4], [11, 1, 4, 7], [11, 5, 2, 12], [0, 8, 11, 9]]
[[3, 11, 0, 1], [6, 1, 7, 12], [9, 8, 0, 2], [9, 6, 11, 8], [10, 5, 2, 5], [12, 10, 9, 5], [4, 9, 3, 6], [7, 2, 10, 7], [12, 6, 2, 8], [10, 8, 4, 7], [11, 3, 4, 5], [12, 11, 1, 0], [1, 3, 0, 4]]

ES6, 57 byte

a=>(g=n=>a.map((x,i)=>i&&x[3]==n&&++c&&g(i)),g(c=0),c>11)

Điều này hoạt động vì chỉ có các thẻ ở dưới cùng của cọc 1-12 là có liên quan và chúng cần tạo thành một đồ thị có hướng trở lại cọc 0. Vì vậy, tôi đếm số lượng cọc có thẻ dưới là 0, sau đó là số cọc có thẻ dưới cùng là một trong những cọc tôi đã đếm trước đó, v.v ... Nếu tôi đạt được 12 cọc thì cấu hình là một chiến thắng.

Bằng chứng phác thảo:

Trò chơi luôn kết thúc khi bạn chuyển qua 0 cuối cùng, vì đống đó thực sự có ít thẻ hơn các thẻ khác.

Nếu các thẻ dưới cùng trên các cọc 1-12 tạo thành một biểu đồ có hướng đến cọc 0, thì để xóa cọc 0, chúng ta phải xóa tất cả các cọc có mục nhập cuối cùng là 0, và cứ thế đệ quy cho tất cả các cọc mà chúng ta phải xóa để chúng ta có thể xóa các cọc có mục nhập cuối cùng là 0, v.v. Do đó, cấu hình là một chiến thắng.

Nếu các thẻ ở dưới cùng của cọc 1-12 không tạo thành đồ thị có hướng đến cọc 0, thì phải tồn tại ít nhất một chu kỳ. Không có cọc nào trong chu trình này có thể bị xóa, vì nó phụ thuộc vào cọc trước trong chu kỳ. (Trong trường hợp chu kỳ dài 2, đây là tình huống gà và trứng.) Cấu hình do đó bị mất.

CJam, 23 21 byte

q~({(\a@+1$ff-m<(}h*!

Chạy tất cả các trường hợp thử nghiệm.

Nếu việc gán sự thật và giả là ngược lại tôi có thể lưu 3 byte:

q~{((\a@+1$ff-m<}h

Giải trình

Đặt các thẻ úp lên dưới một đống khác là cá trích đỏ. Chúng tôi cũng có thể loại bỏ chúng khỏi trò chơi và tiếp tục chơi cho đến khi đống hiện tại trống rỗng. Vì vậy, đó là những gì tôi đang làm: mã chỉ đơn giản là chơi trò chơi cho đến khi đống hiện tại trống và sau đó kiểm tra xem có thẻ nào còn lại không.

q~    e# Read and evaluate input.
(     e# Pull off the first (current) pile.
{     e# While the current pile is non-empty...
  (\  e#   Pull off the top card and swap with the remaining pile.
  a   e#   Wrap the pile in an array.
  @+  e#   Prepend it to the list of piles
  1$  e#   Copy the drawn card.
  ff- e#   Subtract it from all all remaining cards.
  m<  e#   Rotate the stack to the left by the drawn card
  (   e#   Pull off the top pile as the new current pile.
}h
*     e# The top pile is empty. Joining the other piles with it, flattens them.
!     e# Logical not, turns an empty array into 1 and a non-empty array into 0.

Haskell, 85 byte

(a:b)?n|n<1=tail a:b|1>0=a:b?(n-1)
l%i|null(l!!i)=all null l|1>0=l?i%(l!!i!!0)
f=(%0)

Bình thường, 13 byte

!su@LGGXeMQZZ

Dựa vào bằng chứng của @ Neil. !su&VG@LGGeMQcũng hoạt động.

                 implicit: Q=input
! s u            Sum of (apply lambda G,H on ... until fixed point) equals 0
      @L         Index G into itself.
         G       
         G       
                  Apply that to:
      X                                            set to
        eM Q      Last elts of input, with the 
        Z                                      0th
        Z                                                 0

Hãy thử nó ở đây .

Python, 55 byte

x=lambda l,i=0:x(l,l[i].pop(0))if l[i]else[]==sum(l,[])

Nếu danh sách phụ không trống, tiếp tục bật các mục. Khi nó trống, Trả lại tất cả các danh sách trống (bằng cách nhóm chúng vào một danh sách lớn) hoặc không.

Thạch, 11 byte

‘ịa
Ṫ€ÇL¡S¬

Hãy thử nó ở đây .