Jam adalah permainan kartu yang menarik, karena tidak memerlukan keahlian. Ini adalah permainan pemain tunggal, dan konfigurasi kartu yang sama selalu mengarah pada kemenangan atau kekalahan. Dalam tantangan ini, Anda perlu mencari tahu apakah konfigurasi kartu yang diberikan menang atau kalah . Anda dapat memainkan game di sini .

Permainan ini dimainkan sebagai berikut:

1. Tiga belas tumpukan kartu dibagikan tertutup. Setiap tumpukan diberi nomor dari 0 hingga 12.
2. Kami menetapkan tumpukan ke-0 menjadi tumpukan saat ini
3. Kami membalik kartu teratas dari tumpukan saat ini menghadap ke atas.
4. Kami memindahkan kartu menghadap ke atas di bagian bawah tumpukan masing-masing (kartu A 4 berada di bawah tumpukan ke-4) . Kartu tetap menghadap ke atas. Tumpukan ini menjadi tumpukan saat ini.
5. Jika tumpukan saat ini benar-benar menghadap ke atas, maka permainan sudah berakhir. Jika tidak, kembali ke langkah 3.

Kiat: Permainan akan selalu berakhir di tumpukan ke-0

Permainan dimenangkan jika semua kartu berakhir menghadap ke atas, dan hilang jika ada sisa kartu yang tersisa.

Input output

Array 2D berisi masing-masing tumpukan. Kartu diwakili dengan angka dari 0 hingga 12 (setelan tidak relevan, dan tidak diberikan). Kartu teratas dari setiap tumpukan adalah elemen pertama dari setiap susunan.

Anda dapat mengasumsikan bahwa input akan terbentuk dengan baik: itu akan berisi 52 kartu dari 0 hingga 12 (inklusif), dan berisi setiap angka tepat 4 kali.

Anda harus mengembalikan nilai kebenaran jika permainan bisa dimenangkan, dan palsu jika tidak bisa.

Uji kasus

Benar:

[[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]]

Falsy:

[[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)

Ini berfungsi karena hanya kartu di dasar tumpukan 1-12 yang relevan, dan mereka perlu membentuk grafik yang diarahkan kembali ke tumpukan 0. Jadi, saya menghitung jumlah tumpukan yang kartu bawahnya adalah 0, kemudian jumlah tumpukan yang kartu terbawah adalah salah satu tumpukan yang saya hitung sebelumnya, dll. Jika saya mencapai 12 tumpukan maka konfigurasi adalah yang menang.

Bukti garis besar:

Permainan selalu berakhir ketika Anda membalik 0 terakhir, karena tumpukan itu secara efektif memiliki satu kartu lebih sedikit daripada yang lain.

Jika kartu terbawah pada tumpukan 1-12 membentuk grafik berarah ke tumpukan 0, maka untuk menghapus tumpukan 0, kita harus menghapus semua tumpukan yang entri terakhirnya adalah 0, dan seterusnya secara rekursif ke semua tumpukan kita harus menghapus sehingga kita bisa menghapus tumpukan yang entri terakhirnya 0, dan sebagainya. Oleh karena itu konfigurasi adalah yang menang.

Jika kartu di bagian bawah tumpukan 1-12 tidak membentuk grafik berarah ke tumpukan 0, harus ada setidaknya satu siklus. Tidak ada tumpukan dalam siklus ini dapat dihapus, karena itu tergantung pada tumpukan sebelumnya dalam siklus. (Dalam kasus siklus 2 panjang, ini adalah situasi ayam-dan-telur.) Karena itu konfigurasi yang hilang.

CJam, 23 21 byte

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

Jalankan semua test case.

Jika penugasan truey dan falsy adalah kebalikannya, saya bisa menghemat 3 byte:

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

Penjelasan

Menempatkan kartu menghadap ke bawah di bawah tumpukan lain adalah herring merah. Kami mungkin juga menghapusnya dari permainan dan terus bermain sampai tumpukan saat ini kosong. Jadi itulah yang saya lakukan: kode hanya memainkan permainan sampai tumpukan saat ini kosong dan kemudian memeriksa apakah ada kartu yang tersisa.

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)

Pyth, 13 byte

!su@LGGXeMQZZ

Bergantung pada bukti @ Neil. !su&VG@LGGeMQjuga berfungsi.

                 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

Coba di sini .

Python, 55 byte

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

Jika sublist tidak kosong, lanjutkan sembulan item. Ketika kosong, Kembalikan semua daftar kosong (dengan mengelompokkannya ke dalam satu daftar besar) atau tidak.

Jelly, 11 byte

‘ịa
Ṫ€ÇL¡S¬

Coba di sini .