Cuando era niño, solía jugar mucho al juego de cartas " golf " . Su desafío, si elige aceptarlo, es calcular el puntaje de una mano de golf. Como hay más de 9000 variaciones en este juego de cartas ¹ , iremos con las reglas que recuerdo haber jugado.

Reglas del juego)

• Terminas una ronda con 6 cartas y quieres la menor cantidad de puntos posible.

• Los comodines no se usan.

• Los ases y los 2 valen -1 y -2 puntos respectivamente.

• Jacks y Kings valen 0 puntos.

• Las cartas del 3 al 10 valen su valor nominal. Sin embargo, estos se cancelan cuando los empareja. Por ejemplo, un 5 vale 5 puntos, pero dos 5 valen cero. Tres 5 valen 5 puntos (ya que los 2 primeros están emparejados, pero el tercero no.) Y cuatro 5 valen 0 (ya que forman 2 pares).

• Las reinas valen 15 puntos. Las reinas no se pueden cancelar, por ejemplo, 2 reinas valen 30 puntos.

Reglas (del desafío)

La entrada será una matriz de enteros, o 6 enteros individuales. Cualquiera que prefiera. 1 representa un as, 2-10 representa 2-10, y Jack, Queen y King representan 11, 12 y 13. La salida es el puntaje de la mano de acuerdo con las reglas anteriores. Puede asumir con seguridad que todas las entradas son válidas, por ejemplo, ningún número aparece más de 4 veces, y todos los números están en el rango [1, 13]. La entrada y la salida pueden estar en cualquier formato razonable.

Prueba 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

¡La respuesta más corta en bytes gana!

¹ no realmente, pero hay una gran cantidad de variaciones.

Pyth, 28 27 25 bytes

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

Pruébalo en línea. Banco de pruebas.

Explicación

• En primer lugar, Pyth agrega automáticamente algunas variables. El código es ahora s+*L%/Qd2}3Tm?<d3_d*15q12dQ.
• }3Tgenera la lista [3, 4, 5, 6, 7, 8, 9, 10].
• Multiplique cada número en esa lista ( *L) por el recuento de ese número en la entrada ( /Qd), módulo 2 ( %... 2). El resultado es 0 para los números emparejados y el número mismo para los no emparejados.
• Mapa sobre los números de entrada ( m... Q):
  • Si el número es menor que 3 ( ?<d3), niegue ( _d).
  • De lo contrario, verifique si es 12 ( q12d) y multiplique el booleano por 15 ( *15). El resultado es 15 para reinas y 0 para cualquier otra cosa.
• Concatenar las listas ( +). La lista resultante ahora contiene las puntuaciones para los números no emparejados (la primera parte) y las tarjetas especiales A, 2, Q (la segunda parte), con algunos ceros adicionales.
• Finalmente, tome la suma del resultado ( s).

Solución alternativa de 25 bytes.

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

Esto funciona de manera similar a la primera, pero cuenta las reinas por separado y niega los ases y los dos con un filtro.

Python 2, 72 70 bytes

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

En un momento deseé que Python fuera tratado 0**0 == 0por una vez para poder hacerlo (-condition)**num. Llama como f(11, 10, 3, 1, 2, 2).

Versión anterior de 72 bytes:

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 bytes

Se espera que los números de entrada estén en la pila al inicio del programa, por lo que +2 bytes para el -vindicador. Pruébalo en línea!

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

Como todos los valores no utilizados en el campo de código se inicializan 0, se puede usar para calcular cuántos de cada valor está presente en la pila obteniendo el valor [value,6], incrementándolo y volviéndolo a colocar en el campo de código. El total se calcula como:

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

Editar: eliminó 6 bytes de golf reestructurando la entrada y cambiando los pasos de cálculo. Versión previa:

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

Edición 2: guardado 1 byte, gracias a Sp3000

MATL , 27 26 bytes

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

La entrada es una matriz de columnas, es decir, los valores están separados por punto y coma.

Pruébalo en línea! o verificar todos los casos de prueba (esto se suma un bucle de tomar todas las entradas, y reemplaza Gpor 1$0Gempujar última entrada).

Explicación

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

Esto parece demasiado grande, pero FGITW.

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

Test Suite .

JavaScript (ES6), 63 bytes

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

O si lo prefieres

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 bytes

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

Pruébalo en línea!

Perl 5.10.0 + -n, 115 64 60 56 bytes

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

Pruébalo en línea!

Explicación:

Agregando el -nbucle a su alrededor:

# 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
}