Casey West

In November I got together with Tom Moertel and Chris Winters at a coffee shop in Mt. Lebanon (Aldo, sorry, you were closed). The premise was to solve the Bowling Game Kata in Haskell. Tom has already completed this on his own, but we sat down to give it a shot together. Our attempt together follows:

module Bowling where

type FrameScore  = Int
type FrameRolls  = [Int]
type FrameNumber = Int

data FrameType = Strike | Spare | Normal | Ten
deriving (Show, Eq)

data FrameInfo = Frame FrameScore FrameRolls FrameNumber FrameType
deriving (Show)

score :: [Int] -> Int
score = scoreFrames . parseFrames 1

parseFrames :: Int -> [Int] -> [FrameInfo]
parseFrames n (x:y:zs)
| n == 10       = Frame (sum (x:y:zs)) (x:y:zs) n Ten : []
| x == 10       = Frame 10 (x:[]) n Strike      : parseFrames (n + 1) (y:zs)
| (x+y) == 10   = Frame 10 (x:y:[]) n Spare     : parseFrames (n + 1) zs
| otherwise     = Frame (x+y) (x:y:[]) n Normal : parseFrames (n + 1) zs

getTwo :: [FrameInfo] -> [Int]
getTwo = take 2 . unrollFrames

getOne :: [FrameInfo] -> [Int]
getOne = take 1 . unrollFrames

unrollFrames :: [FrameInfo] -> [Int]
unrollFrames [] = []
unrollFrames ((Frame _ (xs) _ _) : ys) = xs ++ unrollFrames ys

scoreFrames :: [FrameInfo] -> Int
scoreFrames ((Frame s _ n t) : xs)
| n == 10       = s
| t == Strike   = sum (s : getTwo xs ++ scoreFrames xs : [])
| t == Spare    = sum (s : getOne xs ++ scoreFrames xs : [])
| otherwise     = sum (s : scoreFrames xs : [])

That’s rather long winded, especially compared to Tom’s version which is short and elegant. I went home that night and created an alternate short and elegant version:

module TinyBowling where
score           = c 1
a n  rs         = sum $ take n rs
c 10 rs         = a 3 rs
c f  rs         = s (f+1) rs
s f  (10:rs)                = a 3 rs + c f rs
s f  (x:y:rs)   | (x+y)==10 = a 3 rs + c f rs
| otherwise = a 2 rs + c f rs

I was reviewing this code tonight and discovered that I’d really like to create a short and elegant Perl version. I gave it a shot but I’m not pleased at all. In this round of Golf I think Haskell wins on elegance, hands down:

package Bowling;
sub score { c(1, 0, @_) }
sub c {
my ($f, $s, @rs) = @_;
my ($x, $y, @zs) = @rs;

return $s                            if $f > 10;
return _c($f, $s, 2, \@rs, [@zs]   ) if !($x && $y);
return _c($f, $s, 3, \@rs, [$y,@zs]) if $x == 10;
return _c($f, $s, 3, \@rs, [\@zs]  ) if $x + $y == 10;
}
sub _c {
my ($f, $s, $n, $rs, $zs) = @_;
c($f+1, eval(join '+',$s,map $_||0, @{$rs}[0..$n-1]), @{$zs});
}

This entry was posted on Tuesday, December 19th, 2006 at 9:27 pm and is filed under Ruminations. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.