Una de las cosas que hace que bridge bridge sea muy interesante es su metajuego "artificial" altamente complicado. Este sistema de puntuación de manos es una pequeña parte de él.

Bridge es un juego de cartas con trucos. Cada jugador obtiene una mano de 13 cartas, y el juego comienza con la oferta . La licitación determina cómo se juega el resto del juego, por lo que es una parte crucial del mismo. Para garantizar que usted y su pareja no oferten demasiado (o demasiado bajo), este sistema de puntuación artificial fue desarrollado para decirle lo buena que es su mano.

Puntuación

Aquí hay una mano de muestra:

S:KQT5
H:J72
D:965
C:AK8

Los símbolos S, H, D, C representan los palos (picas, corazones, diamantes y tréboles) y el resto son las cartas de esos palos. Entonces esta mano tiene una reina de espadas (Q), un rey de espadas (K), diez de espadas (T), cinco de espadas, jota de corazones, siete de corazones, etc.

El sistema de puntuación funciona de la siguiente manera:

• Obtienes 4 puntos por cada as (A) que tienes, 3 puntos por cada rey (K), 2 puntos por cada reina (Q) y 1 punto por cada jota (J). Ninguna otra carta da puntos.
• Cada carta después del cuarto en un palo te da 1 punto. Entonces, si tienes seis corazones, obtendrás 2 puntos.
• Un palo en el que solo tienes 2 cartas te da 1 punto (este es un doubleton). Un palo donde solo tienes 1 carta te da 2 puntos (este es un singleton). Si no tienes cartas en un palo determinado, obtienes 3 puntos (esto es un vacío). (Por lo general, estos solo se cuentan una vez que ha acordado un traje con su pareja, pero los incluyo para que el desafío sea más interesante).

Entonces, la mano anterior tiene 13 puntos.

Desafío

Dada una mano de puente en el formato que se muestra arriba, calcule cuántos puntos tiene la mano. Los trajes siempre se enumerarán en el orden de espadas, corazones, diamantes y tréboles, y las tarjetas siempre se ordenarán en el orden A, K, Q, J, T, 9-2.

Entradas y salidas de muestra

S:KQT5
H:J72
D:965
C:AK8
       \-> 13

S:AKQT6
H:54
D:J83
C:732
       \-> 12

S:
H:KQT8754
D:A86
C:432
       \-> 15

S:9876
H:843
D:652
C:432
       \-> 0

S:AKQT5
H:AQJ6
D:Q3
C:AK
       \-> 28

Este es el código de golf , por lo que gana el código más corto en bytes.

Jalea, 27 25 21 bytes

¡Gracias @Dennis por -3 bytes!

L_5.AḞW+“JQKA”i$€Sµ€S

Esto toma la entrada como una lista de líneas. Para tomar la entrada como una cadena multilínea, precatenate a ṣ⁷µ.

Hacer una tabla de los puntos de frecuencia:

Cards:    0  1  2  3  4  5  6 ... 4+k
Points:   3  2  1  0  0  1  2 ... k

podemos ver que son iguales a abs(c-3.5)-.5, donde c es el número de cartas. Como cada línea contiene dos caracteres adicionales, y el número de puntos es siempre un número entero, aquí es floor(abs(l-5.5))donde l es la longitud de la línea.

Tenga en cuenta que los índices de Jelly están basados ​​en 1, y también el comportamiento de las funciones vectorizadas en dimensiones no coincidentes: los elementos adicionales de la lista más larga no se ven afectados. Entonces [1] + [3,2,0,0]da [4,2,0,0].

                  µ      The program is two monadic fs applied in turn; an atop.
L_5.AW+“JQKA”i$€S       Helper function:
                 €        For €ach line:
L                         Get the line Length.
 _5.                      Subtract 5.5 (Numeric literals' decimal parts default to .5)
    A                     Apply Absolute value
     Ḟ                    Floor
      W                   Then Wrap it in an array. "S:AKQT6" gives [1].
        “JQKA”i$          Monadic function: index into the string "JQKA".
                €         Apply ^ over €ach char of the line; [3,2,0,0,0].
       +                  Add the two arrays together; [4,2,0,0,0].
                 S        Sum; 6.
                    S    Main link: Sum all results

Pruébalo aquí .

ES6, 107 99 89 bytes

s=>(t=0,[...s].map(c=>t+="JQKA".search(c)+1),s.split`
`.map(l=>t+=(l=l.length-6)^l>>4),t)

Pyth, 27 25 24 bytes

sms+a5.5ldshMxL"JQKA"d.z

Calculamos los valores por separado para cada palo, luego los sumamos.

  s m                 sum of map lambda d:  (d is a line of input)
      +                 add the
        s a                 floor of the absolute difference between
            5.5               5.5
            l d               and len(d)
          s hM xL           to the sum of the indices each incremented by one
                  "JQKA"      of each char in d in the string "JQKA"
                  d
      .z

Banco de pruebas .

Retina, 77 59 bytes

T`AKQJTd`5-1
:(.){0,3}(.)?
$#1$#1$#2 3$0
\S
$0$*1
+`1 1

1

Explicación por líneas / pares de líneas:

• En la primera línea convertimos caracteres AKQJT987655432a 5432111111111. Esto significa que para cada palo tenemos una suma. Si tenemos 0 1 2 3 4 5 6 7 ...cartas en este palo, la suma se deduce +3 +1 -1 -3 -4 -4 -4 -4 ...de la puntuación correcta.
• En las líneas 2 y 3 para corregir esto, agregamos 3 a cada línea y antes de un espacio agregamos valores que restaremos. Este valor restado es el doble de la longitud de las cartas con un máximo de 3 y 1 más si hay al menos 4 cartas.
• En las líneas 4 y 5, convertimos los dígitos a soltar soltando todo lo demás excepto el espacio separador.
• En las líneas 6 y 7 hacemos sustracción unaria.
• En la línea 8 contamos los 1que dan el resultado.

Pruébelo en línea aquí.

APL (Dyalog Classic) , 24 bytes

+/(⌊∘|5.5-≢¨),5|'JQKA'⍳∊

Pruébalo en línea!

usa ⎕io = 1

Stax , 18 bytes

½Γ}♣▓="pì∩û╨▐M↨}╚-

La respuesta más corta hasta ahora, derrotó a Jelly (aunque espero ser derrotado pronto ...)

¡Ejecute y depure en línea!

Explicación

Utiliza la versión desempaquetada para explicar.

LZF{"JQKA"I^+i5-:++F5+
L                         Collect input in a list (if this is not needed, we can yet save another byte)
 Z                        Put a zero under the top of the stack, used as the accumulator
  F                       Loop for every suit
   {               F      Calculate the "score" for the string describing the suit
    "JQKA"I^              Find the 1-based index of current character in "JQKA", 0 for not found
            +             Add to the accumulator
             i5-:+        Subtract 5 from the current 0-based index, and take the sign
                  +       Add to the accumulator
                    5+    Add 5 extra points for each suit

Esto se logra traduciendo

• Cada carta después del cuarto en un palo te da 1 punto. Entonces, si tienes seis corazones, obtendrás 2 puntos.
• Un palo en el que solo tienes 2 cartas te da 1 punto (este es un doubleton). Un palo donde solo tienes 1 carta te da 2 puntos (este es un singleton). Si no tienes cartas en un palo determinado, obtienes 3 puntos (esto es un vacío).

A

• Consigue 3 puntos extra por cada palo
• Cada carta antes del cuarto en un palo te da -1 punto, cada carta después del cuarto te da 1 punto, la cuarta carta obtiene 0.

Entonces podemos hacer uso de la propiedad de la función signum.

Al hacer esto, podemos evitar el manejo explícito del número de tarjetas que guardan unos pocos bytes.