Da bambino, giocavo molto al gioco di carte " golf " . La tua sfida, se scegli di accettarla, è calcolare il punteggio di una mano da golf. Dato che ci sono oltre 9000 varianti in questo gioco di carte ¹ , seguiremo le regole che ricordo di aver giocato.

Le regole del gioco)

• Finisci un round con 6 carte e vuoi il minor numero di punti possibile.

• I jolly non vengono utilizzati.

• Gli assi e i 2 valgono rispettivamente -1 e -2 punti.

• Jack e Kings valgono entrambi 0 punti.

• Le carte da 3 a 10 valgono il loro valore nominale. Tuttavia, questi vengono annullati quando li abbini. Ad esempio, un 5 vale 5 punti, ma due 5 valgono zero. Tre 5 valgono 5 punti (dal momento che i primi 2 sono accoppiati, ma il terzo no.) E quattro 5 valgono 0 (poiché fa 2 coppie).

• Le regine valgono 15 punti. Le regine non possono essere cancellate, ad esempio 2 regine valgono 30 punti.

Regole (della sfida)

L'input sarà un array di numeri interi o 6 singoli numeri interi. Qualunque tu preferisca. 1 rappresenta un asso, 2-10 rappresenta 2-10 e Jack, Queen e King rappresentano 11, 12 e 13. L'output è il punteggio della mano secondo le regole sopra. Puoi tranquillamente supporre che tutti gli ingressi siano validi, ad es. Nessun numero appare più di 4 volte e tutti i numeri sono nell'intervallo [1, 13]. L'input e l'output possono essere in qualsiasi formato ragionevole.

Test IO:

[11, 10, 3, 1, 2, 2]    --> 8
[4, 5, 5, 3, 8, 7]      --> 22
[2, 2, 2, 2, 1, 1]      --> -10 (The lowest score possible)
[12, 12, 12, 12, 10, 9] --> 79 (The highest score possible)
[9, 9, 9, 9, 11, 1]     --> -1
[8, 8, 8, 8, 11, 13]    --> 0
[10, 9, 3, 7, 12, 2]    --> 42
[1, 2, 3, 4, 5, 6]      --> 15
[10, 9, 2, 3, 4, 1]     --> 23
[10, 3, 12, 3, 7, 12]   --> 47

Vince la risposta più breve in byte!

¹ non proprio, ma ci sono molte varianti.

Pyth, 28 27 25 byte

s+*L%/Qd2}3Tm?<d3_d*15q12

Provalo online. Suite di test.

Spiegazione

• Innanzitutto, Pyth aggiunge automaticamente alcune variabili. Il codice è adesso s+*L%/Qd2}3Tm?<d3_d*15q12dQ.
• }3Tgenera l'elenco [3, 4, 5, 6, 7, 8, 9, 10].
• Moltiplicare ogni numero in quell'elenco ( *L) per il conteggio di quel numero nell'input ( /Qd), modulo 2 ( %... 2). Il risultato è 0 per i numeri associati e il numero stesso per quelli non associati.
• Mappa sui numeri di input ( m... Q):
  • Se il numero è inferiore a 3 ( ?<d3), negalo ( _d).
  • Altrimenti controlla se è 12 ( q12d) e moltiplica il valore booleano per 15 ( *15). Il risultato è 15 per le regine e 0 per qualsiasi altra cosa.
• Concatena le liste ( +). L'elenco risultante ora contiene i punteggi per i numeri non accoppiati (la prima parte) e le carte speciali A, 2, Q (la seconda parte), con alcuni zero aggiuntivi.
• Infine, prendi la somma del risultato ( s).

Soluzione alternativa a 25 byte

-+s*L%/Qd2}3T*15/Q12s<#3Q

Funziona in modo simile al primo, ma conta le regine separatamente e annulla gli assi e i due con un filtro.

Python 2, 72 70 byte

f=lambda x,*T:[x*(-1)**T.count(x),~x%2*15,-x][(x-3)/8]+(T>()and f(*T))

Ad un certo punto avrei desiderato che Python fosse trattato 0**0 == 0per una volta così da poterlo fare (-condition)**num. Chiama come f(11, 10, 3, 1, 2, 2).

Versione precedente a 72 byte:

f=lambda x,*T:[~x%2*15,x*(-1)**(x<3or T.count(x))][x<11]+(T>()and f(*T))

> <> , 63 57 56 + 2 = 65 59 58 byte

I numeri di input dovrebbero essere nello stack all'avvio del programma, quindi +2 byte per il -vflag. Provalo online!

</!?lp6$+1g6:
3\0
?\::6g2%*{+}1+:b=
;\~16g-26g2*-c6gf*+n

Poiché tutti i valori inutilizzati nel campo del codice sono inizializzati 0, può essere utilizzato per determinare quanti di ciascun valore è presente nello stack ottenendo il valore [value,6], incrementandolo e reinserendolo nel campo del codice. Il totale viene quindi calcolato come:

T = 0 + {for x in 3 to 10, x*([x,6]%2)} - [1,6] - 2*[2,6] + 15*[12,6]

Modifica: golf 6 byte off ristrutturando l'input e cambiando i passaggi di calcolo. Versione precedente:

:6g1+$6pl0=?\
/-*2g62-g610/
c ;n$\
6:b=?/>::6g2%*{+}1+!
\gf*+3/

Modifica 2: salvato 1 byte, grazie a Sp3000

MATL , 27 26 byte

3:10=s2\7M*G12=15*Gt3<*_vs

L'input è un array di colonne, ovvero i valori sono separati da punti e virgola.

Provalo online! o verificare tutti i casi di test (questo aggiunge un ciclo per prendere tutti gli ingressi, e sostituisce Gda 1$0Gspingere ultime ingresso).

Spiegazione

3:10=    % Take input implicitly. Compare with range [3 4 ... 10], with broadcast
s        % Sum of each column: how may threes, fours, ... tens there are
2\       % Modulo 2
7M       % Push [3 4 ... 10] again
*        % Element-wise multiply (the sum of this array is the score of 3...10)
G        % Push input again
12=      % Compare with 12, element-wise
15*      % Multiply by 15 (this is the score of 12)
G        % Push input again
t3<      % Duplicate. True for entries 1 or 2
*_       % Multiply and negate (the sum of this array is the score of 1, 2)
v        % Concatenate all stack concents into a vertical array
s        % Sum of array. Implicitly display

Pyth - 37 36 35

Sembra troppo grande, ma FGITW.

J<#h;K-QS2++*15/K12sm*d%/Jd2{J_s@S2

Test Suite .

JavaScript (ES6), 63 byte

a=>a.map(e=>r+=e<3?-e:e>10?e-12?0:15:(m[e]^=1)?e:-e,r=0,m=[])|r

O se preferisci,

a=>a.map(e=>r-=e<3?e:e>10?e-12?0:-15:(m[e]^=1)?-e:e,r=0,m=[])|r

Perl 5 , 74 +1 ( -a) = 75 byte

map$s+=/12/?15:$_<3?-$_:$_<11?$k{$_}?-delete$k{$_}:($k{$_}=$_):0,@F;say $s

Provalo online!

Perl 5.10.0 + -n, 115 64 60 56 byte

$p+=$_-12?$_>2?$_<11?++$l[$_]%2?$_:-$_:0:-$_:15}{say$p

Provalo online!

Spiegazione:

Aggiungendo il -nloop attorno ad esso:

# Used variables:
# $_: input (auto)
# $p: points
# $l[n]: number of occurences of n (for 3-10)
while (<>) { # for every input
    $p += $_ - 12 ? # if the input is not 12 (queen) ...
        $_ > 2 ? # then: if it's > 2 (not ace or 2) ...
            $_ < 11 ? # then: if < 11 (3-10) ...
                ++$l[$_] % 2 ? # then: if it's an odd occurence (1st, 3rd, 5th, ...)
                    $_ # add it
                    : -$_ # else subtract it
            : 0 # no points for other stuff (J, K)
        : -$_ # negative points for ace and 2
    : 15 # 15 points for queen
}
{ # after input:
    say $p # output points
}