Think in LINQ: Yahtzee Score Calculator Using LINQ Technology

LINQ Method:

Run a query on the dice collection that filters all die = nDie using a Where clause. Take the results of this query and call a Sum function to sum the matching die.

Listing 1 - Calculating matching Dice Rolls using LINQ

public int CalculateLikeRolls(int nDie, Dice[] dice) { // determine all the dice in the dice collection // that have the value of nDie var numberOfValues = from die in dice where die.RollNumber == nDie select die.RollNumber; // Add all the values which have value nDie together int sum = numberOfValues.Sum(); // add the sum to the total score and to the upper // score section m_nTotal += sum; m_nUpperTotal += sum; return sum; }

Although this isn't a large difference in the amount of code, it is a lot cleaner and brings us to a higher level of thinking about how we milk our collection data for useful information. Also, (as you'll see in the following yahtzee calculations), LINQ reduces our code by quite a bit.

Let's take a look at another yahtzee score: three of a kind. With three of a kind, if you have at least 3 of the same die value out of 5 die, you can sum the die together for the score and put it in the three of a kind column. How do we score this in code?

Old Method:

Somehow we need to determine which items in the collection are alike. One way to do this is to build a Hashtable containing a histogram of all 6 (1-6) die possibilities as keys. We increment each hash key each time a die matches that key. If one of the keys is equal to or greater than 3, then we loop through all the dice and sum them.

LINQ Method:

Group all the dice by like numbers and count them in a generated DieCount collection. Determine if there is Any group containing at least 3 dice. If so, Sum the dice. You can start to see how the solution to the problem more closely matches your thinking in the implementation of the solution.

Listing 2 - Calculating Three of A Kind using LINQ

public int CalculateThreeOfAKind (Dice[] myDice) { // group the die by dice number and keep a count of each group var groupCounts = from die in myDice group die.RollNumber by die.RollNumber into g select new {Category = g.Key, DieCount = g.Count()}; // determine if there is at least 3 dice in any group bool count3 = groupCounts.Any(dieGroup => dieGroup.DieCount >= 3); // if not, then there is no score if (count3 == false) return 0; // yes, we have three of a kind, sum all the dice int nTotal = SumAllDice(myDice); m_nTotal += nTotal; m_nLowerTotal += nTotal; return nTotal; }

Finally, let's look at how to score a large straight. A large straight is a set of 5 consecutive die values (either a roll of {1, 2, 3, 4, 5} or a roll of {2,3,4,5,6})

Old Method:

One way to determine if you have a large straight is to sort all the die in an ArrayList, then loop through each die and determine if the die in front of the previous die is at least 1 ahead of the previous die. Another way would be to sort all the die in order, then loop through each of the two possible large straight arrays and test each die against the corresponding element at the same index to see if they are the same.

LINQ Method:

See if one of the two possible straights {1, 2, 3, 4, 5} and {2,3,4,5,6} Intersect with all 5 dice in the roll.

Listing 3 - Calculating a Large Straight using LINQ

public int CalculateLargeStraight (Dice[] myDice) { // now test against 2 possibilities // get the dice as a result of integers var result = from die in myDice orderby die.RollNumber select die.RollNumber; // possible large straights int[] largeStraight1 = new int[5]{1,2,3,4,5}; int[] largeStraight2 = new int[5]{2,3,4,5,6}; // test to see if the roll intersects all 5 dice in either of the two possibilities bool commonValues1 = ((IEnumerable<int>)result).Intersect(largeStraight1).Count() == 5; bool commonValues2 = ((IEnumerable<int>)result).Intersect(largeStraight2).Count() == 5; // if either possibility is true, add a score of 40 if (commonValues1 || commonValues2) { int nTotal = 40; m_nTotal += nTotal; m_nLowerTotal += nTotal; return nTotal; } return 0; }

Conclusion:

LINQ is a powerful technology for manipulating collections that will require you to change your thinking of how you are probably currently manipulating them in C#. Not only can LINQ help you query and manipulate collections in memory, but LINQ technology can be extended to work with databases (DLINQ) and XML (XLINQ). Ultimately, LINQ reduces code size and helps your code implementation match a higher level thinking of working with the data. In the meantime, if you are in search for the missing LINQ, you may have found it here in C# and .NET 3.0.