您的任务是在最多 21局掷骰后，在 10针保龄球游戏中总结并输出一个球员的得分。

在您首选的输入法中，滚动表示为整数序列。每个整数对应于该卷中被击倒的引脚数。

计分

每回合之后，该回合中击倒的针脚数量将计入最终得分。如果玩家在第一回合中击倒所有十个别针，则为罢工，此回合结束。否则，该回合将继续进行一轮。如果第二回合击倒所有剩余的销，则这是备用的。

对于每次打击，都有一笔奖金，等于在接下来的两次掷骰中击倒的针脚的总和。对于每个备用零件，都具有等于下一轮击倒的销子数量的奖金。

在第10轮也是最后一轮，可能会给予玩家额外的掷骰：如果有罢工，则玩家会获得另外2个掷骰来弥补其罢工奖励。如果有备用的话，玩家还会获得一掷。

例子

Input: 4 3 8 2 7 1 10 7 3 0 10 2 2 10 10 5 4
Output: 131

Input: 10 10 9 1 7 3 2 7 10 1 9 10 7 1 10 10 10
Output: 183

规则

• 您可能假设输入有效。
• 根据Mego的评论，我放宽了对输入/输出方法的要求，以满足我们目前的标准。
• 允许使用比挑战新的语言进行回答
• 最短的代码胜出！

GolfScript，50个 41个字符

~0]-1%~0{\.9>{+1$3$}{@+.9>3$*}if++}10*p];

GolfScript中的另一种尝试（在线运行）。

代码说明如下。该解决方案利用了问题的堆栈性质（一个接一个地消耗卷），因此必须颠倒输入。

~0          # Take the input and evaluate to single numbers on the stack. Add zero.
]-1%~       # Reverse the stack (make array, reverse array, dump array)

0           # Start with a sum of zero
{           # Perform this block 10 times (once for each round)
  \         #   Take the next roll
  .9>{      #   If it is a strike
    +       #     Add the value of the roll to the sum
    1$3$    #     and duplicate top two members of the stack (i.e. next two rolls).
  }{        #   ... else ...
    @+      #     Take the next roll and add with first roll in round.
    .9>     #     Does this sum show a spare?
    3$*     #     Get next roll (potential bonus) and multiply with yes/no.
            #     Since we pushed an additional 0 in the beginning 
            #     there is a spare roll even for the last round.
  }if       #   endif
  ++        #   Add top three stack entries together
            #   (i.e. sum+2 bonus rolls for strike, sum+rolls+bonus else)
}10*        # Loop ten times

p];         # Sum is top of stack. Print sum and discard any leftover rolls.

先前版本：

~].1>.1>]zip{((.10<{@(0=@+@1>1$9><}*@}10*;]{+}.@**

Python中，116 110 105 103 100 99个字符

z=map(int,raw_input().split())
s=0
exec('s+=sum(z[:2+(z[0]+z[1]>9)]);z=z[2-(z[0]>9):];'*10)

在输入上花费30个字符令人讨厌。欢迎提出建议。

非常感谢霍华德所做的改进。

R，101个字节

我不确定为什么要挑战这个挑战，但是我喜欢它，所以无论如何我都会迟到。

f=function(x,s=0,c=10)`if`(c&length(x),f(x[-(0:(x[1]!=10)+1)],sum(x[1:(2+(sum(x[1:2])>9))])+s,c-1),s)

在线尝试！

取消高尔夫：

f <- function(throws, score = 0, count = 10){
  if(count != 0 & length(throws) != 0){
    IsStrike <- throws[1] == 10
    IsStrikeOrSpare <- sum(throws[1:2]) >= 10
    f(throws[-c(1, 2 * !IsStrike)],
      score + sum(throws[c(1:(2 + IsStrikeOrSpare))]),
      count - 1)
  } else {
    return(score)
  }
}

递归函数。取x作为输入，其保持分数。初始化s核心并c增加掷出的回合数量。

if语句检查是否抛出10回合，或者是否x为空。在这种情况下，将返回分数。否则，该函数将自己调用如下：

它x通过检查是否是罢工来从中删除罚球。如果是这样，则删除第一个条目，否则删除前两个条目。(S=x[1]!=10)检查罢工。我们删除（-）index 0:S，S如果是罢工，则为1，否则为0。然后添加一个：-(0:(x[1]!=10)+1)。我们将缩短x的呼叫传递给下一个呼叫。

至于比分，可以通过x[1:2]是否是常规回合，x[1:3]是罢工还是备用来确定。我们检查是否sum(x[1:2])大于或等于10。如果是罢工，显然是这种情况。如果是备用的，那么也可以。因此，如果这是TRUE，我们将加x[3]和。然后将其添加到中s。

CoffeeScript的（234 215 170）

z=(a)->b=(Number i for i in a.split(' ').reverse());t=0;(r=b.pop();l=b.length;if(9<r)then(t+=r;t+=b[l-1]+b[l-2];)else(f=r+b.pop();t+=f;(t+=b[l-2])if 9<f))for i in[0..9];t

编辑：大量重写，毫不掩饰地抄袭了霍华德基于堆栈的出色方法。我相信可以删除更多用于访问数组的最后一个元素而不破坏它...

Ruby，252个字节

接受输入到数组中的输入，首先添加所有元素，然后搜索备用和罢工奖励

s,p,t,r=0,0,1,1
o=ARGV
o.each_with_index do |m,n|
y=m.to_i
s+=y
if r<10
p+=y
if p==10&&t==1
r,p=(r+1),0
s+=o[n+1].to_i+o[n+2].to_i
elsif p<10&&t==1
t=2
elsif p<10&&t==2
t,p,r=1,0,(r+1)
elsif p==10&&t==2
t,p,r=1,0,(r+1)
s+=o[n+1].to_i
end end end
puts s

PHP，82字节

for($a=$argv;$r++<10;$i+=$p<10)$s+=(9<$q=$a[++$i+1]+$p=$a[$i])*$a[$i+2]+$q;echo$s;

从命令行参数获取输入；在线运行-nr或测试。

分解

for($a=$argv;       # import arguments
    $r++<10;        # loop through rounds
    $i+=$p<10)          # 6. if no strike, increment throw count again
    $s+=(9<
        $q=$a[++$i+1]+  # 1. increment throw count  2. $q=second throw plus
        $p=$a[$i]       # 3. $p=first throw
        )*$a[$i+2]      # 4. if $q>9 (strike or spare), add third throw to sum
    +$q;                # 5. add first and second throw to sum
echo$s;             # print sum

Perl 5、65 + 2 = 67字节

需要-ap标志

$\+=(($"=shift@F)<10?$"+=shift@F:10+$F[1])+$F[0]*(9<$")for 0..9}{

在线尝试！

果冻， 36  35 字节

+\µi©⁵+Ị$ḂḤị;®×Ị¤¡-
;0Ç3ƤFṣ-m€2Fḣ⁵S

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

在线尝试！

怎么样？

计算三个碗的每一次重叠运行的得分，就好像它是从一帧的开始处开始的，并可选地附加一个罢工标识符（-1），展平此结果列表，将其拆分为罢工标识符，然后丢弃第二个结果每个块（删除那些并非真正从帧的开头开始的跑步得分）。

为了满足最后一帧的要求，首先将零添加到输入中（以允许进行3向切片，以使帧可以从倒数第二个碗开始），然后将所得的分数截断为前十个（删除当前的分数）。可能会在第11帧之前伪造）。

+\µi©⁵+Ị$ḂḤị;®×Ị¤¡- - Link 1, threeBowlEvaluate: list, bowlScores
                    -               e.g. [0,4,6]   [9,1,10]   [0,4,4]  [10,7,9]
 \                  - cumulative reduce with:
+                   -   addition         [0,4,10]  [9,10,20]  [0,4,8]  [10,17,26]
  µ                 - monadic chain separation, call that "left"
     ⁵              - literal ten        10        10         10       10
   i                - first index in left 3         2 (spare)  0        1 (strike)
    ©               - (copy to register for later reuse)
        $           - last two links as a monad (f(x)):
       Ị            -   abs(x) <= 1       0         0          1        1
      +             -   add x             3         2          1        2
         Ḃ          - modulo by 2         1         0          1        0
          Ḥ         - double              2         0          2        0
           ị        - index into left (both 1-indexed and modular)
                    -            ...      4        20          4       26
                  - - literal -1         -1        -1         -1       -1
                 ¡  - repeat:
            ;       - ...action: concatenate
                ¤   - ...number of times: nilad followed by link(s) as a nilad:
             ®      -   z from register   3         2          0        1
               Ị    -   abs(z) <= 1       0         0          1        1
              ×     -   multiply          0         0          0        1 (strike)
                    - ...yielding:        4         20         4        [26,-1]

;0Ç3ƤFṣ-m€2Fḣ⁵S - Main link: list bowlValues
                -                    e.g. [4,3,8,2,7,1,10,7,3,0,10,2,2,10,10,5,4]
 0              - literal zero            0
;               - concatenate             [4,3,8,2,7,1,10,7,3,0,10,2,2,10,10,5,4,0]
   3Ƥ           - for infixes of length 3:
  Ç             -   last link (1) as a monad
                -                         [7,11,17,9,8,11,[20,-1],10,3,12,[14,-1],4,12,[25,-1],[19,-1],9]
     F          - flatten                 [7,11,17,9,8,11,20,-1,10,3,12,14,-1,4,12,25,-1,19,-1,9]
       -        - literal -1              -1
      ṣ         - split at                [[7,11,17,9,8,11,20],[10,3,12,14],[4,12,25],[19],[9]]
          2     - literal two             2
        m€      - modulo slice for €ach   [[7,17,8,20],[10,12],[4,25],[19],[9]]
           F    - flatten                 [7,17,8,20,10,12,4,25,19,9]
             ⁵  - literal ten             10
            ḣ   - head to index           [7,17,8,20,10,12,4,25,19,9] (no effect this time)
              S - sum                     131

Perl，140吗？

第一次尝试：

#!/usr/bin/perl
# usage: ./bowling.pl [list of scores]

@A=@ARGV;{last if(9<$n++);$a=shift@A;$S+=$a;($S+=$A[0]+$A[1])&redo if($a==10);$b=shift@A;$S+=$b;($S+=$A[0])&redo if(10==$a+$b);redo}print$S

可悲的是，在某些情况下它会失败。我会稍后重做。