Greed Dice Game Scoring from Ruby Koans

Ruby
1

Hey everyone! I’m a long-time lurker, and this is my first post. I’m
working through the Edgecase Ruby Koans (http://www.rubykoans.com/), and
have written a solution to scoring the game of dice called “greed.”
However, while it passes all the assertion tests, I am wondering if my
code
is sufficiently “Rubyesque”? I appreciate any and all feedback!

Greed is a dice game where you roll up to five dice to accumulate

points. The following “score” function will be used calculate the

score of a single roll of the dice.

A greed roll is scored as follows:

* A set of three ones is 1000 points

* A set of three numbers (other than ones) is worth 100 times the

number. (e.g. three fives is 500 points).

* A one (that is not part of a set of three) is worth 100 points.

* A five (that is not part of a set of three) is worth 50 points.

* Everything else is worth 0 points.

Examples:

score([1,1,1,5,1]) => 1150 points

score([2,3,4,6,2]) => 0 points

score([3,4,5,3,3]) => 350 points

score([1,5,1,2,4]) => 250 points

More scoring examples are given in the tests below:

Your goal is to write the score method.

def score(dice)

total = 0

dice.uniq.each do |num|

if num == 1

  if dice.count(1) >= 3

    total += 1000

    total += 100 * (dice.count(1) - 3)

  else

    total += 100 * dice.count(1)

  end

elsif num == 5

  if dice.count(5) >= 3

    total += 5  * 100

    total += 50 * (dice.count(5) - 3)

  else

    total += 50 * dice.count(5)

  end

else

  total += num * 100 if dice.count(num) >= 3

end

end

total

end

2

On 09/12/11 09:11, Nate Lindstrom wrote:

points. The following “score” function will be used calculate the

score([1,5,1,2,4]) => 250 points

     total += 1000

   end

end

This is quite a fun exercise, and interesting to see what people come up
with. The only suggestion I have is that you can gain a lot of economy
by ‘baking’ the score values from the getgo. If the rules of the game
ever changed (you could roll more dice, or the score values changed),
there would be a lot less stuff to have to fiddle. This seems to pass
the tests.

def score(dice)

#============================================================================

This bit bakes the scores on first invocation

#============================================================================
@greed_scores ||= (Hash.new { |h, k|
h[k] = {:singles=>0, :triples=>k*100}
}).merge!({1=>{:singles=>100, :triples=>1000}, 5=>{:singles=>50,
:triples=>500}})

#============================================================================

This bit does the actual scoring

#============================================================================
score = 0
dice.uniq.each { |n|
triples, singles = dice.count(n).divmod(3)
score += (@greed_scores[n][:singles] *
singles)+(@greed_scores[n][:triples] * triples)
}
score

#============================================================================
end

Sam