Tichu è un gioco di carte in cui i giocatori giocano a turno set di carte da un mazzo costituito da un mazzo standard da 52 carte, più 4 carte aggiuntive:

• il drago , che ha un valore maggiore di qualsiasi altra carta
• la fenice , che può fungere da jolly
• il cane , che passa il turno al tuo partner
• il Mah Jong , che ha valore 1 (e la persona che lo tiene gioca per prima)

Il primo giocatore (che si dice abbia "lead") può scegliere di giocare uno dei seguenti tipi di combinazioni di carte:

• un singolo (ad es. 6)
• una coppia ( JJ)
• una tripla ( 555)
• una casa piena ( QQQ33) - una tripla e una coppia
• una scala ( 56789) - 5 o più carte consecutive
• un trattore ( 223344) - qualsiasi sequenza consecutiva di coppie

I giocatori successivi possono quindi giocare solo un set di carte dello stesso tipo, ma rigorosamente più alte. Ad esempio, QQpuò essere giocato sopra JJ, ma QQKKnon (è un trattore, non una coppia). Le case complete sono ordinate dalla tripla (ad es. 77722> 44499) E rettilinei e trattori devono avere la stessa lunghezza ( 456789non possono essere giocati sopra 23456). Gli assi sono alti.

C'è un'eccezione: qualsiasi 4 della stessa carta è una bomba e può essere giocata sopra qualsiasi cosa tranne una bomba più alta. ¹

Il drago può essere giocato da solo in cima a qualsiasi singolo o con piombo (ma da nessun'altra parte). La fenice, oltre ad essere un jolly, può anche essere giocata su qualsiasi singolo tranne il drago. ² Il cane può essere giocato solo da solo con piombo e termina immediatamente il turno. ³

La tua sfida è determinare se un determinato gioco Tichu è valido, dato il gioco precedente.

Puoi accettare entrambe le giocate in qualsiasi ordine come elenchi di numeri interi o stringhe; in entrambi i casi, puoi scegliere qualsiasi mappatura di carte in numeri interi / caratteri. Se c'è stata una giocata precedente, sarà sempre valida, e in caso contrario (cioè il giocatore ha un vantaggio), il primo input sarà l'array / stringa vuota (corrispondente al tipo dell'altro input). Non è garantito che le carte vengano date in un ordine particolare.

L'output deve essere selezionato da un set di esattamente due valori distinti, uno dei quali indica che il gioco è legale e uno che indica che non lo è.

Non è necessario verificare se l'insieme di carte esiste effettivamente nel mazzo (ad esempio, 77766seguito da 88877è impossibile perché ci sono solo quattro 7) - tali casi non verranno mai dati.

Nei seguenti casi di test, 234567890JQKArappresentare 2 attraverso l'asso e RPD1rappresentare rispettivamente il drago, la fenice, il cane e il Mah Jong. La stringa vuota è mostrata qui come -. Questi spettacoli sono legali:

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

E questi non sono:

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: in realtà, anche una scala reale è una bomba, ma poiché questo è l'unico posto nel gioco che conta il seme delle carte, ho scelto di lasciarlo fuori per semplicità}

^{2: il valore della fenice giocata sopra una carta con valore n è in realtà n + 0,5 (una fenice su un 9 è un 9 e mezzo); poiché ciò richiede la conoscenza della storia aggiuntiva per giudicare, nessun caso di test coinvolge un singolo suonato sopra una sola fenice}

^{3: quindi il primo input non sarà mai dog}

JavaScript (ES6),  274  273 byte

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

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

Restituisce false per valido o vero per non valido.

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)

Provalo online!

Come?

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 ];

Per ogni rango di carta nella mano, lo slot corrispondente o[]viene incrementato. Una volta ricollegati a una stringa, possiamo applicare le seguenti espressioni regolari per rilevare ogni tipo di 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

Se la mano non attiva nessuna di queste espressioni regolari, non è valida.

$9$(20*)

La fenice (cioè il jolly) viene semplicemente sostituita con ogni possibile valore di carta, a partire da quello più alto, fino a quando non viene rilevata una corrispondenza.

Python 3 , 466 455 403 401 399 byte

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

Provalo online! L'input è un elenco di mani in cui la mano è un elenco di numeri interi ¹ con la seguente mappatura dei valori:

• 0: Phoenix
• 1: Mah Jong
• 2-13: 2 all'asso
• 14: Drago
• 15: Cane
• 16: stringa vuota

^{1: Sebbene nei TIO collegati i test siano espressi con un elenco di stringhe per comodità che vengono tradotte in base alla mappatura dei valori prima di chiamare f}