# Clock (card game)

Clock is an interesting card game, as it requires no skill. It is a single player game, and the same card configuration always leads to a win or a loss. In this challenge, you need to figure out whether a given card configuration wins or loses. You can play the game here.

The game is played as follows:

1. Thirteen piles of cards are dealt face down. Each pile is numbered from 0 to 12.
2. We set the 0th pile to be the current pile
3. We flip the top card of the current pile face up.
4. We move the face up card at the bottom of its respective pile (A 4 card goes under the 4th pile). The card remains face up. This pile becomes the current pile.
5. If the current pile is completely face up, then the game is over. Otherwise, go back to step 3.

Tip: The game will always end on the 0th pile

The game is won if all cards end up face up, and is lost if there are remaining face down cards.

# Input/Output

A 2D array containing each of the piles. Cards are represented with numbers from 0 to 12 (suit is irrelevant, and not given). The top card of each pile is the first element of each array.

You can assume that the input will be well formed: it will contain 52 cards from 0 to 12 (inclusive), and contain each number exactly 4 times.

You must return a truthy value if the game can be won, and falsy if it cannot.

# Test cases

Truthy:

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

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


This works because only the cards on the bottom of piles 1-12 are relevant, and they need to form a directed graph back to pile 0. So, I count the number of piles whose bottom card is 0, then the number of piles whose bottom card was one of the piles I counted earlier, etc. If I reach 12 piles then the configuration is a winning one.

Outline proof:

The game always ends when you turn over the last 0, since that pile effectively has one fewer card than the others.

If the bottom cards on piles 1-12 form a directed graph to pile 0, then in order to clear pile 0, we have to clear all the piles whose last entry is 0, and so on recursively to all the piles we have to clear so that we can clear the piles whose last entry is 0, and so forth. The configuration is therefore a winning one.

If the cards on the bottom of piles 1-12 do not form a directed graph to pile 0, there must exist at least one cycle. No pile in this cycle can be cleared, since it depends on the previous pile in the cycle. (In the case of a cycle of length 2, this is a chicken-and-egg situation.) The configuration is therefore a losing one.

## CJam, 23 21 bytes

q~({(\a@+1$ff-m<(}h*!  Run all test cases. If the assignment of truthy and falsy was the opposite I could save 3 bytes: q~{((\a@+1$ff-m<}h


### Explanation

Putting the cards face up under another pile is a red herring. We might as well remove them from the game and keep playing until the current pile is empty. So that's what I'm doing: the code simply plays the game until the current pile is empty and then checks if any cards are left.

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.


(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


Relies on @Neil's proof. !su&VG@LGGeMQ also works.

                 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


Try it here.

• Request Line is too large (7173 > 4094) Jan 26, 2016 at 9:56
• Fixed the link. Jan 26, 2016 at 18:31

Python, 55 bytes

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


If the sublist is not empty, continue poping items. When it's empty, Return either all the lists are empty (by grouping them into one big list) or not.

• I get False for the first true test case using Python 3.4.2. Jan 30, 2016 at 5:04
• I'm taking the last item of each list, so you need to flip the lists: l = [i[::-1] for i in l] Jan 30, 2016 at 5:12
• The question explicitly says the first item of every list is the top. You'll need to include the code to flip in your byte count. Jan 30, 2016 at 5:34
• Fixed. Now it's poping the first item. Jan 30, 2016 at 12:36

## Jelly, 11 bytes

‘ịa
Ṫ€ÇL¡S¬


Try it here.