Tichu es un juego de cartas en el que los jugadores se turnan para jugar juegos de cartas de un mazo que consiste en un mazo estándar de 52 cartas, más 4 cartas adicionales:

• el dragón , que tiene un valor mayor que cualquier otra carta
• el fénix , que puede actuar como comodín
• el perro , que le pasa el turno a tu pareja
• el Mah Jong , que tiene un valor de 1 (y la persona que lo sostiene juega primero)

El primer jugador (de quien se dice que tiene "ventaja") puede elegir jugar uno de los siguientes tipos de combinaciones de cartas:

• una sola (por ejemplo 6)
• un par ( JJ)
• un triple ( 555)
• una casa completa ( QQQ33) - un triple y un par
• una escalera ( 56789) - 5 o más cartas consecutivas
• un tractor ( 223344) - cualquier secuencia consecutiva de pares

Los jugadores posteriores solo pueden jugar un juego de cartas del mismo tipo, pero estrictamente superior. Por ejemplo, QQse puede jugar encima JJ, pero QQKKno se puede (es un tractor, no un par). Las casas completas se ordenan por triple (por ejemplo, 77722> 44499), y las rectas y los tractores deben tener la misma longitud ( 456789no se pueden jugar encima 23456). Los ases son altos.

Hay una excepción: cualquier 4 de la misma carta es una bomba , y se puede jugar encima de cualquier cosa, excepto una bomba más alta. ¹

El dragón se puede jugar solo sobre cualquier sencillo o con plomo (pero en ningún otro lugar). El fénix, además de ser un comodín, también se puede jugar encima de cualquier sencillo, excepto el dragón. ² El perro solo se puede jugar solo con plomo e inmediatamente termina el turno. ³

Su desafío es determinar si una determinada jugada Tichu es válida, dada la jugada anterior.

Puede aceptar ambas jugadas en cualquier orden como listas de enteros o cadenas; en cualquier caso, puede elegir cualquier asignación de cartas a enteros / caracteres. Si hubo una jugada anterior, siempre será válida, y si no (es decir, el jugador tiene plomo), la primera entrada será la matriz / cadena vacía (que coincida con el tipo de la otra entrada). No se garantiza que las tarjetas se entreguen en ningún orden en particular.

Su salida debe seleccionarse de un conjunto de exactamente dos valores distintos, uno de los cuales indica que la jugada es legal y otra que no lo es.

No hay necesidad de comprobar si el conjunto de cartas realmente existe en el mazo (por ejemplo, es imposible 77766seguirlo 88877porque solo hay cuatro 7), tales casos nunca se darán.

En los siguientes casos de prueba, 234567890JQKArepresente de 2 a as y RPD1represente al dragón, el fénix, el perro y Mah Jong, respectivamente. La cadena vacía se muestra aquí como -. Estas jugadas son legales:

6 J
JJ QQ
555 KKK
44499 77722
23456 56789
223344 QQKKAA
49494 72727
A R
A P
P R
66 7P
P6 77
58304967 6P0594J7
5P304967 680594J7
57446765 788657P5
- D
- 1
- 12345
3344556677889900 JJJJ
5555 7777

Y estos no son:

9 3
66 55
888 444
44 888
77722 44499
44499 777
44499 777JJJ
45678 34567
34567 456789
556677 334455
5566 778899
72727 49494
A A
R A
R P
77 RP
77 6P
P7 66
680594J7 5P304967
6P0594J7 58304967
57446765 3645P536
1 D
2 D
2 1
- 1234
7777 5555
- 223355

^{1: en realidad, una escalera de color también es una bomba, pero dado que este es el único lugar en el juego que importa el palo de las cartas, he optado por dejarlo fuera por simplicidad}

^{2: el valor del fénix jugado en la parte superior de una carta con valor n es en realidad n + 0.5 (un fénix en un 9 es un 9 y medio); dado que esto requiere conocimiento de un historial adicional para juzgar, ningún caso de prueba involucra un solo juego encima de un solo fénix}

^{3: entonces la primera entrada nunca será perro}

JavaScript (ES6),  274  273 bytes

(a)(b)$a$$b$

• $1$
• $3$
• $4..16$
• $18$
• $19$

Devuelve falso para válido o verdadero para inválido.

a=>b=>!(L='length',[A,B]=(g=a=>(h=n=>--n?[i=1,2,3,'(20*)3|30*2','1{5,}','22+',4].some(p=>m=o.join``.match(`9(0*)(${p})0*$`,i++),a.map(x=>o[x-19?x:x=n]=-~o[x],o=[...9e16+'']))?[i,m[1][L]+(m[3]||[])[L]]:h(n):[])(18))(a),[C,D]=g(b),a+a?A-C?C>7|+b>a:a[L]==b[L]&D>B|A<3&b==18:C)

Pruébalo en línea!

¿Cómo?

o[]$9$

//       D  -  1  2  3  4  5  6  7  8  9  T  J  Q  K  A
o = [ 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];

Para cada rango de carta en la mano, la ranura correspondiente o[]se incrementa. Una vez unidos de nuevo a una cadena, podemos aplicar las siguientes expresiones regulares para detectar cada tipo de mano:

 hand        | pattern     | full regex              | example
-------------+-------------+-------------------------+-------------------
 single      | 1           | /9(0*)(1)0*$/           | 90000100000000000
 pair        | 2           | /9(0*)(2)0*$/           | 90000002000000000
 3-of-a-kind | 3           | /9(0*)(3)0*$/           | 90003000000000000
 full house  | (20*)3|30*2 | /9(0*)((20*)3|30*2)0*$/ | 90020000030000000
 straight 5+ | 1{5,}       | /9(0*)(1{5,})0*$/       | 90000111110000000
 tractor     | 22+         | /9(0*)(22+)0*$/         | 90000000000022200
 bomb        | 4           | /9(0*)(4)0*$/           | 90000000000000004

Si la mano no activa ninguna de estas expresiones regulares, no es válida.

$9$(20*)

El fénix (es decir, el comodín) simplemente se reemplaza con cada rango de carta posible, comenzando por el más alto, hasta que se detecta una coincidencia.

Python 3 , 466 455 403 401 399 bytes

R=lambda H,n=3:n==len(H)*(len({*H})<2)and[15]!=H[1:]
s=lambda H:[H[2:],H[:1]][R(H[:3])]
def n(J,K):j,k=[[16in H,R(H,4),len(H)>4and all(15!=t>T-2for t,T in zip(H,H[1:])),[R(H[2:])*R(H[:2],2),R(H[3:],2)][R(H[:3])],R(H),R(H,2),R(H,1),1].index(1)for H in[J,K]];return k!=7and[17]==J or[j==k*[J<K,s(J)<s(K)][2<j<5],J<K][k==1]
f=lambda P:any(n(*[sorted([L,i][i>0]for i in H)for H in P])for L in range(16))

Pruébalo en línea! La entrada es una lista de manos donde hand es una lista de enteros ¹ con el siguiente mapeo de valores:

• 0: Phoenix
• 1: Mah Jong
• 2-13: 2 a Ace
• 14: dragón
• 15: perro
• 16: cadena vacía

^{1: Aunque en las pruebas de TIO vinculadas se expresan con una lista de cadenas debido a la conveniencia que se traducen de acuerdo con la asignación de valores antes de llamar f}