How to randomize a number based on criteria in C#?

Question

I am struggling with a randomize algorithm which I'm unable to solve.

Below is the randomize criteria.

1. User type a random integer number, i.e 28
2. User type a factor number, i.e 1.2
3. If user key in 28 on point #1 and 1.2 for point #2, then there should be a total of 28 randomize number generated and the sums of the 28 randomize number must equals to 29.2
4. For each randomize number must be the value between 0.01 to 9.99, maximum two decimals.

I have done my code and it meet criteria 1-3, but I can't seems to meet criteria #4. If a lot of high randomize number generated upfront, the ending iteration would not be enough to generate at least 0.01. It was always 0.00. Anything i missed out?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace RandomizeAlgo
{
    public static class Extend
    {
        public static double RandomNumberBetween(this Random random, double minValue, double maxValue)
        {
            var next = random.NextDouble();

            return minValue + (next * (maxValue - minValue));
        }

        public static double ToFloor(this double value)
        {
            return Math.Floor(value * 100) / 100;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var rnd = new Random();
            var totalPeople = 28;
            var factor = 1.2;
            var shouldHaveTotalNumber = totalPeople + factor;

            var defaultMin = 0.01;
            var defaultMax = 9.99;

            while (true)
            {
                var iteration = 0;
                var balance = shouldHaveTotalNumber;
                var listOfRandomizedNumber = new List<double>();
                for (var i = 1; i <= totalPeople; i++)
                {
                    var randomizeResult = 0.00;
                    if (i == totalPeople)
                    {
                        randomizeResult = balance;
                    }
                    else if (balance >= defaultMax)
                    {
                        randomizeResult = rnd.RandomNumberBetween(defaultMin, defaultMax);
                        randomizeResult = randomizeResult.ToFloor();
                    }
                    else
                    {
                        randomizeResult = rnd.RandomNumberBetween(defaultMin, balance);
                        randomizeResult = randomizeResult.ToFloor();
                    }
                    listOfRandomizedNumber.Add(randomizeResult);

                    Console.WriteLine(string.Format("{0:0.00}", randomizeResult));

                    balance = balance - randomizeResult;
                }

                iteration++;
                //Assertion
                var totalSumNumberGenerated = listOfRandomizedNumber.Sum().ToString("0.00");
                if (totalSumNumberGenerated != shouldHaveTotalNumber.ToString("0.00"))
                {
                    throw new InvalidOperationException("Total #"+ iteration + " iteration is: " + totalSumNumberGenerated + " . Invalid Randomize Number. Sum does not match");
                }
                else
                {
                    Console.WriteLine("Iteration #"+ iteration + " successfully generated");
                }
            }
        }
    }
}

Answer 1

Randomize proportions of the sum, not magnitudes

Since you don't seem to care about distribution, how about a different approach. Generate a list of random numbers in any range, compute their sum, then compute a constant that will scale the sum to the target. For example, if the actual sum was 10, but the target sum was 20, the scaling value is 2. Then multiply every element by 2.

Another way to look at it is that you are generating a series of numbers that represents the proportion that element contributes to the sum, rather than the magnitude itself.

This approach would always get the list you need in one iteration, except for one pesky thing: your range and precision requirements. By enforcing a precision to two decimals we could round ourselves off target, so we will need to double check and then iterate a few times until it works out.

Also, don't forget floating point comparisons must use a tolerance, in this case 0.005.

public static List<double> GetTheList(int count, double target)
{
    var random = new Random();
    var iteration = 0;

    while (true)
    {
        iteration++;

        //Start with a list of random numbers of any range
        var list = Enumerable.Range(1, count).Select( i => random.NextDouble() );

        //Take the sum
        var sum = list.Sum();

        //Determine a scaling factor to make the sum hit the target
        var scale = target / sum;

        //Scale all of the numbers, and round them off
        var results = list.Select( n => Math.Round(n * scale, 2) ).ToList();

        //Check to see if rounding errors put you off target
        if (Math.Abs(results.Sum() - target) > 0.005) continue;

        //Ensure bounds
        if (results.Min() < 0.01 || results.Max() > 99.9) continue;

        //The list matches all the criteria, so return it
        Console.WriteLine("{0} iterations executed.", iteration);
        return results;
    }
}

Example on DotNetFiddle

Answer 2

Here's an implementation I've made, but first allow me to explain the theory behind it. The idea is that instead of simply creating random numbers that up to a certain number we say we want random numbers in pairs that add up to the average per number multiplied by two. this way the numbers while random have a sticky effect to the average and therefore the target number.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace RandomizeAlgo {

    class Program {

        public static void Main(string[] args) {
            int people = 0;
            double factor = 0.0;
            getInputs(ref people, ref factor);
            Random r = new Random();
            List<double> randoms = new List<double>();
            double total = factor + people;
            double divisor = Math.Round(total / people, 2);
            double counter = 0.0;
            if (people % 2 == 1) {
                randoms.Add(Math.Round(Math.Min(Math.Min(r.NextDouble() + 0.01, 0.99) * 10 / people, divisor), 2));
                total -= randoms[0];
                divisor = Math.Round(total / (people - 1), 2);
                counter += randoms[0];
            } for (int i = randoms.Count; i != people; i += 2) {
                if (i == people - 2) {
                    double finals = Math.Round(Math.Min(r.NextDouble() + 0.01, 0.99) * divisor, 2);
                    randoms.Add(finals);
                    randoms.Add(Math.Round((people + factor) - (counter + finals), 2));
                } randoms.AddRange(getRandomPair(divisor, r, ref counter));
            } counter = 0.0;
            for (int i = 0; i != people; i++) {
                counter += randoms[i];
                Console.WriteLine("+ " + randoms[i].ToString() + " = " + counter.ToString());
            } Console.ReadLine();
        }

        public static void getInputs(ref int people, ref double factor) {
            while (true) {
                Console.Clear();
                Console.Write("Integer: ");
                try { people = Convert.ToInt32(Console.ReadLine()); break; }
                catch { Console.WriteLine("ERROR: Must be an integer."); Console.ReadLine(); }
            } while (true) {
                Console.Clear();
                Console.Write("Double: ");
                try { factor = Convert.ToDouble(Console.ReadLine()); break; }
                catch { Console.WriteLine("ERROR: Must be an double."); Console.ReadLine(); }
            }
        }

        public static double[] getRandomPair(double divisor, Random r, ref double counter) {
            double[] parts = { Math.Round(Math.Min(r.NextDouble() + 0.01, 0.99) * divisor, 2), 0 };
            parts[1] = (divisor * 2) - parts[0];
            counter = counter + parts[0] + parts[1];
            return parts;
        }
    }
}