Score a game of Bowling

Your task is to sum up and output one player's score in a game of 10-pin bowling after up to 21 rolls.

The rolls are represented as space separated integers on a single line of input. Each integer corresponds to the number of pins that were knocked down in that roll.

Scoring

After each round the number of pins knocked down in that round is counted into the final score. If a player knocks down all ten pins in the first roll of a round, this is a strike, and the round is over. Otherwise, the round lasts for one more roll. If the second roll of a round knocks down all the remaining pins, this is a spare.

For each strike there is a bonus equal to the sum of pins knocked down in the two next rolls. For each spare there is a bonus equal to the numer of pins knocked down in the next roll.

The 10th and final round, the player may be granted extra rolls: In case of a strike, the player gets two more rolls to make up his strike bonus. In case of a spare, the player gets one more roll.

Examples

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

Shortest code wins!

-
 Shouldn't the score for game 1 be 126? – David Carraher Oct 8 '12 at 0:37 @DavidCarraher Actually, now I get 7+17+8+20+10+12+4+25+19+9 = 131. – Daniero Oct 8 '12 at 1:16 Yes, I double checked. 131. – David Carraher Oct 8 '12 at 1:19

GolfScript, 50 41 characters

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

Another attempt in GolfScript (run it online).

An explanation of the code follows. The solution utilises the stack nature of the problem (consume rolls one after another) but therefore the input has to be reversed.

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

{           # 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.
``````

Previous version:

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

Python, 116110105103100 99 characters

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

Spending 30 characters on input is irksome. Suggestions welcome.

Much thanks to Howard for improvements.

-
 You may replace `1+(z[i]!=10)` with `2-(z[i]>9)` to save one char. – Howard Oct 10 '12 at 20:44 @Howard: Excellent suggestion. I have incorporated it into my answer. It saved two characters. – Steven Rumbalski Oct 10 '12 at 20:51 And two more if you remove `i` completely (set to 0) and instead of `i+=...` use `z=z[2-(z[0]>9)::];` – Howard Oct 10 '12 at 20:53 @Howard: Thanks again. Saved three characters. – Steven Rumbalski Oct 10 '12 at 21:02

CoffeeScript (234215 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
``````

EDIT: A hefty re-write, shamelessly plagiarising Howard's great stack-based approach. I'm confident more can be stripped out for accessing the last element of an array without destroying it...

-

Perl, 140?

First attempt:

``````#!/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
``````

Sadly, there are certain cases where it fails. I will come and redo it later.

-

Ruby

Accepts input into an array add all elements first Then searches for spare and strike bonus
``````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
``````
-