Optimizing odds calculator

Question

I am trying to setup an odds calculator for a best of 7 series, given independent odds for each event.

The following code works, but I would like to add recursion to simplify the end.

public class Game
{
    public int No { get; set; }
    public List<decimal> Odds;

    public Game(int no, decimal odd1, decimal odd2)
    {
        No = no;

        Odds = new List<decimal>();

        Odds.Add(odd1);
        Odds.Add(odd2);
    }

  }

void Main()
{

    var games = new List<Game>();

    var homeodd = .6m;
    var awayodd = .4m;

    var winningOdds = 0m;

//Add  7 games each with a different odd of winning game
    games.Add(new Game(1,homeodd,awayodd));
    games.Add(new Game(2,homeodd,awayodd));
    games.Add(new Game(3,awayodd,homeodd));
    games.Add(new Game(4,awayodd,homeodd));
    games.Add(new Game(5,awayodd,homeodd));
    games.Add(new Game(6,homeodd,awayodd));
    games.Add(new Game(7,homeodd,awayodd));

//game one has 2 possible outcomes, 0 = win, 1 = loss =>same for all 7 games
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            for (int k = 0; k < 2; k++)
            {
                for (int l = 0; l < 2; l++)
                {
                    for (int m = 0; m < 2; m++)
                    {
                        for (int n = 0; n < 2; n++)
                        {
                            for (int o = 0; o < 2; o++)
                            {
                                if ((i+j+k+l+m+n+o)<4)  //if we have loss less than 4 games, we have won the series and we want to add the odds of that possibility to the total odds
                                {
                                    winningOdds += games[0].Odds[i] * games[1].Odds[j] * games[2].Odds[k] * games[3].Odds[l] * games[4].Odds[m] * games[5].Odds[n] * games[6].Odds[o];
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    Console.WriteLine(winningOdds); 
}

Answer 1

Basically, what you need is a Cartesian product of 7 sequences, each containing a 0 and a 1. Eric Lippert has an interesting article about doing just that using LINQ (note: I think you could make his code more efficient using immutable collections). If you use his method, your code could look something like:

var product = CartesianProduct(Enumerable.Repeat(new[] { 0, 1 }, games.Count));

foreach (var indexes in product)
{
    if (indexes.Sum() < 4)
    {    
        winningOdds += indexes
            .Select((index, game) => games[game].Odds[index])
            .Aggregate((x, y) => x * y);
    }
}

Answer 2

This is a clean as I can make it. The last thing I could do would be to replace the hardcoded 7 by a const to make it a little easier to setup best of 5, best of 3, etc...

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApplication10
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var games = new List<Game>();

            const decimal homeodd = .6m;
            const decimal awayodd = .4m;

            var winningOdds2 = 0m;

            games.Add(new Game(1, homeodd));
            games.Add(new Game(2, homeodd));
            games.Add(new Game(3, awayodd));
            games.Add(new Game(4, awayodd));
            games.Add(new Game(5, awayodd));
            games.Add(new Game(6, homeodd));
            games.Add(new Game(7, homeodd));

            for (var ii = 0; ii < Math.Pow(2, games.Count()); ii++)
            {
                var result = Convert.ToString(ii, 2);
                result = "00000000".Substring(0, 7 - result.Length) + result;

                var flag = new List<int>();

                for (var i2 = 0; i2 < games.Count(); i2++)
                {
                    flag.Add(int.Parse(result.Substring(i2, 1)));
                }

                if (flag.Sum() >= 4) continue;
                var product = 1m;
                for (var p = 0; p < 7; p++)
                {
                    product = product * games[p].Odds[flag[p]];
                }
                winningOdds2 += product;
            }

            Console.WriteLine(winningOdds2);
            Console.ReadLine();
        }
    }
}

public class Game
{
    public int No { get; set; }

    public List<decimal> Odds;

    public Game(int no, decimal odd1)
    {
        No = no;
        Odds = new List<decimal> {odd1, 1-odd1};
    }
}

// Define other methods and classes here