Tichu est un jeu de cartes dans lequel les joueurs jouent à tour de rôle des jeux de cartes à partir d'un jeu de cartes composé d'un jeu de 52 cartes standard, plus 4 cartes supplémentaires:

• le dragon , qui a une valeur supérieure à toute autre carte
• le phénix , qui peut servir de joker
• le chien , qui passe le tour à votre partenaire
• le Mah Jong , qui a la valeur 1 (et la personne qui le tient joue en premier)

Le premier joueur (qui est censé avoir une «avance») peut choisir de jouer l'un des types de combinaisons de cartes suivants:

• un seul (par exemple 6)
• une paire ( JJ)
• un triple ( 555)
• une maison pleine ( QQQ33) - un triple et une paire
• une ligne droite ( 56789) - 5 cartes consécutives ou plus
• un tracteur ( 223344) - toute séquence consécutive de paires

Les joueurs suivants ne sont alors autorisés qu'à jouer un jeu de cartes du même type, mais strictement supérieur. Par exemple, QQpeut être joué par dessus JJ, mais QQKKne peut pas (c'est un tracteur, pas une paire). Les maisons pleines sont ordonnées par le triple (par exemple 77722> 44499), et les lignes droites et les tracteurs doivent être de la même longueur ( 456789ne peuvent pas être joués dessus 23456). Les as sont élevés.

Il y a une exception: les 4 cartes de la même carte sont des bombes et peuvent être jouées sur n'importe quoi sauf une bombe plus haute. ¹

Le dragon peut être joué seul sur n'importe quel single ou avec du plomb (mais nulle part ailleurs). Le phénix, en plus d'être un joker, peut également être joué au-dessus de n'importe quel single sauf le dragon. ² Le chien ne peut être joué seul qu'avec la laisse et termine immédiatement le tour. ³

Votre défi consiste à déterminer si un jeu Tichu donné est valide, compte tenu du jeu précédent.

Vous pouvez accepter les deux jeux dans n'importe quel ordre en tant que listes d'entiers ou de chaînes - dans les deux cas, vous pouvez choisir n'importe quel mappage de cartes en entiers / caractères. S'il y a eu un jeu précédent, il sera toujours valide et sinon (c'est-à-dire que le joueur a le plomb), la première entrée sera le tableau / la chaîne vide (correspondant au type de l'autre entrée). Les cartes ne sont pas garanties d'être données dans un ordre particulier.

Votre sortie doit être sélectionnée parmi un ensemble d'exactement deux valeurs distinctes, l'une indiquant que le jeu est légal et l'autre qui ne l'est pas.

Il n'est pas nécessaire de vérifier si le jeu de cartes existe réellement dans le jeu (par exemple, 77766suivi de 88877est impossible car il n'y a que quatre 7) - de tels cas ne seront jamais donnés.

Dans les cas de test suivants, 234567890JQKAreprésentent 2 par as et RPD1représentent respectivement le dragon, le phénix, le chien et Mah Jong. La chaîne vide est représentée ici sous la forme -. Ces jeux sont légaux:

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

Et ce ne sont pas:

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 fait, une quinte flush est aussi une bombe, mais comme c'est le seul endroit du jeu où la couleur des cartes est importante, j'ai choisi de la laisser de côté pour plus de simplicité}

^{2: la valeur du phénix joué au dessus d'une carte de valeur n est en fait n + 0,5 (un phénix sur un 9 est un 9 et demi); comme cela nécessite une connaissance de l'historique supplémentaire pour statuer, aucun cas de test n'implique un seul joué au-dessus d'un seul phénix}

^{3: donc la première entrée ne sera jamais un chien}

JavaScript (ES6),  274  273 octets

Prend l'entrée comme (a)(b), où et sont des tableaux d'entiers avec:$a$$b$

• $1$ = chien
• $3$ = Mah Jong
• $4..16$ = 2 ... Ace
• $18$ = dragon
• $19$ = phénix

Renvoie false pour valide ou true pour invalide.

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)

Essayez-le en ligne!

Comment?

Pour évaluer une main, nous construisons un tableau o[]composé d'un tête , initialement suivi de 16 zéros:$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 ];

Pour chaque rang de carte dans la main, l'emplacement correspondant o[]est incrémenté. Une fois joint à une chaîne, nous pouvons appliquer les expressions régulières suivantes pour détecter chaque type de main:

 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 main ne déclenche aucune de ces expressions régulières, elle n'est pas valide.

La valeur de la main est donnée par le nombre de zéros juste après le tête (le plus élevé est le mieux). Un cas spécial est une maison pleine où le rang du triple est supérieur à celui de la paire, auquel cas nous devons ajouter la longueur du motif.$9$(20*)

Le phénix (c'est-à-dire le caractère générique) est simplement remplacé par chaque rang de carte possible, en commençant par le plus élevé, jusqu'à ce qu'une correspondance soit détectée.

Python 3 , 466 455 403 401 399 octets

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

Essayez-le en ligne! L'entrée est une liste de mains où main est une liste d'entiers ¹ avec le mappage de valeurs suivant:

• 0: Phoenix
• 1: Mah Jong
• 2-13: 2 contre Ace
• 14: Dragon
• 15: Chien
• 16: chaîne vide

^{1: Bien que les tests TIO liés soient exprimés avec une liste de chaînes en raison de leur commodité qui sont traduites en fonction du mappage de valeurs avant d'appeler f}