Pontuação no boliche de dez pinos - World Bowling edition

20

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
code-golf string number arithmetic parsing Makotosan
fonte
21
Estou desapontado este não é um desafio-boliche código
Jo rei
13
Seu primeiro exemplo reserva diz que a pontuação seria 13, mas acho que deveria ser 17.
Jo.
@Jo. Boa pegada. Atualizei a pergunta para corrigir esse erro.
26518 Makotosan
@JoKing Eu estava pensando que este é um desafio de boliche de código composto por 10 sub-desafios quando vi o título pela primeira vez.
Weijun Zhou
1
Um dos melhores desafios documentados e escritos que já vi.
27718 Joshua

Respostas:

7

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)
Adnan
fonte
7

JavaScript, 43 bytes

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

Mostrar snippet de código

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
tsh
fonte
1
Você pode explicar seu código? parece muito bom
Luis felipe De jesus Munoz
@LuisfelipeDejesusMunoz Acabou de adicionar alguns.
tsh
5

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

recursivo
fonte
3

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.

xnor
fonte
3

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
Kevin Cruijssen
fonte
1
("123456789//"+1e6+1e6+"X")parece economizar 5 bytes.
315 Neil
Essa é uma técnica inteligente para criar algumas strings de preenchimento.
precisa saber é o seguinte
1
46 bytes
Olivier Grégoire
3

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!

Ciaran_McCarthy
fonte
1
Eu não sei muito bem o F #, mas parece que você pode soltar os espaços depois 'por -3 bytes.
Kevin Cruijssen 26/03
Nem eu! Mas você está certo, bem avistado! Obrigado!
Ciaran_McCarthy 26/03
2
@Ciaran_McCarthy: Não me importo se você copiar minha solução, se quiser incluí-la também. As pessoas aqui geralmente são bastante abertas sobre esse tipo de coisa. É um esforço cooperativo para encontrar todo o menor código, mesmo que seja formalmente uma competição.
recursivo
1
Obrigado recursivo. Vou incluí-lo então, porque é uma solução muito boa e é interessante ver como fica em diferentes idiomas.
Ciaran_McCarthy 26/03
2

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

Jonathan Allan
fonte
2

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.

PunPun1000
fonte
2

Perl 5 -pF , 30 27 bytes

-3 bytes graças ao Xcali

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

Experimente online!

Ton Hospel
fonte
Você pode cortar dois bytes usando em /X/vez de y/X//e mais um usando em m%/%vez de y%/%%: Experimente online!
Xcali 26/03
@Xcali Ah, é claro. Visão curta de golfe clássica, eu ainda pensava em termos de y///quando as fiz fora de um circuito. Graças
Ton Hospel
1

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
Kaldo
fonte
1

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

Galen Ivanov
fonte
Como J e Red são dois idiomas completamente diferentes, é melhor postar duas respostas separadas, mesmo que elas possam fazer o mesmo. Você pode adicionar um link da resposta vermelha para esta resposta J, afirmando que é uma porta da sua resposta J.
Kevin Cruijssen 26/03
@Kevin Cruijssen - Ok, obrigado - eu vou fazer isso. A razão para publicá-las em conjunto é que, obviamente, a solução Red não é competitivo (embora muito legível :))
Galen Ivanov
1

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!

Gambá morto
fonte
1
Você pode salvar 3 bytes mudando '-123456789'+'/'*20+'X':sum(p.index(i)para'-123456789/'+'X'*20:sum(p.rfind(i)
Kevin Cruijssen
@KevinCruijssen thanks, good one!
Gambá morto
1

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.
Dennis
fonte
1

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.

Makotosan
fonte
1

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!

Jo.
fonte
Você pode mudar ($b=='/'?10+(int)$a:((int)$a+(int)$b))a (int)$a+($b=='/'?10:(int)$b)para -10 bytes.
Kevin Cruijssen 26/03
@KevinCruijssen Obrigado, parece ser bom! Embora, olhando para as outras respostas, pareça que estou fazendo isso da maneira errada / longa. :)
Jo.
0

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
Neil
fonte
0

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
Giuseppe
fonte
0

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.

Joshua
fonte