about_scoring_project.rb

require 'edgecase'


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

class AboutScoringAssignment < EdgeCase::Koan

  def score(dice)
    total_score = 0    
    [2,3,4,6].each do |number| 
      total_score += score_for_number(dice, number, number * 100, 0)
    end
    
    total_score += score_for_number(dice, 5, 500, 50)
    total_score += score_for_number(dice, 1, 1000, 100)
  end
  
  def score_for_number(dice, selection, value_of_triple, value_of_single)    
    selected = dice.select{|item| item == selection}
    three_or_more = selected.size >= 3
    remaining = three_or_more ? selected[3, selected.size] : selected
    remaining.inject(three_or_more ? value_of_triple : 0){|total, item| total + value_of_single}    
  end

  def test_score_of_an_empty_list_is_zero
    assert_equal 0, score([])
  end

  def test_score_of_a_single_roll_of_5_is_50
    assert_equal 50, score([5])
  end

  def test_score_of_a_single_roll_of_1_is_100
    assert_equal 100, score([1])
  end

  def test_score_of_mulitple_1s_and_5s_is_the_sum_of_individual_scores
    assert_equal 300, score([1,5,5,1])
  end

  def test_score_of_single_2s_3s_4s_and_6s_are_zero
    assert_equal 0, score([2,3,4,6])
  end

  def test_score_of_a_triple_1_is_1000
    assert_equal 1000, score([1,1,1])
  end

  def test_score_of_other_triples_is_100x
    assert_equal 200, score([2,2,2])
    assert_equal 300, score([3,3,3])
    assert_equal 400, score([4,4,4])
    assert_equal 500, score([5,5,5])
    assert_equal 600, score([6,6,6])
  end

  def test_score_of_more_than_triple_others_is_still_100x
    assert_equal 200, score([2,2,2,2])
    assert_equal 300, score([3,3,3,3,3])
    assert_equal 400, score([4,4,4,4])
    assert_equal 600, score([6,6,6,6])
  end

  def test_score_of_mixed_is_sum
    assert_equal 250, score([2,5,2,2,3])
    assert_equal 550, score([5,5,5,5])
    assert_equal 1100, score([1,1,1,1])
  end
end

Added the rules up to to give the code more context.

hi zach, what you have is very clean and certainly readable.

I don't do much ruby, but I do like thinking about algorithms. Reading through your code, it looks like you rely very heavily on the 'select' method, which may be doing more scans of your data than you need to. Ideally, you'd like to scan the entire list no more than twice. Once to sort the numbers, and another to calculate the score from that list.

My hastily conceived algorithm:

I would have reduced the list to a list of pairs. Each pair containing the die number and it's number of occurrences in the list.
That list could then further be reduced to a list of scores for each pair. And then those numbers could be reduced/summed to get a final score.

I'll take a crack at test-driving some code to illustrate over lunch.

@youngnh

Not sure I agree on the readable, but I do like your reduction-based algorithm idea.

@zeedunk

Per our earlier face-2-face discussion a few thoughts:

• The work done to setup for each call to score_for_number is a bit cumbersome (some are done via 'each', others are singular stand outs, and the need/use of each parameter isn't immediately clear looking just at the score function). Looking at the code w/o first reading ALL of the instructions meant I didn't immediately follow why the distinction was being made. It would be great if the difference in scoring schemes could be separated and all values iterated over in the same way.
• The score_for_number method itself seems a bit muddy. You really only need the number of each type of die, not the actual die values to calculate a score. This would also get rid of the need for the last inject replaced by a simple expression (possibly with a call to an integer flooring function)
• Other than that, thanks for putting this up.

@youngnh - Thanks for the feedback. I think that would certainly be a simplification and I'll start hacking on that as soon as I get a chance.

@benjaminplee - I agree that the code doesn't clearly express why five and one are special cases. Integrating that with Nate's suggestion will be a fun challenge. As far the last inject, well, I keep reaching for inject because it's my new favorite toy. :) You're right though, it is unnecessary there.

Thanks again guys!