Best way to distribute different outcomes?

Question

I have a method called "GetValue()" which is supposed to return the value "A", "B", "C" or "D" on each method call.

I want this method to return the value "A" in 30% of the method calls and the value "B" in 14% of the method calls, the value "C" 31%.. and so on...

Wich is the best way to distribute theese values smoothly, I do not want the method to return the value "A" xxx times in a row becouse the value "A" are farest from it's requested outcome percentage.

Please, all answeres are appreciated.

Answer 1

You can use the Random class to achieve this:

private static Random Generator = new Random();

public string GetValue() 
{
  var next = Generator.Next(100);
  if (next < 30) return "A";
  if (next < 44) return "B";
  if (next < 75) return "C";
  return "D";
}

Update

For a more generic random weighted value store, the following may be a good starting point:

public class WeightedValueStore<T> : IDisposable
{
  private static readonly Random Generator = new Random();

  private readonly List<Tuple<int, T>> _values = new List<Tuple<int, T>>();
  private readonly ReaderWriterLockSlim _valueLock = new ReaderWriterLockSlim();

  public void AddValue(int weight, T value)
  {
    _valueLock.EnterWriteLock();
    try 
    {
      _values.Add(Tuple.Create(weight, value));
    }
    finally
    {
      _valueLock.ExitWriteLock();
    }
  }      

  public T GetValue() 
  {
    _valueLock.EnterReadLock();
    try
    {
      var totalWeight = _values.Sum(t => t.Item1);
      var next = Random.Next(totalWeight);
      foreach (var tuple in _values)
      {
        next -= tuple.Item1;
        if (next < 0) return tuple.Item2;
      }
      return default(T); // Or throw exception here - only reachable if _values has no elements.
    }
    finally
    {
      _valueLock.ExitReadLock();
    }
  }

  public void Dispose()
  {
    _valueLock.Dispose();
  }
}

Which would then be useable like so:

public string GetValue() 
{
  using (var valueStore = new WeightedValueStore<string>()) 
  {
    valueStore.AddValue(30, "A");
    valueStore.AddValue(14, "B");
    valueStore.AddValue(31, "C");
    valueStore.AddValue(25, "D");
    return valueStore.GetValue();
  }
}

Answer 2

Use Random. Take care of the seed. See this link.

Example:

    // You can provide a seed as a parameter of the Random() class.
    private static Random RandomGenerator = new Random();

    private static string Generate()
    {
        int value = RandomGenerator.Next(100);

        if (value < 30)
        {
            return "A";
        }
        else if (value < 44)
        {
            return "B";
        }
        else
        {
            return "C";
        }
    }

Answer 3

If you want that distribution by average, you can just pick a random number and check it.

Random rnd = new Random();

int value = rnd.Next(100); // get a number in the range 0 - 99
if (value < 30) return "A";
if (value < 30+14) return "B";
if (value < 30+14+31) return "C";
return "D";

Note that you should create the random generator once, and reuse it for subsequent calls. If you create a new one each time, they will be initialised with the same random sequence if two method calls come too close in time.

If you want exactly that distribution for 100 items, then you would create an array with 100 items, where 30 are "A", 14 are "B", and so on. Shuffle the array (look up Fisher-Yates), and return one item from the array for each method call.

Answer 4

Let's say you have the arrays
String[] possibleOutcomes = new String[] { "A", "B", "C", "D" }
and
int[] possibleOutcomeProbabilities = new int[] { 30, 14, 31, 25 }

You can use the following strategy whenever you are required to output one of the outcomes:

1. Find the sum of all elements in possibleOutcomeProbabilities. Lets call this sum totalProbability.
2. Generate a random number between 1 and totalProbability. Lets call this randomly generated number outcomeBucket.
3. Iterate over possibleOutcomeProbabilities to determine which outcome outcomeBucket corresponds to. You then pick the corresponding outcome from possibleOutcomes.

This strategy will certainly not give you first 30% outcomes as A, next 14% as B, etc. However, as probability works, over a sufficiently large number of outcomes, this strategy will ensure that your possible outcomes are distributed as per their expected probabilities. This strategy gives you the advantage that outcome probabilities are not required to add up to 100%. You can even specify relative probabilities, such as, 1:2:3:4, etc.

If you are really worried about the fastest possible implementation for the strategy, you can tweak it as follows:

a. Calculate totalProbability only once, or when the probablities are changed. b. Before calculating totalProbability, see if the elements in possibleOutcomeProbabilities have any common divisors and eliminate those. This will give you a smaller probability space to traverse each time.

Answer 5

try this:

Random r = new Random();

private string GetValue()
{
  double d = r.Next();
  if(d < 0.3)
    return "A";
  else if(d < 0.5)
    return "B";

  ...etc.

}

EDIT: just make sure that the Random variable is created outside the function or you'll get the same value each time.

Answer 6

I would not recommend any hard-coded approach (it is hard to maintain and it's bad practice). I'd prefer a more generic solution instead.

    enum PossibleOutcome { A, B, C, D, Undefined }

    // sample data: possible outcome vs its probability
    static readonly Dictionary<PossibleOutcome, double> probabilities = new Dictionary<PossibleOutcome, double>()
    {
        {PossibleOutcome.A, 0.31},
        {PossibleOutcome.B, 0.14},
        {PossibleOutcome.C, 0.30},
        {PossibleOutcome.D, 0.25}
    };

    static Random random = new Random();       
    static PossibleOutcome GetValue()
    {            
        var result = random.NextDouble();
        var sum = 0.0;
        foreach (var probability in probabilities)
        {
            sum += probability.Value;
            if (result <= sum)
            {
                return probability.Key;
            }                
        }
        return PossibleOutcome.Undefined; // it shouldn't happen
    }

    static void Main(string[] args)
    {
        if (probabilities.Sum(pair => pair.Value) != 1.0)
        {
            throw new ApplicationException("Probabilities must add up to 100%!");
        }

        for (var i = 0; i < 100; i++)
        {
            Console.WriteLine(GetValue().ToString());
        }
        Console.ReadLine();            
    }