Reloj (juego de cartas)

14

Clock es un juego de cartas interesante, ya que no requiere habilidad. Es un juego para un solo jugador, y la misma configuración de cartas siempre conduce a una victoria o una pérdida. En este desafío, debe averiguar si una configuración de tarjeta determinada gana o pierde . Puedes jugar el juego aquí .

El juego se juega de la siguiente manera:

  1. Trece montones de cartas se reparten boca abajo. Cada pila está numerada del 0 al 12.
  2. Configuramos la pila 0 para que sea la pila actual
  3. Volteamos la carta superior de la pila actual boca arriba.
  4. Movimos la carta boca arriba en la parte inferior de su pila respectiva (una carta 4 va debajo de la cuarta pila) . La tarjeta permanece boca arriba. Esta pila se convierte en la pila actual.
  5. Si la pila actual está completamente boca arriba, entonces el juego ha terminado. De lo contrario, regrese al paso 3.

Consejo: el juego siempre terminará en la pila 0

El juego se gana si todas las cartas terminan boca arriba, y se pierde si quedan cartas boca abajo.

De entrada y salida

Una matriz 2D que contiene cada una de las pilas. Las tarjetas se representan con números del 0 al 12 (el palo es irrelevante y no se da). La primera carta de cada pila es el primer elemento de cada matriz.

Puede suponer que la entrada estará bien formada: contendrá 52 tarjetas del 0 al 12 (inclusive) y contendrá cada número exactamente 4 veces.

Debe devolver un valor verdadero si el juego se puede ganar, y falso si no se puede ganar.

Casos de prueba

Verdad:

[[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]]
Nathan Merrill
fuente

Respuestas:

9

ES6, 57 bytes

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

Esto funciona porque solo las cartas en la parte inferior de las pilas 1-12 son relevantes, y necesitan formar un gráfico dirigido de vuelta a la pila 0. Entonces, cuento la cantidad de pilas cuya carta inferior es 0, luego la cantidad de pilas cuya la carta inferior era una de las pilas que conté anteriormente, etc. Si llego a 12 pilas, la configuración es ganadora.

Prueba de esquema:

El juego siempre termina cuando le das la vuelta al último 0, ya que esa pila efectivamente tiene una carta menos que las otras.

Si las cartas inferiores en las pilas 1-12 forman un gráfico dirigido para la pila 0, entonces para borrar la pila 0, tenemos que borrar todas las pilas cuya última entrada es 0, y así sucesivamente a todas las pilas que tenemos que borrar. para que podamos borrar las pilas cuya última entrada es 0, y así sucesivamente. La configuración es, por lo tanto, ganadora.

Si las cartas en la parte inferior de las pilas 1-12 no forman una gráfica dirigida a la pila 0, debe existir al menos un ciclo. No se puede borrar ninguna pila en este ciclo, ya que depende de la pila anterior en el ciclo. (En el caso de un ciclo de longitud 2, esta es una situación de huevo y gallina). Por lo tanto, la configuración es perdedora.

Neil
fuente
7

CJam, 23 21 bytes

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

Ejecute todos los casos de prueba.

Si la asignación de verdad y falsedad fuera lo contrario, podría guardar 3 bytes:

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

Explicación

Poner las cartas boca arriba debajo de otro montón es un arenque rojo. También podríamos eliminarlos del juego y seguir jugando hasta que la pila actual esté vacía. Entonces eso es lo que estoy haciendo: el código simplemente juega el juego hasta que la pila actual esté vacía y luego verifica si quedan cartas.

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.
Martin Ender
fuente
4

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)
Damien
fuente
4

Pyth, 13 bytes

!su@LGGXeMQZZ

Se basa en la prueba de @ Neil. !su&VG@LGGeMQTambién 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

Pruébalo aquí .

lirtosiast
fuente
La línea de solicitud es demasiado grande (7173> 4094)
Loco
Corregido el enlace.
lirtosiast
1

Python, 55 bytes

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

Si la sublista no está vacía, continúe mostrando elementos. Cuando está vacío, Devuelve o todas las listas están vacías (agrupándolas en una lista grande) o no.

Dantal
fuente
Obtengo False para el primer caso de prueba verdadero usando Python 3.4.2.
lirtosiast
Estoy tomando el último elemento de cada lista, por lo que debe voltear las listas: l = [i [:: - 1] para i en l]
Dantal
1
La pregunta dice explícitamente que el primer elemento de cada lista es el primero. Deberá incluir el código para voltear en su conteo de bytes.
lirtosiast
Fijo. Ahora está apareciendo el primer elemento.
Dantal
0

Jalea, 11 bytes

‘ịa
Ṫ€ÇL¡S¬

Pruébalo aquí .

lirtosiast
fuente