Clock ist ein interessantes Kartenspiel, da es keine Geschicklichkeit erfordert. Es ist ein Einzelspielerspiel und dieselbe Kartenkonfiguration führt immer zu einem Gewinn oder einer Niederlage. Bei dieser Herausforderung müssen Sie herausfinden, ob eine bestimmte Kartenkonfiguration gewinnt oder verliert . Sie können das Spiel hier spielen .

Das Spiel wird wie folgt gespielt:

1. Dreizehn Kartenstapel werden verdeckt ausgeteilt. Jeder Stapel ist von 0 bis 12 nummeriert.
2. Wir setzen den 0. Stapel auf den aktuellen Stapel
3. Wir drehen die oberste Karte des aktuellen Stapels auf.
4. Wir legen die aufgedeckte Karte unten auf den jeweiligen Stapel (A 4 Karte geht unter den 4. Stapel) . Die Karte bleibt offen. Dieser Stapel wird zum aktuellen Stapel.
5. Wenn der aktuelle Stapel vollständig aufgedeckt ist, ist das Spiel beendet. Fahren Sie andernfalls mit Schritt 3 fort.

Tipp: Das Spiel endet immer auf dem 0. Stapel

Das Spiel ist gewonnen, wenn alle Karten offen liegen, und verloren, wenn noch verdeckte Karten übrig sind.

Input-Output

Ein 2D-Array, das die einzelnen Stapel enthält. Karten werden mit Zahlen von 0 bis 12 dargestellt (Farbe ist irrelevant und nicht angegeben). Die oberste Karte jedes Stapels ist das erste Element jedes Arrays.

Sie können davon ausgehen, dass die Eingabe gut strukturiert ist: Sie enthält 52 Karten von 0 bis 12 (einschließlich) und enthält jede Zahl genau viermal.

Sie müssen einen wahrheitsgemäßen Wert zurückgeben, wenn das Spiel gewonnen werden kann, und einen falschen Wert, wenn dies nicht möglich ist.

Testfälle

Wahrheit:

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

Falsch:

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

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

Dies funktioniert, weil nur die Karten auf der Unterseite der Stapel 1 bis 12 relevant sind und sie einen gerichteten Graphen bilden müssen, um zu Stapel 0 zurückzukehren. Also zähle ich die Anzahl der Stapel, deren unterste Karte 0 ist, und dann die Anzahl der Stapel, deren Die unterste Karte war einer der Stapel, die ich zuvor gezählt habe usw. Wenn ich 12 Stapel erreicht habe, ist die Konfiguration eine gewinnende.

Umrissbeweis:

Das Spiel endet immer, wenn Sie die letzte 0 aufdecken, da dieser Stapel effektiv eine Karte weniger hat als die anderen.

Wenn die untersten Karten auf den Stapeln 1-12 einen gerichteten Graphen für Stapel 0 bilden, müssen zum Löschen von Stapel 0 alle Stapel gelöscht werden, deren letzter Eintrag 0 ist, und so weiter rekursiv für alle Stapel, die gelöscht werden müssen damit wir die Stapel löschen können, deren letzter Eintrag 0 ist, und so weiter. Die Konfiguration ist daher ein Gewinn.

Wenn die Karten auf der Unterseite der Stapel 1-12 keine gerichtete Grafik für Stapel 0 bilden, muss mindestens ein Zyklus vorhanden sein. In diesem Zyklus kann kein Stapel gelöscht werden, da dies vom vorherigen Stapel im Zyklus abhängt. (Bei einem Zyklus der Länge 2 handelt es sich um eine Henne-Ei-Situation.) Die Konfiguration ist daher eine verlierende.

CJam, 23 21 Bytes

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

Führen Sie alle Testfälle aus.

Wenn die Zuordnung von Wahr und Falsch das Gegenteil wäre, könnte ich 3 Bytes sparen:

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

Erläuterung

Ein roter Hering legt die Karten offen unter einen anderen Stapel. Wir können sie genauso gut aus dem Spiel entfernen und weiterspielen, bis der aktuelle Stapel leer ist. Also mache ich das so: Der Code spielt einfach das Spiel, bis der aktuelle Stapel leer ist, und prüft dann, ob noch Karten übrig sind.

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 Bytes

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

!su@LGGXeMQZZ

Verlässt sich auf @ Neils Beweis. !su&VG@LGGeMQfunktioniert auch.

                 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

Probieren Sie es hier aus .

Python, 55 Bytes

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

Wenn die Unterliste nicht leer ist, fahren Sie mit dem Einblenden von Elementen fort. Wenn es leer ist, geben Sie entweder alle leeren Listen zurück (indem Sie sie zu einer großen Liste zusammenfassen) oder nicht.

Jelly, 11 Bytes

‘ịa
Ṫ€ÇL¡S¬

Probieren Sie es hier aus .