Pontuação mundial de boliche

Muitas pessoas foram ao centro de boliche local para jogar alguns jogos de boliche e muitas continuam lutando para calcular suas pontuações. O World Bowling introduziu um sistema de pontuação simplificado para atrair mais pessoas para o esporte. Este sistema de pontuação é utilizado em jogos internacionais.

O sistema de pontuação funciona assim (da Wikipedia ):

O sistema de pontuação do World Bowling - descrito como "pontuação atual de quadros" [32] - possui pinos da seguinte maneira:

• strike: 30 (independentemente dos resultados dos testes seguintes)
• sobressalente: 10 mais pinfall no primeiro rolo do quadro atual
• aberto: pinfall total para o quadro atual

Se você não conhece o boliche, aqui está uma recapitulação.

Existem 10 pinos no final de uma pista de boliche, onde o objetivo é derrubar todos eles com uma bola de boliche. Você recebe 2 jogadas de bola para tentar derrubá-las todas, de preferência derrubando-as todas com a primeira jogada (conhecida como golpe ). Se você receber uma tacada, esse quadro estará completo e você não precisará rolar a bola uma segunda vez. Uma greve vale 30.

Se você não derrubar todos os dez, terá mais uma jogada. Se você derrubar todos os pinos restantes, isso é conhecido como sobressalente . A pontuação vale 10 pinos + o número de pinos derrubados no primeiro rolo. Por exemplo, se eu derrubasse 7 pinos, conseguiria derrubar os 3 restantes, que valeriam 17.

Se após a sua segunda jogada você não derrubar todas as dez, isso é conhecido como um quadro aberto . A pontuação vale o número total de pinos derrubados para esse quadro.

Existem 10 quadros em um jogo . Se você conhece a pontuação tradicional de boliche, não recebe um rolo extra no 10º quadro com a Pontuação Mundial de Boliche. Na pontuação tradicional de boliche, são necessários 12 acertos consecutivos para obter uma pontuação perfeita de 300, enquanto a pontuação no boliche mundial exige apenas 10 acertos consecutivos.

Desafio

Seu desafio é calcular a pontuação fornecida pelos valores de uma planilha de pontuação.

Em uma planilha de pontuação, uma falta é indicada por um traço ( - ), uma batida com um X e uma reposição com uma barra ( / ). Se estes não se aplicarem, a contagem de pinfall é simplesmente indicada com um número (1-9). Faltas e divisões também são registradas nas fichas, mas você não precisa se preocupar com isso.

Entrada

Você receberá uma sequência composta por pontuações para cada quadro e terá um total de dez quadros. Cada quadro terá até dois valores, ou apenas 1 valor, se houver uma ocorrência. Sua entrada pode ser um parâmetro de string para uma função, ler de um arquivo ou de STDIN.

Por exemplo, se eu derrubar 1 pino no meu primeiro rolo e depois derrubar 2, o quadro parecerá "12". Isso não significa 12 (doze), mas significa 1 e 2, para um total de 3.

Se eu perdesse todos os pinos com os dois rolos (bolas de sarjeta), ficaria assim "-" (pontuação 0).

Cada quadro será separado por um espaço.

Entrada de amostra

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

Para detalhar esse exemplo,

• Quadro 1 (-) - ambos os rolos foram perdidos. marcou 0
• Quadro 2 (9-) - derrubou 9 no primeiro rolo e perdeu no segundo. Pontuação 9
• Quadro 3 (-9) - Perdeu tudo no primeiro, conseguiu 9 no segundo. Pontuação 9
• Quadro 4 (X) - Greve, derrubou todos os dez. Pontuação 30
• Quadro 5 (- /) - Spare, perdeu tudo no primeiro, derrubou todos com o 2º rolo. Pontuação 10 + 0 = 10
• Quadro 6 (8 /) - Sobressalente, 8 pinos no primeiro rolo, derrubou os outros 2 com o 2º rolo. Pontuação 10 + 8 = 18
• Estrutura 7 (71) - estrutura aberta, 7 pinos no primeiro rolo, 1 pino no segundo rolo. Pontuação 7 + 1 = 8
• Os quadros 8,9,10 seguem os mesmos exemplos acima.

Saída

A saída será simplesmente um valor que possui a soma das pontuações de todos os 10 quadros. Usando a entrada de amostra, a saída será 128. Sua saída pode ser uma sequência ou um tipo numérico. Pode ser um valor de retorno da função ou gravado em STDOUT.

Regras

• Suponha que a entrada sempre seja válida. Por exemplo, um quadro inválido seria "/ 8", "XX", "123", "0" etc.
• Você não precisa se preocupar com divisões ou faltas.
• Seu código pode ser um programa completo ou uma função que recebe uma string e retorna a pontuação.
• Seu código não deve gerar nenhuma exceção.
• Isso é código de golfe, a resposta com o menor número de bytes ganha.
• Os idiomas que usam inclusões ou importações devem incluir as instruções de importação como parte de seu código e contar para a contagem de bytes.

Casos de teste

"-- 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

Experimente online!

Explicação

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>

Como funciona

Convertemos cada caractere ao seu ponto:

• 'X' vale 30 pontos
• '/' vale 10 pontos
• '1' .. '9' vale 1 .. 9 pontos
• outros personagens vale 0 ponto

Em seguida, some todos os pontos.

Converter

O operador OR bit a bit |converte seu operando em Int32 antes de operar. Ao converter para Int32, o valor primeiro converte para o formato Número (número flutuante de 64 bits), depois faz o tronco para Int32 (ou convertido para 0 se inválido).

• ToInt32({'/':10,X:30}[c]) pode ser lido como:
  • se c == '/': resultado é 10;
  • se c == 'X': resultado é 30;
  • caso contrário: o resultado é ToInt32(undefined)-> ToInt32(NaN)-> 0;
• ToInt32(c) poderia ser:
  • se c == '1' ... '9': o resultado é 1 .. 9;
  • se c == '': Number(c)é 0, o resultado é 0;
  • caso contrário: Number(c)is NaN, result é 0;
• Bit a bit ou aqui é o mesmo que "add", pois um de seus operandos será 0

Soma

• [c,...s] = sdeixe c = s[0], e s = s.slice(1);
  • se s é uma string vazia, c é indefinido ;
  • caso contrário, c é a primeira letra de s
• undefined for false, string não vazia (incluindo espaço) é verdadeira

Stax , 13 bytes

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

Execute e depure

Descompactado, não destruído, e comentou que é assim.

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)

Execute este

Python 2 , 55 bytes

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

Experimente online!

Baseado na abordagem do índice de string de muitas soluções.

Java 8, 64 59 46 bytes

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

-5 bytes graças a @Neil .
-13 bytes graças a @ OlivierGrégoire .

Explicação:

Experimente online.

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 #, 106 103 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

Experimente online!

Eu acho que esse quebra-cabeça (sem o golfe) seria uma ótima pergunta para um guia de "Programação funcional para iniciantes". E eu deveria saber!

-3 de Kevin Cruijssen, por descobrir que o espaço em branco entre 'e "então" pode ser excluído. Obrigado!

A solução Stax da recursiva de usar índices de string é muito, muito boa. Se você o portar para F #, poderá obtê-lo por 77 bytes :

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

Experimente isso online!

Gelatina , 17 bytes

ḟ⁾ -“X0/⁵”yV€o30S

Um link monádico que aceita uma lista de caracteres e retorna um número inteiro

Experimente online!

Quão?

ḟ⁾ -“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

Também aos 17 anos:

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

Tente isso

Perl 6 , 30 bytes

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

Experimente online!

Retina , 17 bytes

X
///
/
55
\d
*
_

Experimente online!

Não estou muito atualizado sobre as alterações mais recentes da Retina. Vou olhar mais neles quando tiver uma chance e ver se há novos truques para jogar isso. O código transforma todas as ocorrências em três sobressalentes, todas em dez pontos e, em seguida, todos os pontos no número correspondente de sublinhados. Em seguida, conta o número de sublinhados.

Perl 5 -pF , 30 27 bytes

-3 bytes graças ao Xcali

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

Experimente online!

05AB1E , 14 bytes

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

Experimente online!

Explicação

þ`              # 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.]

Experimente online!

Explicação:

] a entrada

('-123456789',20 1#'/X')acrescenta 20 /e um Xà sequência-123456789

i. localiza os índices da entrada na string acima

31|módulo 31 - para se livrar dos espaços - eles não são encontrados na string, então i.retorna 31 para eles

1#. encontra a soma dos índices

Python 2 , 67 bytes

-3 bytes graças a @KevinCruijssen

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

Experimente online!

Gelatina , 12 bytes

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

Experimente online!

Como 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))

Experimente online!

Kotlin , 50 bytes

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

Experimente online!

Espero que não seja contra as regras responder à sua própria pergunta, mas eu queria participar da diversão.

Math.Eproduz o valor 2.718281828459045. Estou usando-o para criar alguma string de preenchimento para empurrar X para a posição 30.

indexOfobtém a posição (com base em 0) do caractere na sequência "12345 ...". Se não for encontrado, ele retornará -1. Nós adicionamos 1 para fazer esses 0, e isso também torna a posição baseada em 0 no valor da string.

PHP, 119 109 bytes

-10 bytes graças 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;

Experimente online!

Carvão , 23 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

  Ｅχ                    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

Vermelho , 93 bytes

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

Experimente online!

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)

Experimente online!

C # (compilador interativo do Visual C #) , 53 bytes

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

Experimente online!

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

Experimente online!

	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%)

Experimente online!

Ao reducepassar por uma String, cada caracter é realmente convertido em um caracter - quem teria pensado. Mas isso significa que tenho que escrever \spacee isso dói mais do que se pode imaginar. Além disso, ao criar um número real a partir de um caractere, a combinação de biginte strparece ser a única combinação utilizável.

Bem, além de todas essas lutas: função anônima que retorna a pontuação como natural.

Ruby , 38 bytes

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

Experimente online!