[janne_panne]

Countdown Numbers round challenge

Introduction:
This challenge is a copy of a challenge introduced in a TV show called Countdown. The challenge is called Numbers round.

In Numbers round there is a player whose mission is to pick six cards from the table and then with those cards he has to achieve a number generated by a machine using basic operators: + - * /
There are two groups of cards on the table. In the first group there are four different cards with values 25, 50, 75 and 100. In the second group there are cards with values from 1 to 10. Usually players pick one big card and the rest five from small cards. The number they have to achieve (or get as close as possible) is from range 100-999.
One number can only be used once. Not all numbers have to be used.

The Challenge
Your challenge is to create a program which does the following:
- Picks the cards:
-- Randomly picks one card from big cards (25,50,75,100) and five cards from small cards (1-10). The small cards aren't unique, they can have the same value
- Generates a number from range 100-999
- Finds out what how to get to the generated number using the cards given and the operators +, -, *, /. Note that you aren't allowed to use integer rounding meaning that number 4/3 equals to 1.333 instead of 1. One card can be used only once. Not all cards have to be used.
- Prints out how it got to the generated number

Example #1

Big card: 25
Small cards: 5 8 1 10 6
Generated number: 452

25 - 10 = 15
15 * 5 = 75
75 - 1 = 74
74 * 6 = 444
444 + 8 = 452

Example #2

Big card: 25
Small cards: 2 6 1 9 1
Generated number: 333

25 + 1 = 26
26 + 1 = 27
27 * 2 = 54
54 * 6 = 324
324 + 9 = 333

Rewards

Joy of programming, what else would you dare to ask.

Final words

Good luck and have fun.

Remember to use Spoiler and Code tags when posting code.

[snoj]

My humble PowerShell contribution.

Spoiler

$big_card = @(25,50,75,100)[(Get-Random -Minimum 0 -Maximum 3)];

$small_cards = @(1..5) | %{Get-Random -Minimum 1 -Maximum 10}

$operations = "+,-,*,/".Split(",");

$solved = $false;
for($i = 0; $i -lt 100; $i++) {
    $winning_number = $big_card;
    $winning_formula = @();
    foreach($n in $small_cards) {
        $formula = "{0} {1} {2}" -f $winning_number, $operations[(Get-Random -Minimum 0 -Maximum 3)], $n;
        $winning_formula += $formula;
        $winning_number = Invoke-Expression $formula;
    }
    if($winning_number -ge 100 -and $winning_number -le 999) {
        $solved = $true;
        break;
    }
}

if($solved) {
    "Big card: {0}" -f $big_card
    "Small cards: {0}" -f [string]::Join(", ", $small_cards);
    "Generated number: {0}" -f $winning_number
    ""
    $winning_formula
} else {
    "Failed in 100 attempts to generate a result from the following numbers..."
    [string]::Join(", ", (@($big_card) + $small_cards));
}

[edit] Had 99 instead of 999 and added a message if failed to generate a number.

This post has been edited by snoj: 05 January 2012 - 02:25 PM

[AdamSpeight2008]

Talk about a though one!
Do we also have to write us own evaluate function?

The search space is way bigger than you initial think it is.

- Number of ways to arrange the number (6! / (6-n)!)
multipled by
- Number of way to do the sum ( 4^ (n-1))
multipled by
- Number of ways that the parenthesis can work. 2 ^ (n-1)

But that not the end of it, as you have to take into account the different of number of used number solutions. So it actually it a summation of that function for the values 1 to 6

   6
 ∑(n) = F(n)= (4^(n-1)) * (6! / (6-n)!) * (2 ^ (n-1))
 n=1

That look a lot nice if DIC had Mathjax capabilities

Edit: I think those are the right formula, it been a while since I looked at the problem.

Then there is the 30sec time limit!

PS.

Quote

Prints out how it got to the generated number

Is a Reverse Polish Solution allowed?


Blog Post: The Bracketing Problem

My OLD attempt: Solving the Number Game
A slightly newer version

This post has been edited by AdamSpeight2008: 05 January 2012 - 02:49 PM

[AdamSpeight2008]

To clarify are the possible cards.
Big Uns: 100 75 50 25
Wee Uns: 10 10 9 9 8 8 7 7 6 6 5 5 4 4 3 3 2 2 1 1
And that the contestant picks any 6 of those.
You have to find a solution utilizing those 6 card, and the basic math operators.

[snoj]

AdamSpeight2008, on 05 January 2012 - 03:54 PM, said:

To clarify are the possible cards.
Big Uns: 100 75 50 25
Wee Uns: 10 10 9 9 8 8 7 7 6 6 5 5 4 4 3 3 2 2 1 1
And that the contestant picks any 6 of those.
You have to find a solution utilizing those 6 card, and the basic math operators.

So only two ten cards?

*goes back to rework code

[prog_insanity]

Does the program get to pick their values out of the 1-10 pool, or are those 5 cards randomly assigned?

[AdamSpeight2008]

Example Puzzle

Cards: 75 50 2 3 8 7
Target: 812

Ok, 30 secs on the clock.

Spoiler

diddle diddle diddly ding... BOOM!

Spoiler

A possible solution

(7 × 2) × (50 + 8)

This post has been edited by AdamSpeight2008: 05 January 2012 - 04:58 PM

[RexGrammer]

WARNING: Very Long Code Inside

Spoiler

public static class CountdownNumbersGameSolver
    {
        // The path to the solution.
        private static int[] path;

        // Current depth of recursion.
        private static int depth;

        // All data is stored here so that it doesn't have.
        // to be passed down during recursion - saves time.

        // Counter: how many operations we have done.
        private static int operations;

        // Max recursion depth.
        private static int maxDepth;

        // Indicator: solved or not
        private static bool solved;

        // The solution.
        private static string solution;

        public static void Recurse(int baseOfRecursion, int no, int[] numbers)
        {
            // Increase the depth.
            depth++;
            // Figure out which part of the numbers.
            // array is going to be addressing.
            int nbase = baseOfRecursion + no + 1;
            // The last calculation came up with a solution.
            // output the path so far and stop.
            if (numbers[0 + baseOfRecursion] == numbers[1 + baseOfRecursion])
            {
                solution = "Solved: \n";
                for (int a = 0; a < depth - 1; ++a)
                {
                    solution += "" + path[a * 5] + "";
                    if (path[a * 5 + 1] == 0)
                        solution += " = ";
                    if (path[a * 5 + 1] == 1)
                        solution += " * ";
                    if (path[a * 5 + 1] == 2)
                        solution += " + ";
                    if (path[a * 5 + 1] == 3)
                        solution += " - ";
                    if (path[a * 5 + 1] == 4)
                        solution += " / ";
                    solution += "" + path[a * 5 + 2] + "";
                    if (path[a * 5 + 3] == 0)
                        solution += " = ";
                    if (path[a * 5 + 3] == 1)
                        solution += " * ";
                    if (path[a * 5 + 3] == 2)
                        solution += " + ";
                    if (path[a * 5 + 3] == 3)
                        solution += " - ";
                    if (path[a * 5 + 3] == 4)
                        solution += " / ";
                    solution += "" + path[a * 5 + 4] + "\n";
                }
                solved = true;
                return;
            }
            else if (no == maxDepth)
            {
                // The bottom of the recursion and.
                // solution is found , so do nothing.
            }
            else
            {
                // Not at the bottom of the recursion and no solution.
                // Iterate through the possible number pairs and operations.
                for (int a = 1; a < no; ++a)
                {
                    for (int b = 1; b < no; ++B)/>
                    {
                        if (a > B)/>
                        {
                            numbers[0 + nbase] = numbers[0 + nbase];
                            int c = 1;
                            numbers[c + nbase] = numbers[a + baseOfRecursion] * numbers[b + baseOfRecursion];
                            operations++;
                            c++;
                            for (int d = 1; d < no; ++d)
                            {
                                if (d != a && d != B)/>
                                {
                                    numbers[c + nbase] = numbers[d + baseOfRecursion];
                                    c++;
                                }
                            }
                            path[(depth - 1) * 5] = numbers[a + baseOfRecursion];
                            path[(depth - 1) * 5 + 1] = 1;
                            path[(depth - 1) * 5 + 2] = numbers[b + baseOfRecursion];
                            path[(depth - 1) * 5 + 3] = 0;
                            path[(depth - 1) * 5 + 4] = numbers[1 + nbase];
                            Recurse(nbase, no - 1, numbers);
                            if (solved)
                            {
                                return;
                            }
                            numbers[1 + nbase] = numbers[a + baseOfRecursion] + numbers[b + baseOfRecursion];
                            ++operations;
                            path[(depth - 1) * 5 + 1] = 2;
                            path[(depth - 1) * 5 + 4] = numbers[1 + nbase];
                            Recurse(nbase, no - 1, numbers);
                            if (solved)
                            {
                                return;
                            }
                            numbers[1 + nbase] = numbers[a + baseOfRecursion] - numbers[b + baseOfRecursion];
                            operations++;
                            if (numbers[1 + nbase] > 0)
                            {
                                path[(depth - 1) * 5 + 1] = 3;
                                path[(depth - 1) * 5 + 4] = numbers[1 + nbase];
                                Recurse(nbase, no - 1, numbers);
                                if (solved)
                                {
                                    return;
                                }
                            }
                            if ((numbers[b + baseOfRecursion] != 0) && (numbers[a + baseOfRecursion] % numbers[b + baseOfRecursion] == 0))
                            {
                                numbers[1 + nbase] = numbers[a + baseOfRecursion] / numbers[b + baseOfRecursion];
                                operations++;
                                path[(depth - 1) * 5 + 1] = 4;
                                path[(depth - 1) * 5 + 4] = numbers[1 + nbase];
                                Recurse(nbase, no - 1, numbers);
                                if (solved)
                                {
                                    return;
                                }
                            }
                        }
                        else if (b > a)
                        {
                            // Perform division and subtraction - multiplication and
                            // addition will be performed with this number pair ordered the
                            // other way around, and will give the same result.
                            numbers[0 + nbase] = numbers[0 + baseOfRecursion];
                            int c = 1;
                            numbers[c + nbase] = numbers[a + baseOfRecursion] - numbers[b + baseOfRecursion];
                            operations++;
                            c++;
                            for (int d = 1; d < no; d++)
                            {
                                if (d != a && d != B)/>
                                {
                                    numbers[c + nbase] = numbers[d + baseOfRecursion];
                                    c++;
                                }
                            }
                            if (numbers[1 + nbase] > 0)
                            {
                                path[(depth - 1) * 5] = numbers[a + baseOfRecursion];
                                path[(depth - 1) * 5 + 1] = 3;
                                path[(depth - 1) * 5 + 2] = numbers[b + baseOfRecursion];
                                path[(depth - 1) * 5 + 3] = 0;
                                path[(depth - 1) * 5 + 4] = numbers[1 + nbase];
                                Recurse(nbase, no - 1, numbers);
                                if (solved)
                                {
                                    return;
                                }
                            }
                            if ((numbers[b + baseOfRecursion] != 0) && (numbers[a + baseOfRecursion] % numbers[b + baseOfRecursion] == 0))
                            {
                                numbers[1 + nbase] = numbers[a + baseOfRecursion] / numbers[b + baseOfRecursion];
                                path[(depth - 1) * 5] = numbers[a + baseOfRecursion];
                                path[(depth - 1) * 5 + 1] = 4;
                                path[(depth - 1) * 5 + 1 + 2] = numbers[b + baseOfRecursion];
                                path[(depth - 1) * 5 + 2 + 3] = 0;
                                path[(depth - 1) * 5 + 3 + 4] = numbers[1 + nbase];
                                Recurse(nbase, no - 1, numbers);
                                if (solved)
                                {
                                    return;
                                }
                            }
                        }
                    }
                }
            }
            depth--;
        }

        public static string GetSolution(int[] numbersInputed)
        {
            int no = numbersInputed.Length;
            solved = false;
            solution = "No solution found.";

            if (no < 7)
            {
                throw new ArgumentOutOfRangeException("Please specify all of the needed attributes!");
            }
            else
            {
                int[] numbers = new int[no * (no - 1)];
                path = new int[(no - 1) * 5];
                depth = 0;
                operations = 0;

                for (int i = 0; i < numbersInputed.Length; i++)
                {
                    numbers[i] = numbersInputed[i];

                    if ((i != 0) && (numbers[i] == numbers[0]))
                    {
                        solved = true;
                        return "The input number is the solution.";
                    }
                }

                for (maxDepth = no - 1; maxDepth > 1 && !solved; maxDepth--)
                {
                    Recurse(0, no, numbers);
                }
            }
            return string.Format(" {0} \n Done in: {1} operations! \n Congrats!", solution, operations.ToString());
        }
    }

To be invoked like this:

            Random r = new Random();
            int[] smallCards = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            int[] bigCards = new int[] {25, 50, 75, 100};
            int[] inputs = new int[7];
            inputs[0] = r.Next(100, 999);
            inputs[1] = bigCards[r.Next(0, 3)];
            for (int i = 2; i < inputs.Length; i++)
            {
                inputs[i] = smallCards[r.Next(0, 9)];
            }
            Console.WriteLine(string.Format("The target is: {0} \n The numbers available are:", inputs[0].ToString()));
            for (int i = 1; i < inputs.Length; i++)
            {
                Console.WriteLine(inputs[i].ToString());
            }
            Console.WriteLine(CountdownNumbersGameSolver.GetSolution(inputs));
            Console.ReadLine();

I won't explain the algorithm since it's very long, and I'm tired. It really bruteforces a solution (since I haven't got anything smarter). It's basically a deep recursion algorithm.

Found the inspiration out of Daniel Tebbutt's algorithm on this subject. Since I couldn't think of anything smart on my own, I started searching through the internet for help. Found his algorithm from which I drew inspiration and ideas.

This post has been edited by RexGrammer: 08 January 2012 - 02:53 PM

[janne_panne]

Nice to see some submissions here already.
I'll try your C# submissions on my computer when I have time. I'll also think about the next challenge. I'll try to make it non-mathematic because math challenges can be frustrating if you can't figure out a good algorithm and always just go for a brute force, like me

@prog_insanity:
They are randomly picked

@AdamSpeight2008:
Thanks for clarifying the possible cards.

Here is my version:

Spoiler

I decided to go for a class called Expression which contains Operands and Operators.

    class Expression
    {
        public Expression()
        {
            Items = new List<object>();
        }

        /// <summary>
        /// List that contains operands and operators
        /// </summary>
        private List<object> Items { get; set; }

        /// <summary>
        /// Adds an operand to the expression
        /// </summary>
        /// <param name="operand"></param>
        public void AddOperand(int operand)
        {
            this.Items.Add(operand);
        }

        /// <summary>
        /// Adds an operator to the expression
        /// </summary>
        /// <param name="op"></param>
        public void AddOperator(Operator op)
        {
            this.Items.Add(op);
        }

        /// <summary>
        /// Returns a copy of Expression
        /// </summary>
        /// <returns></returns>
        public Expression Copy()
        {
            Expression expr = new Expression();
            foreach (var item in Items)
                expr.Items.Add(item);
            return expr;
        }

        /// <summary>
        /// Copies the items in Expression 'from' to this Expression 
        /// </summary>
        /// <param name="from"></param>
        public void CopyExpressionItems(Expression from)
        {
            if (from != null)
                this.Items.AddRange(from.Items);
        }

        /// <summary>
        /// Calculates the expression and returns the value calculated
        /// </summary>
        /// <returns></returns>
        public double Evaluate()
        {
            double number = (int)Items[0];
            for (int i = 1; i < Items.Count; i += 2)
            {
                Operator op = (Operator)Items[i];
                number = op.Operate(number, (int)Items[i + 1]);
            }
            return number;
        }

        public override string ToString()
        {
            StringBuilder builder = new StringBuilder();
            double number = (int)Items[0];
            for (int i = 1; i < Items.Count; i += 2)
            {
                Operator op = (Operator)Items[i];
                int num2 = (int)Items[i + 1];
                builder.AppendLine(string.Format("{0} {1} {2} = {3}", number, op.AsString(), num2, op.Operate(number, num2)));
                number = op.Operate(number, num2);
            }
            return builder.ToString();
        }
    }

The possible operators and some extension methods for them:

    /// <summary>
    /// Enum for different operators
    /// </summary>
    public enum Operator
    {
        Plus = 1,
        Minus = 2,
        Multiply = 3,
        Division = 4
    }

    /// <summary>
    /// Class which contains Extension methods for Operator enum
    /// </summary>
    public static class OperatorExt
    {
        /// <summary>
        /// Calculates the two given numbers using the Operator
        /// </summary>
        /// <param name="op"></param>
        /// <param name="num1"></param>
        /// <param name="num2"></param>
        /// <returns></returns>
        public static double Operate(this Operator op, double num1, double num2)
        {
            switch (op)
            {
                case Operator.Plus:
                    return num1 + num2;
                case Operator.Minus:
                    return num1 - num2;
                case Operator.Multiply:
                    return num1 * num2;
                case Operator.Division:
                    return num1 / num2;
                default:
                    throw new ArgumentException();
            }
        }

        /// <summary>
        /// Returns a string presentation of Operator
        /// </summary>
        /// <param name="op"></param>
        /// <returns></returns>
        public static string AsString(this Operator op)
        {
            switch (op)
            {
                case Operator.Plus:
                    return "+";
                case Operator.Minus:
                    return "-";
                case Operator.Multiply:
                    return "*";
                case Operator.Division:
                    return "/";
                default:
                    throw new ArgumentException();
            }
        }
    }

In the Countdown class I get all the possible (I think, I'm not sure if I have missed something) expressions which can be created using one to six operand and four different operators between each operand.

    class Countdown
    {
        private static Random random = new Random();

        /// <summary>
        /// Big card used in calculations
        /// </summary>
        public int BigCard { get; set; }

        /// <summary>
        /// Small cards used in calculations
        /// </summary>
        public List<int> SmallCards { get; private set; }

        /// <summary>
        /// The number this class tries to calculate
        /// </summary>
        public int TargetNumber { get; set; }

        /// <summary>
        /// Possible operators in Countdown Numbers game
        /// </summary>
        private Operator[] operators = new Operator[] { Operator.Plus, Operator.Minus, Operator.Multiply, Operator.Division };

        /// <summary>
        /// Constructor which randomly generates all values used in Countdown Numbers game
        /// </summary>
        public Countdown()
        {
            Initialize();
        }

        /// <summary>
        /// Constructor which takes all values used in Countdown Numbers game
        /// </summary>
        /// <param name="targetNumber"></param>
        /// <param name="bigCard"></param>
        /// <param name="smallCards"></param>
        public Countdown(int targetNumber, int bigCard, List<int> smallCards)
        {
            this.SmallCards = smallCards;
            this.BigCard = bigCard;
            this.TargetNumber = targetNumber;
        }

        /// <summary>
        /// Initializes the Countdown class. Generates SmallCards, BigCard and TargetNumber
        /// </summary>
        private void Initialize()
        {
            this.SmallCards = GetSmallCards();
            this.BigCard = random.Next(1, 5) * 25;
            this.TargetNumber = random.Next(100, 1000);
        }

        /// <summary>
        /// Randomly picks the small cards
        /// </summary>
        /// <returns></returns>
        private List<int> GetSmallCards()
        {
            List<int> availableCards = new List<int> { 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10 };
            List<int> smallCards = new List<int>();
            for (int i = 0; i < 5; i++)
            {
                int r = random.Next(0, availableCards.Count);
                smallCards.Add(availableCards[r]);
                availableCards.RemoveAt(r);
            }
            return smallCards;
        }

        /// <summary>
        /// Returns the closest expression
        /// </summary>
        /// <returns></returns>
        public Expression GetClosestExpression()
        {
            List<int> cards = new List<int>();
            cards.Add(BigCard);
            cards.AddRange(SmallCards);

            Expression closestExpr = null;
            double closest = double.MaxValue;

            foreach (var item in GetExpressionsRecursive(cards, null))
            {
                double val = item.Evaluate();
                if (Math.Abs(TargetNumber - val) <= closest)
                {
                    closest = Math.Abs(TargetNumber - val);
                    closestExpr = item.Copy();
                    if (val == (double)TargetNumber)
                        break;
                }
            }
            return closestExpr;
        }

        /// <summary>
        /// Recursive iterator method to get all possible expressions for items in 'cards' Collection
        /// </summary>
        /// <param name="cards"></param>
        /// <param name="previous"></param>
        /// <returns></returns>
        private IEnumerable<Expression> GetExpressionsRecursive(IList<int> cards, Expression previous)
        {
            List<Expression> expressions = new List<Expression>();

            foreach (int card in cards)
            {
                List<int> copy = CopyListWithoutOneElement(cards, card);
                foreach (Operator oper in operators)
                {
                    Expression current = new Expression();
                    current.CopyExpressionItems(previous);
                    current.AddOperand(card);
                    expressions.Add(current);
                    if (copy.Count == 0)
                        break;
                    Expression copyExpression = current.Copy();
                    copyExpression.AddOperator(oper);
                    foreach (var item in GetExpressionsRecursive(copy, copyExpression))
                        yield return item;
                }
            }
            foreach (var item in expressions)
                yield return item;
        }

        /// <summary>
        /// Returns a list which contains items in given 'numbers' collection but removes the first occurrence of 'element'
        /// </summary>
        /// <param name="numbers"></param>
        /// <param name="element"></param>
        /// <returns></returns>
        private List<int> CopyListWithoutOneElement(IEnumerable<int> numbers, int element)
        {
            var copyNumbers = numbers.ToList();
            copyNumbers.Remove(element);
            return copyNumbers;
        }

        public override string ToString()
        {
            StringBuilder builder = new StringBuilder();
            builder.AppendLine("Big card: " + BigCard.ToString());
            builder.Append("Small cards: ");
            foreach (var item in SmallCards)
                builder.Append(item.ToString() + " ");
            builder.AppendLine();
            builder.Append("Generated number: " + TargetNumber.ToString());
            builder.AppendLine();
            return builder.ToString();
        }
    }

And this is how I use the classes in Main

    class Program
    {
        static void Main(string[] args)
        {
            System.Diagnostics.Stopwatch st = new System.Diagnostics.Stopwatch();
            for (int i = 0; i < 10; i++)
            {
                st.Start();
                Countdown c = new Countdown();
                Console.Write(c.ToString());
                Expression closest = c.GetClosestExpression();
                Console.Write(closest.ToString());
                Console.WriteLine("Elapsed time: " + st.ElapsedMilliseconds + "ms");
                Console.WriteLine();
                st.Reset();
            }
            Console.ReadKey();
        }
    }

So basically it's just a simple brute force solution which uses yield return to make it a bit faster. It creates 1,574,904 expressions if I comment out the break in GetClosestExpression in about 1.8 seconds.

Here is a sample run of ten rounds with one failed run:

Spoiler

Big card: 50
Small cards: 6 10 7 1 1
Generated number: 374
50 + 6 = 56
56 - 1 = 55
55 * 7 = 385
385 - 10 = 375
375 - 1 = 374
Elapsed time: 12ms

Big card: 100
Small cards: 5 3 4 7 6
Generated number: 968
100 / 3 = 33,3333333333333
33,3333333333333 + 7 = 40,3333333333333
40,3333333333333 * 4 = 161,333333333333
161,333333333333 * 6 = 968
Elapsed time: 244ms

Big card: 50
Small cards: 6 9 5 4 10
Generated number: 254
50 + 6 = 56
56 + 5 = 61
61 * 4 = 244
244 + 10 = 254
Elapsed time: 1ms

Big card: 50
Small cards: 5 7 4 8 4
Generated number: 650
5 + 4 = 9
9 + 8 = 17
17 - 4 = 13
13 * 50 = 650
Elapsed time: 335ms

Big card: 75
Small cards: 5 4 4 9 6
Generated number: 931
6 + 75 = 81
81 / 4 = 20,25
20,25 * 9 = 182,25
182,25 + 4 = 186,25
186,25 * 5 = 931,25
Elapsed time: 1861ms

Big card: 50
Small cards: 4 5 3 6 7
Generated number: 625
50 - 4 = 46
46 * 3 = 138
138 - 6 = 132
132 - 7 = 125
125 * 5 = 625
Elapsed time: 85ms

Big card: 50
Small cards: 6 9 6 9 10
Generated number: 855
50 + 6 = 56
56 * 9 = 504
504 + 9 = 513
513 * 10 = 5130
5130 / 6 = 855
Elapsed time: 8ms

Big card: 25
Small cards: 1 3 2 10 8
Generated number: 164
25 + 1 = 26
26 * 3 = 78
78 * 2 = 156
156 + 8 = 164
Elapsed time: 8ms

Big card: 75
Small cards: 4 4 5 8 10
Generated number: 124
75 + 5 = 80
80 / 4 = 20
20 - 8 = 12
12 * 10 = 120
120 + 4 = 124
Elapsed time: 42ms

Big card: 25
Small cards: 10 1 8 10 2
Generated number: 262
25 + 10 = 35
35 + 1 = 36
36 - 2 = 34
34 * 8 = 272
272 - 10 = 262
Elapsed time: 1ms

[AdamSpeight2008]

It could be also six small numbers, it is any 6 from the set of card.
eg 4 Big + 2 Small
3 Big + 3 Small
2 Big + 4 Small
1 Big + 5 Small
0 Big + 6 Small

[AdamSpeight2008]

You can find my Solver entry, in my following blog post covering it.

Countdown Number Puzzle Solver


Just to note it is using the stricter rule used in the game show.

- Only Integer results and intermediate result.
- No Negative or Zero intermediate.
Requires .net 4.0 Client Profile

This post has been edited by AdamSpeight2008: 08 January 2012 - 08:53 PM

[Robin19]

I did mine using the rules I interpreted first, without looking at anyone's posts. It uses recursion to find the answer. It can easily be modified to select any 6 cards. Right now it only selects one large and five small cards.

Equation Class - Holds the cards that are used, the operations, and calculates the mathematical results.

Spoiler

    public class Equation
    {
        #region Properties
        private List<double> Cards { get; set; }
        private List<Operator> Operators { get; set; }
        public double Value
        {
            get
            {
                double value = Cards[0];
                for (int i = 1; i < Cards.Count; i++)
                {
                    switch (Operators[i - 1])
                    {
                        case Operator.Add:
                            value += Cards[i];
                            break;
                        case Operator.Subtract:
                            value -= Cards[i];
                            break;
                        case Operator.Multiply:
                            value *= Cards[i];
                            break;
                        case Operator.Divide:
                            value /= Cards[i];
                            break;
                    }
                }
                return value;
            }
        }
        #endregion Properties

        #region Constructors
        public Equation(double Card)
        {
            this.Cards = new List<double>() { Card };
            this.Operators = new List<Operator>();
        }
        public Equation(Equation StartingEquation, Operator Operation, double Card)
        {
            this.Cards = new List<double>((double[])StartingEquation.Cards.ToArray().Clone());
            this.Cards.Add(Card);
            this.Operators = new List<Operator>((Operator[])StartingEquation.Operators.ToArray().Clone());
            this.Operators.Add(Operation);
        }
        #endregion Constructors

        #region ToString
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();

            double value = Cards[0];
            double nextValue = -1;

            for (int i = 1; i < Cards.Count; i++)
            {
                string line = GetNewCardLine(value, i, ref nextValue);
                sb.Append(line);
                sb.Append(Environment.NewLine);
                value = nextValue;
            }

            return sb.ToString();
        }
        private string GetNewCardLine(double Value, int NextCardIndex, ref double NextValue)
        {
            double nextCard = Cards[NextCardIndex];
            Operator operation = Operators[NextCardIndex - 1];
            string operationString = GetOperationSymbol(operation);
            NextValue = GetNewValue(Value, nextCard, operation);
            return string.Format("{0} {1} {2} = {3}", Value, operationString, nextCard, NextValue);
        }
        private string GetOperationSymbol(Operator Operator)
        {
            switch (Operator)
            {
                case Operator.Add:
                    return "+";
                case Operator.Subtract:
                    return "-";
                case Operator.Multiply:
                    return "*";
                case Operator.Divide:
                    return "/";
                default:
                    return null;
            }
        }
        private double GetNewValue(double First, double Second, Operator Operator)
        {
            switch(Operator)
            {
                case Operator.Add:
                    return First + Second;
                case Operator.Subtract:
                    return First - Second;
                case Operator.Multiply:
                    return First * Second;
                case Operator.Divide:
                    return First / Second;
                default:
                    return -1;
            }
        }
        #endregion ToString
    }

    public enum Operator
    {
        Add,
        Subtract,
        Multiply,
        Divide
    }

Player Class - holds the cards, knows the goal number, brute forces (using recursion) to find an equation that equals the goal

Spoiler

    public class Player
    {
        #region Properties
        public List<double> Cards { get; private set; }
        public double Goal { get; set; }
        private Equation Solution { get; set; }
        #endregion Properties

        #region Constructor
        public Player(double Goal)
        {
            this.Goal = Goal;
            this.Cards = new List<double>();
        }
        #endregion Constructor

        #region Solve
        public void Solve()
        {
            for (int i = 0; i < Cards.Count; i++)
            {
                Equation equation = new Equation(Cards[i]);
                List<double> cardsLeft = GetShortList(Cards, i);
                if (FindSolution(equation, cardsLeft))
                    break;
            }
        }
        private bool FindSolution(Equation StartingEquation, List<Double> CardsLeft)
        {
            for (int i = 0; i < CardsLeft.Count; i++)
            {
                foreach (Operator operation in Enum.GetValues(typeof(Operator)))
                {
                    List<Double> newCardsLeft = GetShortList(CardsLeft, i);
                    double card = CardsLeft[i];
                    if (AddCardIsSolution(card, operation, StartingEquation, newCardsLeft))
                        return true;
                }
            }
            return false;
        }
        private List<Double> GetShortList(List<Double> OldList, int IndexNotToCopy)
        {
            List<Double> newList = new List<double>();
            for (int i = 0; i < OldList.Count; i++)
                if (i != IndexNotToCopy)
                    newList.Add(OldList[i]);
            return newList;
        }
        private bool AddCardIsSolution(double Card, Operator Operation, Equation StartingEquation, List<Double> CardsLeft)
        {
            Equation equation = new Equation(StartingEquation, Operation, Card);
            if (equation.Value == Goal)
            {
                Solution = equation;
                return true;
            }

            if (CardsLeft.Count == 0)
            {
                return false;
            }

            return FindSolution(equation, CardsLeft);
        }
        #endregion Solve

        #region ToString
        public override string ToString()
        {
            if (Solution == null)
                return "No solution was found.";
            else
                return Solution.ToString();
        }
        #endregion ToString
    }

Game Class - Generates the random cards (one big from a set, 5 cards 1-10 with any repeats), creates a player, and tells the player to play

Spoiler

    public class Game
    {
        #region Properties
        Random Random { get; set; }
        double BigCard { get; set; }
        double[] SmallCards { get; set; }
        double GeneratedNumber { get; set; }
        Player Player { get; set; }
        #endregion Properties

        #region PlayGame
        public void PlayNewGame()
        {
            Random = new Random();
            BigCard = GenerateBigCard();
            SmallCards = GenerateSmallCards();
            GeneratedNumber = Random.Next(100, 1000);
            Player = GeneratePlayer();
            Player.Solve();
        }
        private double GenerateBigCard()
        {
            List<double> list = new List<double>() { 25, 50, 75, 100 };
            int index = Random.Next(0, list.Count);
            return list[index];
        }
        private double[] GenerateSmallCards()
        {
            double[] array = new double[5];
            for (int i = 0; i < 5; i++)
            {
                array[i] = Random.Next(1, 11);
            }
            return array;
        }
        private Player GeneratePlayer()
        {
            Player player = new Player(GeneratedNumber);
            player.Cards.Add(BigCard);
            player.Cards.AddRange(SmallCards);
            return player;
        }
        #endregion PlayGame

        #region ToString
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            sb.Append(string.Format("Big card: {0}", BigCard));
            sb.Append(Environment.NewLine);

            sb.Append("Small cards: ");
            for(int i = 0; i < 5; i++)
                sb.Append(string.Format("{0} ", SmallCards[i]));
            sb.Append(Environment.NewLine);

            sb.Append(string.Format("Generated number: {0}", GeneratedNumber));
            sb.Append(Environment.NewLine);

            sb.Append(Environment.NewLine);

            sb.Append(Player);

            return sb.ToString();
        }
        #endregion ToString
    }

Program class just needs to create a new game, tell it to play, and display the game.