Here at Chosen Numbers, we are assigning lottery numbers systematically.

Our quickpicks are NOT random selections, but selected programmatically.

What does that mean?

First off we have created a function to generate lottery numbers sequences based on the index.

For those who are computer or math savvy, this can be represented as a function:

**f(x)={lottery number sequence}**

So for a lottery which has 6 numbers from a pool of 49 numbers, or 13,938,816 possibilities, the first four and last four sequences from the function would be as follows:

f(1) = {1,2,3,4,5,6}

f(2) = {1,2,3,4,5,7}

f(3) = {1,2,3,4,5,8}

f(4) = {1,2,3,4,5,9}

...

(13,938,808 additional sequences)

...

f(13938813) = {43,44,45,47,48,49}

f(13938814) = {43,44,46,47,48,49}

f(13938815) = {43,45,46,47,48,49}

f(13938816) = {44,45,46,47,48,49}

## How do We Choose?

So we have a function, now what?

We now need to find a logical way of presenting these numbers to the players.

This method must be programmatic.

It must span the entire pool of available numbers.

It must provide unique numbers until the pool resets when all sequences have been exhausted.

We have narrowed down the process to a couple of choices.

Sequentially or systematically.

### Sequentially

The above image shows illustratively numbers being chosen sequentially.

Programmatically it would be easy. Just maintain a pointer and add one to it for the next sequence.

We could have chosen this approach, but that would not be too much fun for the players.

Lottery number sequences would be bunched together wherever the index is currently sitting, be it at the beginning, middle or end of the pool of numbers.

Players would also be able to predict the next sequence.

We believe players want to see numbers which do not look sequential.

### Systematically

This is the approach we have adopted for our pools of numbers.

What we are storing is an offset and an increment.

We then add the increment and offset to the index and this provides the next sequence of lottery numbers.

We have some checks in place to see if the offset and increment exceeds the number of sequences in the pool.

If so, we start at the lower offset but increment it by 1.

This way we are providing lottery combinations throughout the entire range of the given lottery.

It also provides a bit of variety to the numbers generated.

The next sequences are not easy to predict.

Each lottery on our website has its own unique increment.

That way different sequences would be generated with lotteries with the same play format.

We decided the increment should be a number between 32000 and 34000.

We also decided to choose prime numbers for the increment as well (kind of following the methodology used by various crypto algorithms).

This logic is used for the main number sequences for a lottery.

For lotteries with a "*Mega Ball*" or "*PowerBall*", here we are adding a sequentially increased number.

Frankly, we chose this method for this additional "ball" because it was easier to implement.

**Aside Note:**

All of our lottery pools do start at the same index, and that index is f(1), so depending on the lottery, the first sequence is 1,2,3,4,5,6 for a lottery with six numbers drawn.

So that's how we do it.

Storing index pointers.

Remember, play with chosen numbers.