Clock , beceri gerektirmediği için ilginç bir kart oyunudur. Tek oyunculu bir oyundur ve aynı kart konfigürasyonu her zaman bir kazanma veya kaybetmeye yol açar. Bu meydan okumada, belirli bir kart yapılandırmasının kazanıp kazanmayacağını veya kaybetip kaybetmeyeceğini bulmanız gerekir . Sen edebilirsiniz burada oyun oynamak .

Oyun şu şekilde oynanır:

1. On üç kart yığını kapalı olarak dağıtılır. Her yığın 0 ila 12 arasında numaralandırılmıştır.
2. 0. yığını mevcut yığın olarak ayarladık
3. Mevcut yığının üst kartını yüzü yukarı gelecek şekilde çeviriyoruz.
4. Yüzü yukarı kartını ilgili yığının altına doğru hareket ettiriyoruz (4 kart 4. yığının altına gidiyor) . Kart kapalı olarak kalır. Bu yığın mevcut yığın olur.
5. Mevcut yığın tamamen yukarı dönükse, oyun biter. Aksi takdirde, 3. adıma geri dönün.

İpucu: Oyun her zaman 0. yığınla sona erecek

Tüm kartlar açık olarak bitirilirse oyun kazanılır ve açık kapalı kartlar varsa kaybedilir.

Giriş çıkış

Kazıkların her birini içeren bir 2B dizi. Kartlar 0 ila 12 arasında sayılarla temsil edilir (takım elbise ilgisizdir ve verilmez). Her yığının üst kartı, her dizinin ilk öğesidir.

Girişin iyi oluşturulacağını varsayabilirsiniz: 0 ila 12 (dahil) arasında 52 kart içerecek ve her bir sayıyı tam olarak 4 kez içerecektir.

Eğer oyun kazanılabiliyorsa gerçek bir değer ve yapamıyorsanız yanlıştır.

Test senaryoları

Doğru:

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

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

Bu, yalnızca 1-12 yığınlarının altındaki kartların alakalı olması ve yığın 0'a geri yönlendirilmiş bir grafik oluşturmaları gerektiği için çalışır. Bu nedenle, alt kartı 0 olan yığınların sayısını, daha sonra yığınların sayısını alt kart, daha önce saydığım yığınlardan biriydi. 12 kazığa ulaşırsam, yapılandırma kazanan bir karttır.

Anahat kanıtı:

Oyun her zaman son 0'ı çevirdiğinizde sona erer, çünkü bu destenin diğerlerinden daha az bir kartı vardır.

Yığın 1-12'deki alt kartlar yığın 0'a yönlendirilmiş bir grafik oluşturuyorsa, yığın 0'ı temizlemek için son girişi 0 olan tüm yığınları temizlemeliyiz ve böylece tüm yığınlara özyinelemeli olarak temizlemeliyiz böylece son girişi 0 olan yığınları temizleyebiliriz. Yapılandırma bu nedenle kazanan bir yapılandırmadır.

Yığın 1-12'nin altındaki kartlar 0 yığına yönlendirilmiş bir grafik oluşturmazsa, en az bir döngü olmalıdır. Bu döngüdeki hiçbir yığın, döngüdeki bir önceki kazığa bağlı olduğundan temizlenemez. (Uzunluk 2 döngüsü söz konusu olduğunda, bu bir tavuk ve yumurta durumudur.) Bu nedenle yapılandırma kaybedilen bir durumdur.

CJam, 23 21 bayt

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

Tüm test senaryolarını çalıştırın.

Doğruluk ve falsy ataması tam tersiyse, 3 bayt kurtarabilirdim:

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

açıklama

Kartları başka bir destenin altına yüzü yukarı gelecek şekilde koymak kırmızı bir ringa balığıdır. Onları oyundan çıkarabilir ve mevcut yığın boşalana kadar oynamaya devam edebiliriz. Ben de bunu yapıyorum: kod sadece mevcut yığın boşalana kadar oyunu oynar ve daha sonra herhangi bir kartın bırakılıp bırakılmadığını kontrol eder.

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 bayt

(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 bayt

!su@LGGXeMQZZ

@ Neil'in kanıtına güveniyor. !su&VG@LGGeMQayrıca çalışır.

                 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

Burada deneyin .

Python, 55 bayt

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

Alt liste boş değilse, öğeleri açmaya devam edin. Boş olduğunda, Tüm listeler boştur (tek bir büyük grupta gruplayarak) ya da değil.

Jöle, 11 bayt

‘ịa
Ṫ€ÇL¡S¬

Burada deneyin .