Scrivi il codice per determinare chi vince una presa di quattro carte in una partita a Picche . Vince il minor numero di byte.

L'ingresso è una stringa che elenca le quattro carte giocate in sequenza come TH QC JH 2H(Ten of Hearts, Queen of Clubs, Jack of Hearts, Two of Hearts). Una carta è data da due personaggi: un seme di CDHSe un valore di 23456789TJQKA. Si garantisce che l'input è valido e che le carte sono distinte.

Dovresti ottenere un numero 1, 2, 3 o 4 per il vincitore del trucco. Nell'esempio TH QC JH 2H, il jack dei cuori vince il trucco, quindi dovresti ottenere 3.

L'input e l'output devono essere esattamente come descritti, tranne che le nuove righe finali sono opzionali.

Ecco le regole di Spades per vincere un trucco. La carta vincente è la carta più alta delle quattro, con alcuni avvertimenti. Spades è il seme di briscola , quindi ogni spade supera qualsiasi non spade. Il seme della prima carta giocata è il seme di testa , e solo le carte di quel seme o picche possono vincere la presa. Le carte dello stesso seme sono confrontate con i loro valori, che sono dati in ordine crescente come 23456789TJQKA.

Casi test:

TH QC JH 2H
3
KC 5S QS 9C
3
QD 2D TD 5D
1
9S 5D AD QS
4
3D 4C 3H JH
1
9S 4S TS JS
4
5H 9H 2C AD
2
5S 4C 3H QD
1
2H 2S KH AH
2

Pyth, 28 27 25 byte

J"KTAZ"hxcz)eo_XN+@z1JJcz

Provalo online: Demonstration o Test Suite (i primi 4 caratteri sono il costrutto della suite di test)

Grazie a @isaacg per un trucco, che ha salvato 2 caratteri.

L'idea principale è quella di modificare i caratteri di ogni mano in modo tale che la mano vincente abbia il valore massimo.

I valori delle mani 23456789TJQKAsono già quasi ordinati. Devo solo sostituire Tcon A, Kcon Te Acon Z, risultante con 23456789AJQSZ.

L'ordine dei semi CDHSè per la maggior parte non molto importante. S, il seme più potente, che è già il valore massimo. È importante dare al seme della prima mano il secondo valore più potente. Quindi traduco questo seme in K.

Anche tutte le mani devono essere lette al contrario, poiché il seme è più potente del valore.

                           implicit: z = input string
J"KTAZ"                    J = "KTAZ"
             o         cz  orders the hands N of split(z) by:
              _              the reversed of 
               XN+@z1JJ      N, where the values z[1]+J are replaced by J
            e              last element (winning hand)
        xcz)               index of the winning hand in split(z)
       h                   + 1

CJam, 34 33 byte

lS/_{)2$0='S+\#\"TQKA"_$er+}$W>#)

Algoritmo

La logica è semplice Ho un ordinamento in corso, in cui per prima cosa do la priorità al secondo personaggio che rappresenta il seme. In questo, Spades ottiene la massima priorità e quindi la prima suite generata. Tutto il resto lo sono -1. Poi ordino il primo personaggio con lo scambio di Tcon Ae Qcon Kper avere un ordinamento lessicale.

Spiegazione del codice

Prima di tutto, vediamo qual è l'ordine lessicale dei valori facciali delle carte:

"23456789TJQKA"$

23456789AJKQT

Quindi, tutti i numeri sono nella posizione corretta. Jè anche nella posizione corretta. Dobbiamo scambiare Ke Qed Je Aper ottenere l'ordine lessicale.

lS/_{)2$0='S+\#\"TQKA"_$er+}$W>#)
lS/                                 "Read an input line and split on spaces";
   _{                      }$       "Copy the array and sort it using this custom logic";
     )                              "Take off the last character of each hand.";
      2$0=                          "Get the suit of the first hand";
          'S+                       "Add Spades suit to it";
             \#                     "Get the index of the current hand suit.
                                     1 for Spades, 0 for first hand suit, -1 otherwise";
               \                    "Put face value of this hand on top of stack";
                "TQKA"              "Put string TQKA on stack";
                      _$            "Copy and sort. This essentially reverses the string
                                     TQKA to form AKQT. This is 1 byte shorter than _W%";
                        er+         "Swap T with A and K with Q and add to the
                                     suit index calculated previously";
                                    "After the above tuple, sorting will automatically
                                     convert the tuple to string and sort lexically";
                             W>     "Get the array containing only the last element";
                               #)   "Get the index of this hand in original set and
                                     increment to convert it to 1 based";

Provalo online qui

JavaScript (ES6), 112

Scansiona l'elenco e restituisce la posizione del valore più alto trovato.

Esegui snippet per testare (in Firefox)

F=t=>t.split(' ').map((c,i)=>(n='23456789TJQKA'.search(c[0])+(c[1]>'H'?40:c[1]==t[1]&&20))>m&&(m=n,r=i+1),m=0)|r

C.innerHTML=['TH QC JH 2H','KC 5S QS 9C','QD 2D TD 5D','9S 5D AD QS','3D 4C 3H JH','9S 4S TS JS','5H 9H 2C AD','5S 4C 3H QD'].map(h=>h+' -> '+F(h)).join('\n')

<pre id=C></pre>

Perl, 73 byte

#!perl -pl
/\B./;s/$&/P/g;y/TKA/IRT/;$_=reverse;@a=sort split;/$a[-1]/;$_=4-"@-"/3

Prova a me .

Converte i nomi delle carte in modo che l'ordine del valore di gioco segua l'ordine alfabetico, quindi seleziona il più alto ordinando e cercandolo nella stringa originale per posizione.

Rubino, 59 + 2 = 61

Con i flag della riga di comando na, eseguire

p (1..4).max_by{|i|$F[i-1].tr($_[1]+'SJQKA','a-z').reverse}

J, 47 byte

1+[:(i.>./)_3+/\16!@-]i.~'SXAKQJT9876543'1}~1&{

Uso:

   (1+[:(i.>./)_3+/\16!@-]i.~'SXAKQJT9876543'1}~1&{) 'TH QC 9S 8S'
3

Metodo:

• Per ogni carattere di input assegniamo un valore basato sulla sua posizione nella 'S[second char of input]AKQJT9876543'stringa. I caratteri non trovati ottengono last position + 1implicitamente il valore . Altri personaggi hanno un valore molto inferiore (value=(16-position)! ).
• Calcola la somma per la tripletta 3 input-char e una duplet (ad es. TH_ QC_ 9S_E8S ).
• Scegli l'indice in base 1 del valore massimo.

(J purtroppo non può confrontare direttamente caratteri o stringhe. Può solo verificare la loro uguaglianza che ha escluso altri approcci per questa sfida.)

Provalo online qui.

C #, 237

using System;namespace S{class P{static void Main(string[] a){var V="23456789TJQKA";int x=0;int y=0;var z=a[0][1];for(int i=0;i<4;i++){int q=V.IndexOf(a[i][0])+2;var w=a[i][1];q*=w==z?1:w=='S'?9:0;if(q>y){x=i;y=q;}}Console.Write(x+1);}}}

Come funziona: itera ogni mano per calcolare il "valore" della carta .. memorizza l'indice con il valore più alto. Il valore di una carta viene determinato come il rango della carta moltiplicato per 0 se non è una carta di picche o il seme di apertura, 1 se è il seme di apertura e 9 se è una carta di picche ma non il seme di apertura. (9 scelto b / c 2 * 9 = 18> A = 14 e 9 è un singolo carattere)

Pyth, 36 33 byte

KczdhxKeo,x,ehK\SeNXhN"TKA""AYZ"K

Approccio abbastanza semplice, utilizza l'ordinamento con una funzione chiave personalizzata, quindi trova l'indice del valore più alto.

Pyth, 31 byte

hxczdeo}\SNo}@z1Zox"TJQKA"hNScz

Provalo qui.

Come funziona:

Il modo corretto di leggere questa procedura è di fronte. La procedura ordina la carta desiderata alla fine dell'elenco, quindi la estrae e trova il suo indice nell'elenco originale.

• cz: Questo genera l'elenco delle stringhe di carte. c, chop, è normalmente una funzione binaria (arity 2), ma quando viene chiamato su un solo input, funge da .split()metodo stringa.

• S: Questo applica il normale comportamento di ordinamento, che ordina le carte con un numero inferiore prima di quelle più alte.

• ox"TJQKA"hN: Ordina le carte in base all'indice ( x) nella stringa "TJQKA"della prima lettera della carta ( hN). Per le carte con numeri, la prima lettera non viene trovata, dando il risultato -1. Poiché la funzione di ordinamento di Pyth è stabile, l'ordine delle carte numerate non è influenzato.

• o}@z1Z: Quindi ordiniamo se il seme della prima carta giocata ( @z1) è nella carta in questione. Dal momento che una Truespecie dietro False, questo invia le carte del seme di piombo sul retro.

• o}\SN: Questo è lo stesso del tipo precedente, ma ordina se la lettera Sè nella carta, inviando picche sul retro.

• hxczde: Questo estrae l'ultima carta ordinata in questo modo ( e), trova il suo indice nell'elenco delle carte ( xczd) e incrementa di 1 ( h), fornendo la posizione del giocatore desiderata.