O relógio é um jogo de cartas interessante, pois não requer habilidade. É um jogo para um jogador e a mesma configuração de cartão sempre leva a uma vitória ou uma perda. Neste desafio, você precisa descobrir se uma determinada configuração de cartão vence ou perde . Você pode jogar o jogo aqui .

O jogo é jogado da seguinte forma:

1. Treze pilhas de cartas são distribuídas com a face para baixo. Cada pilha é numerada de 0 a 12.
2. Definimos a pilha 0 como a pilha atual
3. Viramos a carta do topo da pilha atual com a face para cima.
4. Movemos a carta virada para cima na parte inferior da respectiva pilha (uma carta 4 passa por baixo da 4ª pilha) . O cartão permanece voltado para cima. Essa pilha se torna a pilha atual.
5. Se a pilha atual estiver completamente virada para cima, o jogo terminará. Caso contrário, volte para a etapa 3.

Dica: O jogo sempre termina na 0ª pilha

O jogo é ganho se todas as cartas terminarem viradas para cima e se perderá se houver cartas viradas para baixo restantes.

Entrada / Saída

Uma matriz 2D contendo cada uma das pilhas. Os cartões são representados com números de 0 a 12 (o naipe é irrelevante e não é dado). A carta superior de cada pilha é o primeiro elemento de cada matriz.

Você pode supor que a entrada será bem formada: ela conterá 52 cartões de 0 a 12 (inclusive) e conterá cada número exatamente 4 vezes.

Você deve retornar um valor verdadeiro, se o jogo puder ser ganho, e falso, se não puder.

Casos de teste

Verdade:

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

Isso funciona porque apenas as cartas na parte inferior das pilhas de 1 a 12 são relevantes e precisam formar um gráfico direcionado de volta à pilha 0. Portanto, conto o número de pilhas cuja placa inferior é 0, depois o número de pilhas cujas o cartão inferior foi uma das pilhas que contei anteriormente, etc. Se eu atingir 12 pilhas, a configuração será vencedora.

Prova de estrutura de tópicos:

O jogo sempre termina quando você vira o último 0, pois essa pilha tem efetivamente menos uma carta do que as outras.

Se as cartas de baixo das pilhas 1-12 formam um gráfico direcionado para a pilha 0, então, para limpar a pilha 0, temos que limpar todas as pilhas cuja última entrada é 0, e assim sucessivamente para todas as pilhas que temos que limpar para que possamos limpar as pilhas cuja última entrada é 0 e assim por diante. A configuração é, portanto, vencedora.

Se as cartas na parte inferior das pilhas 1-12 não formarem um gráfico direcionado para a pilha 0, deve existir pelo menos um ciclo. Nenhuma pilha neste ciclo pode ser removida, pois depende da pilha anterior no ciclo. (No caso de um ciclo de comprimento 2, esta é uma situação de galinha e ovo.) A configuração é, portanto, uma perda.

CJam, 23 21 bytes

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

Execute todos os casos de teste.

Se a atribuição de verdade e falsidade fosse o oposto, eu poderia salvar 3 bytes:

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

Explicação

Colocar as cartas viradas para cima sob outra pilha é um arenque vermelho. É melhor removê-los do jogo e continuar jogando até que a pilha atual esteja vazia. Então é isso que estou fazendo: o código simplesmente joga o jogo até que a pilha atual esteja vazia e depois verifica se resta alguma carta.

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)

Pitão, 13 bytes

!su@LGGXeMQZZ

Confia na prova de @ Neil. !su&VG@LGGeMQtambém funciona.

                 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

Experimente aqui .

Python, 55 bytes

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

Se a sublist não estiver vazia, continue exibindo itens. Quando estiver vazio, retorne todas as listas estão vazias (agrupando-as em uma grande lista) ou não.

Gelatina, 11 bytes

‘ịa
Ṫ€ÇL¡S¬

Experimente aqui .