Puntuación mundial de bolos

Muchas personas han ido a su centro de boliche local para jugar algunos juegos de bolos, y muchas personas continúan luchando para calcular sus puntajes. World Bowling ha introducido un sistema de puntuación simplificado para atraer a más personas al deporte. Este sistema de puntuación se utiliza en juegos internacionales.

El sistema de puntuación funciona así (de Wikipedia ):

El sistema de puntuación World Bowling, descrito como "puntuación de cuadro actual" [32], otorga los pines de la siguiente manera:

• Huelga: 30 (independientemente de los resultados de las tiradas posteriores)
• repuesto: más de 10 pinfall en el primer rollo del cuadro actual
• abierto: pinfall total para el marco actual

Si no está familiarizado con los bolos, aquí hay un resumen.

Hay 10 pines al final de una pista de bolos donde el objetivo es derribarlos a todos con una bola de boliche. Obtienes 2 lanzamientos de una bola para intentar derribarlos a todos, preferiblemente derribándolos a todos con el primer lanzamiento (conocido como strike ). Si recibe un golpe, entonces ese marco se completa y no necesita rodar la pelota por segunda vez. Una huelga vale 30.

Si no derribas los diez, obtienes un rollo más. Si derriba todos los pines restantes, eso se conoce como repuesto . El puntaje vale 10 pines + el número de pines derribados en el primer lanzamiento. Por ejemplo, si derribo 7 pines y luego logro derribar los 3 restantes, eso valdría 17.

Si después de su segundo lanzamiento no logra derribar los diez, eso se conoce como un marco abierto . La puntuación vale el número total de pines derribados para ese marco.

Hay 10 cuadros en un juego . Si estás familiarizado con la puntuación tradicional de bolos, no obtienes una tirada extra en el décimo cuadro con la Puntuación Mundial de Bolos. En la puntuación de bolos tradicional, se necesitan 12 golpes consecutivos para obtener una puntuación perfecta de 300, mientras que la puntuación de Bowling Mundial solo requiere 10 golpes consecutivos.

Reto

Su desafío es calcular el puntaje dado los valores de una hoja de puntaje.

En una hoja de puntaje, un error se indica con un guión ( - ), un golpe con una X y un repuesto con una barra ( / ). Si no se aplican, el recuento de pinfall simplemente se indica con un número (1-9). Las faltas y las divisiones también se registran en las hojas de puntuación, pero no necesita preocuparse por ellas.

Entrada

Se le dará una cadena que consta de puntajes para cada cuadro, y tendrá un total de diez cuadros. Cada cuadro tendrá hasta dos valores, o tan solo 1 valor si hubo una huelga. Su entrada puede ser un parámetro de cadena para una función, leer desde un archivo o desde STDIN.

Por ejemplo, si derribo 1 pin en mi primer rollo, luego derribo 2, el marco se vería como "12". Esto no significa 12 (doce), sino que significa 1 y 2, para un total de 3.

Si me perdiera cada pin con ambos rollos (bolas de canaleta), se vería así "-" (puntaje de 0).

Cada cuadro estará separado por un espacio.

Entrada de muestra

-- 9- -9 X -/ 8/ 71 15 44 X

Para desglosar este ejemplo,

• Cuadro 1 (-) - fallan ambos rollos. anotó 0
• Cuadro 2 (9-): derribó 9 en el primer lanzamiento, falló en el segundo lanzamiento. Puntuación 9
• Cuadro 3 (-9): se perdió todo en el primero, obtuvo 9 en el segundo. Puntuación 9
• Cuadro 4 (X) - Golpe, derribado los diez. Puntuación 30
• Cuadro 5 (- /) - Repuesto, se perdió todo en el primero, derribó a todos con el segundo lanzamiento. Puntuación 10 + 0 = 10
• Marco 6 (8 /) - Repuesto, 8 pines en el primer rollo, derribó a los otros 2 con el segundo rollo. Puntuación 10 + 8 = 18
• Marco 7 (71): marco abierto, 7 pines en el primer rollo, 1 pin en el segundo rollo. Puntuación 7 + 1 = 8
• Los cuadros 8, 9, 10 siguen los mismos ejemplos que anteriormente.

Salida

La salida será simplemente un valor que tenga la suma de las puntuaciones de los 10 fotogramas. Usando la entrada de muestra, la salida será 128. Su salida puede ser una cadena o un tipo numérico. Puede ser un valor de retorno de función, o escrito en STDOUT.

Reglas

• Suponga que la entrada siempre será válida. Por ejemplo, un marco inválido sería "/ 8", "XX", "123", "0", etc.
• No necesita preocuparse por divisiones o faltas.
• Su código puede ser un programa completo o una función que toma una cadena y devuelve el puntaje.
• Su código no debe arrojar ninguna excepción.
• Este es el código de golf, la respuesta con el menor número de bytes gana.
• Los idiomas que usan incluye o importa deben incluir las declaraciones de importación como parte de su código y contar para el recuento de bytes.

Casos de prueba

"-- 9- -9 X -/ 8/ 71 15 44 X" -> 128
"-- -1 2- 12 22 5- 42 61 8- 72" -> 45
"X X X 1/ 2/ 3/ 4/ 5/ -- 9/" -> 174
"X X X X X X X X X X" -> 300
"-- -- -- -- -- -- -- -- -- --" -> 0

05AB1E , 12 11 bytes

Código

S'/T:'X30:O

Pruébalo en línea!

Explicación

S             # Split the string into a list of characters
 '/T:         # Replace '/' with 10
     'X30:    # Replace 'X' with 30
          O   # Sum up the array (ignoring non-number elements)

JavaScript, 43 bytes

f=([c,...s])=>c?({'/':10,X:30}[c]|c)+f(s):0

f=([c,...s])=>c?({'/':10,X:30}[c]|c)+f(s):0

Score(<input style="width:200px" oninput="o.value=f(this.value)" />) = <output id=o></output>

Cómo funciona

Convertimos cada personaje a su punto:

• 'X' vale 30 puntos
• '/' vale 10 puntos
• '1' ... '9' vale 1 ... 9 puntos
• otros personajes que valen 0 puntos

Luego suma todos los puntos.

Convertir

El operador OR a nivel de bit |convierte su operando a Int32 antes de operar. Al convertir a Int32, el valor primero se convierte al formato de Número (número flotante de 64 bits), luego se conecta a Int32 (o se convierte a 0 si no es válido).

• ToInt32({'/':10,X:30}[c]) podría leerse como:
  • si c == '/': el resultado es 10;
  • si c == 'X': el resultado es 30;
  • de lo contrario: el resultado es ToInt32(undefined)-> ToInt32(NaN)-> 0;
• ToInt32(c) podría ser:
  • si c == '1' ... '9': el resultado es 1 .. 9;
  • si c == '': Number(c)es 0, el resultado es 0;
  • de lo contrario: Number(c)es NaN, el resultado es 0;
• Bitwise o aquí es lo mismo que "add", ya que uno de sus operandos será 0

Suma

• [c,...s] = sdejar c = s[0]y s = s.slice(1);
  • si s es una cadena vacía, c no está definida ;
  • de lo contrario, c es la primera letra de s
• indefinido es falso, la cadena no vacía (incluido el espacio) es verdadera

Stax , 13 bytes

─*âⁿ┴8òt↨HÉ÷8

Ejecutar y depurarlo

Desempaquetado, sin golf, y comentó que es así.

F               for each character in input, execute...
 9R$'/20*+'X+   build the string "123456789////////////////////X"
 I              get the index of the current character in string
 ^+             increment and add to running total
                (index is -1 when no match; space and dash are 0 score)

Ejecute este

Python 2 , 55 bytes

lambda l:sum(map(('123456789/'+'X'*20).rfind,l))+len(l)

Pruébalo en línea!

Basado en el enfoque de índice de cadena de muchas soluciones.

Java 8, 64 59 46 bytes

s->s.map(c->c<46?0:c<48?10:c>87?30:c-48).sum()

-5 bytes gracias a @Neil .
-13 bytes gracias a @ OlivierGrégoire .

Explicación:

Pruébalo en línea.

s->               // Method with an IntStream parameter and integer return-type
  s.map(c->       //  Loop over the characters
          c<46?   //   If the character is a space or '-':
           0      //    Count it as 0
          :c<48?  //   Else-if it's a '/':
           10     //    Count it as 10
          :c>87?  //   Else-if it's an 'X':
           30     //    Count it as 30
          :       //   Else (it's a digit):
           c-48   //    Count it as the value of the digit
       ).sum()    //   And sum everything

F #, 106103 bytes

let s c=Seq.sumBy(fun x->if x=' '||x='-'then 0 elif x='X'then 30 elif x='/'then 10 else int(string x))c

Pruébalo en línea!

Creo que este rompecabezas (sin el golf) sería una gran pregunta para una guía de "Programación funcional para principiantes". ¡Y debería saberlo!

-3 de Kevin Cruijssen, por detectar que el espacio en blanco entre 'y "entonces" se puede eliminar. ¡Gracias!

La solución Stax de recursive de usar índices de cadena es muy, muy buena. Si lo transfiere a F #, puede obtenerlo por 77 bytes :

let s c=Seq.sumBy(fun x->"123456789/???????????????????X".IndexOf(char x)+1)c

¡Prueba esto en línea!

Jalea , 17 bytes

ḟ⁾ -“X0/⁵”yV€o30S

Un enlace monádico que acepta una lista de caracteres y devuelve un entero

Pruébalo en línea!

¿Cómo?

ḟ⁾ -“X0/⁵”yV€o30S - Link: list of characters
 ⁾ -              - literal list of characters [' ','-']
ḟ                 - filter discard
    “X0/⁵”        - literal list of characters ['X','0','/','⁵']
          y       - translate (change 'X's to '0's and '/'s to '⁵'s)
           V€     - evaluate €ach character as Jelly code (the '⁵'s become 10s)
             o30  - logical OR with 30 (change all instances of 0 to 30)
                S - sum

También a los 17:

”/ẋ20ØD;;”XḊiЀ⁸S

Trata eso

Perl 6 , 30 bytes

{TR'-/X '0㉈㉊'.univals.sum}

Pruébalo en línea!

Retina , 17 bytes

X
///
/
55
\d
*
_

Pruébalo en línea!

No estoy muy actualizado sobre los últimos cambios de Retina. Los buscaré más cuando tenga la oportunidad y veré si hay nuevos trucos para jugar golf. El código convierte todos los golpes en tres repuestos, todos los repuestos en diez puntos, luego todos los puntos en el número correspondiente de guiones bajos. Luego cuenta el número de guiones bajos.

Perl 5 -pF , 30 27 bytes

-3 bytes gracias a Xcali

#!/usr/bin/perl -pF
$\+=m%/%+3*/X/.0+$_ for@F}{

Pruébalo en línea!

05AB1E , 14 bytes

þ`I…/aXS¢ƶT*`O

Pruébalo en línea!

Explicación

þ`              # Push the digits of the input on the stack (removes everyting that isn't a digit)
  I…/aXS        # Push the input and the array "/","a","X" on the stack
        ¢       # Index of each element in the input ...
         ƶT*    # ... multiplied by its index (a could be anything that can't be found in the input), multiplied by 10.
            `O  # Sum the stack, implicit display

J , 33 bytes

1#.31|('-123456789',20 1#'/X')i.]

Pruébalo en línea!

Explicación:

] la entrada

('-123456789',20 1#'/X')agrega 20 /y uno Xa la cadena-123456789

i. encuentra los índices de la entrada en la cadena anterior

31| módulo 31 - para deshacerse de los espacios - no se encuentran en la cadena, entonces i. devuelve 31 para ellos

1#. encuentra la suma de los índices

Python 2 , 67 bytes

-3 bytes gracias a @KevinCruijssen

lambda I,p='-123456789/'+20*'X':sum(p.rfind(i)for i in I if i in p)

Pruébalo en línea!

Jalea , 12 bytes

⁾/X,“½œ‘y|0S

Pruébalo en línea!

Cómo funciona

⁾/X,“½œ‘y|0S  Main link. Argument: s (string)

⁾/X,“½œ‘      Literal; yield [['/', 'X'], [10, 30]].
        y     Transliterate; replace '/' with 10, 'X' with 30.
         |0   Bitwise OR with 0. Bitwise operators attempt to cast to int, mapping 
              '0', ..., '9' to 0, ..., 9. All other characters map to 0.
           S  Take the sum.

Python 3.6 , 54 bytes

lambda s:sum(map(f'123456789/{6**24}X'.find,s),len(s))

Pruébalo en línea!

Kotlin , 50 bytes

x->x.sumBy{"123456789/_${Math.E}_X".indexOf(it)+1}

Pruébalo en línea!

Espero que no esté en contra de las reglas responder tu propia pregunta, pero quería unirme a la diversión.

Math.Eproduce el valor 2.718281828459045. Lo estoy usando para crear una cadena de relleno para empujar X a la posición 30.

indexOfobtiene la posición (basada en 0) del personaje en la cadena "12345 ...". Si no se encuentra, devuelve -1. Agregamos 1 para hacer estos 0, y eso también hace que la posición basada en 0 sea el valor de la cadena.

PHP, 119109 bytes

-10 bytes gracias a @KevinCruijssen

<?foreach(explode(" ",$argv[1])as$f){[$a,$b]=str_split($f);$n+=$f==X?30:(int)$a+($b=='/'?10:(int)$b);}echo$n;

Pruébalo en línea!

Carbón , 23 bytes

ＩΣＥχΣＥＳ⎇№-/Xλ×χ⌕-//XλＩλ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

  Ｅχ                    Map over 10 frames
      Ｓ                 Input the frame
     Ｅ                  Map over the characters
            λ           Current character
        №-/X            Search the literal string `-/X`
                    λ   Current character
               ⌕-//X    Find position in literal string `-//X`
             ×χ         Multiply by predefined variable 10
                      λ Current character
                     Ｉ  Cast to integer
       ⎇                Ternary
    Σ                   Sum for each frame
 Σ                      Sum over frames
Ｉ                       Cast to string for implicit print

Rojo , 93 bytes

func[b][s: 0
foreach c trim/all b[s: s - 1 + index? find{-123456789/...................X}c]s]

Pruébalo en línea!

C # (.NET Core) , 40 + 18 = 58 bytes

using System.Linq;
s=>s.Sum(c=>c>87?30:c<46?0:c<48?10:c-48)

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 53 bytes

Write(ReadLine().Sum(c=>c>87?30:c<46?0:c<48?10:c-48))

Pruébalo en línea!

SNOBOL4 (CSNOBOL4) , 169 151 147 bytes

	F =INPUT ' '
R	F '-' =0	:S(R)
T	F 'X' ='_'	:S(T)
S	F LEN(1) . X ARB . Y ' ' REM . F	:F(O)
	X '_' =30
	Y '/' =10
	S =S + X + Y	:(S)
O	OUTPUT =S
END

Pruébalo en línea!

	F =INPUT ' '					;* read input and append a space
R	F '-' =0	:S(R)				;* replace - with 0
T	F 'X' ='_'	:S(T)				;* replace X with _
S	F LEN(1) . X ARB . Y ' ' REM . F	:F(O)	;* set first character to x, remainder up to ' ' to y, and remainder to F
	X '_' =20					;* replace _ in x with 20
	Y '/' =10					;* replace / in y with 10
	S =S + X + Y	:(S)				;* else X and Y are their values so we can sum them
O	OUTPUT =S					;* output the sum
END

Clojure , 70 bytes

#(reduce(fn[s i](+ s(case i\- 0\/ 10\X 30\space 0(bigint(str i)))))0%)

Pruébalo en línea!

Al reducepasar sobre una Cadena, cada personaje se convierte en un personaje, ¿quién lo hubiera pensado? Pero esto es malo, tengo que escribir \spacey eso duele más de lo que uno puede imaginar. Además, al crear un número real a partir de un carácter, la combinación debigint ystr parece ser la única combinación utilizable.

Bueno, aparte de todas estas luchas: función anónima que devuelve el puntaje como algo natural.

Rubí , 38 bytes.

->s{s.tr("/X -",":N00").sum-s.size*48}

Pruébalo en línea!