This example is a little program to generate random numbers based on historic lotto results. Each potential result pull is weighted based on past results.

The full project is available **on GitHub** here.

First, we need to store the historic data. In this case I use an instance of SortedDictionary.

```
int totalBallsNeeded = 6; //5 plus the extra shot
int doubleBallCount = 104; //52 numbers times 2
SortedDictionary<int, int> lottoNumberFrequencyTable = new SortedDictionary<int, int>();
lottoNumberFrequencyTable.Add(1, 29);
lottoNumberFrequencyTable.Add(2, 34);
//...
lottoNumberFrequencyTable.Add(52, 38);
```

Code language: C# (cs)

There is a possible range of 01 to 52 lotto values. I pulled the frequency data from online sources. In this case the key is the lotto number and the value is the frequency.

After the data is stored, we do the actual random number generation with weighted frequency.

The array we link our random numbers to is twice as large as the total number of lotto possibilities. Inside two array index related to one lotto number.

That means for lotto #01 index 0 and index 1 will store the values 0 to 29.

For lotto #02 it will be associated to index 2 and index 3 with values 30 to 64.

```
//add up the total range of frequencies
int totalFrequencyCount = 0;
//an array that will hold frequency ranges for all possible balls
//eg: [0][1] is for ball 01 with two associated array entries: [0] = 0 and [1] = 29
//for ball 02 it would be [2] = 30 and [3] = 64 for that range
int[] frequencyBlocks = new int[doubleBallCount];
//keep track of which set of array entries we are working on
int frequencyBlocksCounter = 0;
foreach (KeyValuePair<int, int> entry in lottoNumberFrequencyTable.ToArray())
{
//generate block of numbers for weighted RNG
//the starting point value for this lotto number
frequencyBlocks[frequencyBlocksCounter] = totalFrequencyCount++;
//increment the total frequency count variable to prep for the next step
totalFrequencyCount += entry.Value;
//the ending point for this lotto number
frequencyBlocks[frequencyBlocksCounter + 1] = totalFrequencyCount;
//jump to the next set of array entries
frequencyBlocksCounter += 2;
}
//fire up a random number generator
Random r = new Random();
//clear our result display text box
textBox1.Text = "";
//due to needing unique numbers, we need to track our successful pulls
int totalBallsSelected = 0;
//a place to store our successful pulls
List<int> selectedBallValues = new List<int>();
//get our six weighted random values with no duplicates
while(totalBallsSelected < totalBallsNeeded)
{
//get a random number between 1 and the total sample size
int randInRange = r.Next(1, totalFrequencyCount);
//get a weighted random number result
//loop through our custom array
int currentBall = 1;
for(int j = 0; j < doubleBallCount; j += 2)
{
//find which block of weighted frequency this random number should fit in
//once found that range will relate back to a lotto number
if (randInRange >= frequencyBlocks[j] && randInRange < frequencyBlocks[j + 1])
{
//don't allow duplicates
if(!selectedBallValues.Contains(currentBall))
{
//save the successful pull into our result class instance
selectedBallValues.Add(currentBall);
totalBallsSelected++;
}
break; //exit the inner for loop after a successful pull
}
else
{
//after a successful pull, increment our total result counter
currentBall++;
}
}
}
```

Code language: C# (cs)

When we get a random number, it will fit into our double wide array. Looping through each time to find where in the array it should fit. Once that index is found it related back to the actual lotto number. This happens as long as it takes to get 6 entries that are unique.