世界保龄球计分

许多人去了当地的保龄球中心打了几场保龄球，而且许多人仍在努力计算分数。世界保龄球馆引入了简化的计分系统，以吸引更多的人参加这项运动。该计分系统用于国际比赛。

计分系统的工作方式如下（来自Wikipedia）：

世界保龄球计分系统（称为“当前帧计分” [32]）按以下方式授予图钉：

• 罢工：30（无论随后的掷骰结果如何）
• 备用：当前帧的第一卷上有10多个掉落
• 打开：当前帧的总落差

如果您不熟悉十针保龄球，这里有个回顾。

保龄球道的尽头有10个插脚，目标是用保龄球将它们全部击倒。您得到2卷球来尝试将它们全部击倒，最好是在第一卷时将它们全部击落（称为打击）。如果确实有罢工，则说明该帧已经完成，您无需再次掷球。罢工价值30。

如果您没有全部淘汰十人，您将获得一卷。如果您击倒所有其余的引脚，则称为备用。得分价值10针+第一卷击倒的针数。例如，如果我击倒7个针脚，然后设法击倒其余3个针脚，那将值17。

如果在第二次掷骰后未能击倒全部十个骰子，则称为开架。得分值相当于该帧被击倒的引脚总数。

一个游戏中有10帧。如果您熟悉传统的保龄球计分，那么在第10帧中，World Bowling Scoring并不会增加您的得分。在传统的保龄球计分中，需要12次连续击球才能获得300分的完美分数，而世界保龄球计分仅需要连续10次击球。

挑战

您的挑战是从分数表中计算给定值的分数。

在得分表上，未命中用破折号（-），带X的罢工和带斜杠（/）的备用项表示。如果这些都不适用，那么落下数量将简单地用数字（1-9）表示。犯规和分裂也会记录在得分表上，但是您不必担心这些。

输入项

系统会为您提供一个字符串，其中包含每帧的乐谱，总共有10帧。每个帧最多可以有两个值，如果有罢工，则每个帧将只有1个值。您的输入可能是函数的字符串参数，是从文件中还是从STDIN中读取的。

例如，如果我在第一卷上按了1个销，然后按了2个，则框架看起来像“ 12”。这并不意味着12（十二），而是意味着1和2，总计为3。

如果我错过了两个滚子（装订线球）的每个销钉，它将看起来像这样的“-”（0分）。

每个帧将由一个空格分隔。

样品输入

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

为了分解这个例子，

• 框架1（-）-两个投掷都错过了。得分0
• 帧2（9-）-第一局9落败，第二局错过。得分9
• 赛局3（-9）-第一局全败，第二局9分。得分9
• 赛局4（X）-强袭，淘汰了全部10人。得分30
• 框架5（-/）-备用，第一个错过全部，第2个落下全部失败。得分10 + 0 = 10
• 框架6（8 /）-备用，第一卷上有8根针，第二卷上的另一根被击倒。得分10 + 8 = 18
• 框架7（71）-打开框架，第一卷上有7针，第二卷上有1针。得分7 + 1 = 8
• 框架8,9,10遵循与上述相同的示例。

输出量

输出将只是一个具有所有10帧得分总和的值。使用样本输入，输出将为128。您的输出可以是字符串或数字类型。它可以是函数返回值，也可以写入STDOUT。

规则

• 假设输入将始终有效。例如，无效的帧将是“ / 8”，“ XX”，“ 123”，“ 0”等。
• 您无需担心分裂或犯规。
• 您的代码可以是完整的程序，也可以是接受字符串并返回分数的函数。
• 您的代码不得引发任何异常。
• 这是代码高尔夫，以最少的字节数获胜。
• 使用包含或导入的语言必须将导入语句作为其代码的一部分包含在内，并计入字节数。

测试用例

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

码

S'/T:'X30: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个字节

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>

怎么运行的

我们将每个字符转换为其点：

• 价值30分的“ X”
• '/'得10分
• '1'..'9'相当于1 .. 9点
• 其他价值0分的角色

然后加总所有点。

兑换

在进行运算之前，按位或运算符|会将其操作数转换为Int32。转换为Int32时，值首先转换为Number（64位浮点数）格式，然后转换为Int32（或如果无效则转换为0）。

• ToInt32({'/':10,X:30}[c]) 可以理解为：
  • 如果c =='/'：结果为10；
  • 如果c =='X'：结果是30;
  • 否则：结果是ToInt32(undefined)-> ToInt32(NaN)-> 0;
• ToInt32(c) 可能：
  • 如果c =='1'...'9'：结果为1 .. 9;
  • 如果c ==''：Number(c)为0，则结果为0;
  • 否则：Number(c)是NaN，结果为0；否则为0。
• 按位或此处与“加”相同，因为其操作数之一为0

和

• [c,...s] = s让c = s[0]和s = s.slice(1);
  • 如果s为空字符串，则c为undefined；
  • 否则，c是s的首字母
• undefined是虚假的，非空字符串（包括空格）是真实的

Stax，13 个字节

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

运行并调试

因此，请打开包装，取消包装并发表评论。

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)

运行这个

Python 2，55个字节

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

在线尝试！

基于许多解决方案的字符串索引方法。

Java 8，64 59 46字节

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

-5个字节，感谢@Neil。
-13个字节，感谢@OlivierGrégoire。

说明：

在线尝试。

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字节

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

在线尝试！

我认为这个难题（不打高尔夫球）对于“初学者的功能编程”指南将是一个很大的问题。我应该知道！

Kevin Cruijssen的-3，因为发现'和'then'之间的空格可以删除。谢谢！

递归的使用字符串索引的Stax解决方案非常好。如果将其移植到F＃，则可以获得77个字节：

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

在线尝试！

果冻，17 个字节

ḟ⁾ -“X0/⁵”yV€o30S

接受字符列表并返回整数的单子链接

在线尝试！

怎么样？

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

同样在17：

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

试试看

Perl 6，30个字节

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

在线尝试！

视网膜，17字节

X
///
/
55
\d
*
_

在线尝试！

我不太了解最新的Retina更新。如果有机会，我将对它们进行更多研究，看看是否有任何新的技巧可以使高尔夫球运动下降。该代码将所有的罢工变为三个备用项，所有备用项均分为十个点，然后所有点均变为对应的下划线数量。然后，它计算下划线的数量。

Perl 5中 -pF，30 27个字节

-3字节归功于Xcali

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

在线尝试！

05AB1E，14个字节

þ`I…/aXS¢ƶT*`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个字节

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

在线尝试！

说明：

] 输入

('-123456789',20 1#'/X')在字符串后附加20 /和一个X-123456789

i. 在上面的字符串中找到输入的索引

31|模数31-摆脱空格-在字符串中找不到空格，因此i.为它们返回31

1#. 找到索引的总和

Python 2，67字节

-3个字节，感谢@KevinCruijssen

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

在线尝试！

果冻，12字节

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

在线尝试！

怎么运行的

⁾/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个字节

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

在线尝试！

Kotlin，50个字节

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

在线尝试！

希望回答您自己的问题不违反规则，但我想加入其中。

Math.E产生价值2.718281828459045。我使用它来创建一些填充字符串，以将X推到位置30。

indexOf获取字符串“ 12345 ...”中字符的位置（从0开始）。如果找不到，则返回-1。我们加1使其成为0，这也使从0开始的位置成为字符串的值。

PHP，119109字节

-10个字节，感谢@KevinCruijssen

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

在线尝试！

木炭，23字节

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

在线尝试！链接是详细版本的代码。说明：

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

红色，93字节

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

在线尝试！

C＃（.NET Core），40 + 18 = 58字节

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

在线尝试！

C＃（Visual C＃交互式编译器），53字节

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

在线尝试！

SNOBOL4（CSNOBOL4） ，169个 151 147字节

	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

在线尝试！

	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个字节

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

在线尝试！

当reduce遍历一个String时，每个字符实际上都会转换为一个字符-谁会想到的。但是，这是我的意思，我必须写这本书，\space这让人无法想象。同样，当从一个字符创建一个实际数字时，bigint和的组合str似乎是唯一可用的组合。

好吧，除了所有这些挣扎之外：匿名函数将分数自然返回。

Ruby，38个字节

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

在线尝试！