Greed Kata–First attempt

I’ve had this on my TODO list since this year’s CodeMash conference. If you’re not already familiar with the Greed kata, or kata’s in general, take a moment and read the article on Steve Gentile’s site. You can also take a look at his solution.

For my first attempt, I made an effort to stay away from Linq. I had no specific reason for this additional constraint. I was really just curious how the solution would turn out. So with that lead-in, here’s my first attempt:

   1: public class Scorer

   2: {

   3:     public int Compute(int[] diceValues)

   4:     {

   5:         if (0 == diceValues.Length) return 0;

   6:  

   7:         Dictionary<int, int> valueGroups = GroupByDiceValue(diceValues);

   8:  

   9:         int totalScore = 0;

  10:         foreach (KeyValuePair<int, int> group in valueGroups)

  11:         {

  12:             totalScore += ScoreGroup(group.Value, group.Key);

  13:         }

  14:         

  15:         return totalScore;

  16:     }

  17:  

  18:     private int ScoreGroup(int count, int value)

  19:     {

  20:         int groupScore = 0;

  21:         if (count>=3)

  22:         {

  23:             if (value == 1) groupScore += 1000;

  24:             else groupScore += value * 100;

  25:  

  26:             count -= 3;

  27:         }

  28:             

  29:         if (1 == value)

  30:         {

  31:             groupScore += count * 100;

  32:         }

  33:             

  34:         if (5 == value)

  35:         {

  36:             groupScore += count * 50;

  37:         }

  38:         return groupScore;

  39:     }

  40:  

  41:     private Dictionary<int, int> GroupByDiceValue(int[] diceValues)

  42:     {

  43:         Array.Sort(diceValues);

  44:         var valueGroups = new Dictionary<int, int>();

  45:         foreach (int value in diceValues)

  46:         {

  47:             int count = 0;

  48:             valueGroups.TryGetValue(value, out count);

  49:             valueGroups[value] = ++count;

  50:         }

  51:         return valueGroups;

  52:     }

  53: }

And here are the tests:

   1: [TestFixture]

   2: public class ScorerTests

   3: {

   4:     

   5:     [Test]

   6:     public void Compute_WhenNoValues_Score_0()

   7:     {

   8:         var scorer = new Scorer();

   9:         Assert.That(scorer.Compute(new int[]{}), Is.EqualTo(0));

  10:     }

  11:  

  12:     [Test]

  13:     public void Compute_ThreeOnes_Score_1000()

  14:     {

  15:         var scorer = new Scorer();

  16:         Assert.That(scorer.Compute(new int[] {1,1,1,2,3}), Is.EqualTo(1000));

  17:     }

  18:  

  19:     [Test]

  20:     public void Compute_ThreeTwos_Score_200()

  21:     {

  22:         var scorer = new Scorer();

  23:         Assert.That(scorer.Compute(new int[] { 3, 2, 2, 2, 3 }), Is.EqualTo(200));

  24:     }

  25:  

  26:     [Test]

  27:     public void Compute_ThreeThreess_Score_300()

  28:     {

  29:         var scorer = new Scorer();

  30:         Assert.That(scorer.Compute(new int[] { 4, 4, 3, 3, 3 }), Is.EqualTo(300));

  31:     }

  32:  

  33:     [Test]

  34:     public void Compute_ASingleOne_Score_100()

  35:     {

  36:         var scorer = new Scorer();

  37:         Assert.That(scorer.Compute(new int[] { 4, 4, 1, 2, 2 }), Is.EqualTo(100));

  38:     }

  39:  

  40:     [Test]

  41:     public void Compute_ASingleFive_Score_50()

  42:     {

  43:         var scorer = new Scorer();

  44:         Assert.That(scorer.Compute(new int[] { 4, 4, 5, 2, 2 }), Is.EqualTo(50));

  45:     }

  46:  

  47:     [Test]

  48:     public void Compute_FourOnes_Score_1100()

  49:     {

  50:         var scorer = new Scorer();

  51:         Assert.That(scorer.Compute(new int[] { 1, 1, 1, 1, 2 }), Is.EqualTo(1100));

  52:     }

  53:  

  54:     [Test]

  55:     public void Compute_ThreeOnesAndTwoFives_Score_1100()

  56:     {

  57:         var scorer = new Scorer();

  58:         Assert.That(scorer.Compute(new int[] { 5, 5, 1, 1, 1 }), Is.EqualTo(1100));

  59:     }

  60:  

  61:     [Test]

  62:     public void Compute_ThreeThreesAndOneFives_Score_350()

  63:     {

  64:         var scorer = new Scorer();

  65:         Assert.That(scorer.Compute(new int[] { 4, 5, 3, 3, 3 }), Is.EqualTo(350));

  66:     }

  67:  

  68:     [Test]

  69:     public void Compute_NoValidScoringCombinations_Score_0()

  70:     {

  71:         var scorer = new Scorer();

  72:         Assert.That(scorer.Compute(new int[] { 2, 2, 4, 4, 3 }), Is.EqualTo(0));

  73:     }

  74:  

  75: }

I’m not unhappy with the solution but the voice in my head is nagging me that I’m missing something obvious.