We know that there is no true random number. The best we get is pseudo-random number, which comes from a seed value. I was wondering if I could get a random number without using Math.random() function of JavaScript. So I developed an algorithm of my own, which is a few lines of code that works by keeping, updating, and shifting a seed array in the state. This ensures nearly equal distribution of the generated values for larger and larger test set.

Below is the code with explanation, followed by its performance test and comparison with Math.random().

## The Code

```
const getDateIntArr = () => Date.now().toString().split("").reverse().map(d => parseInt(d))
class MyRandom {
constructor() {
this.seed = getDateIntArr();
}
generate() {
const dateIntArr = getDateIntArr();
this.seed = dateIntArr.map((d, index) => {
let newVal = d + this.seed[index];
if (newVal > 9) {
newVal = newVal % 10;
}
return newVal;
});
this.seed.push(this.seed.shift());
return this.seed[0];
}
};
```

### The Code Explained

- We start with creating a class
`MyRandom`

and assigning`this.seed`

a value, which is`Date.now()`

in reversed array form and converted to integer. (Example:`Date.now()`

=`1654202603378`

,`this.seed`

=`[ 8, 7, 3, 3, 0, 6, 2, 0, 2, 4, 5, 6, 1 ]`

.) - The
`generate`

method creates a similar reversed array in`dateIntArr`

. We then add the same indexes values of`this.seed`

&`dateIntArr`

. If the sum is greater than 9 we consider the remainder after`%10`

. We assign the resulting array to`this.seed`

. - Lastly, shuffle
`this.seed`

array to the left by one, and return the`0`

index value, which will be anything from 0 to 9. The shuffled`this.seed`

is now the new seed value to be used in the next`generate`

call.

### Reasoning

- Reversing the arrays
`this.seed`

&`dateIntArr`

is not necessary, but then we’ll need to return`this.seed[this.seed.length]`

instead of`this.seed[0]`

. (also, we may want to change the array shift to the opposite direction.) - We return the first element because that’s the one most frequently changed in Date.now() after reversing, followed by second, third and so on. After addition to the previous seed and shifting, this should be the most unpredictable number out of the lot.

### Time Complexity

The time complexity will be O(1) i.e. constant, because though there are loops used but they won’t be dynamic and only go so far as 13, which is the length of `Date.now()`

.

## Performance Test and Comparison with Math.Random()

A reasonably good (pseudo)random generator needs to generate the numbers within a given range almost equally. If we generate a random number from 1 to 10 (like we did above), the percentage of each value from 1 to 10 should be roughly 10%. That is, on generating a random number, say, a 1000 times, every number should ideally appear a 100 times.

To compare the performance of both, let’s run our own custom generator and `Math.random()`

for 10, 100, 1000, 10000, and 100000 times, and get the percentage of the occurrences of 0 to 9. The script below gets us the percentage of each occurrence, given the number of times a random number is generated. (Change the value of TOTAL for the number of times you want to run the generators):

```
const sortObject = o => Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {});
const mathRandomHash = {};
const customRandomHash = {}
const TOTAL = 100;
const rand = new MyRandom();
for (let i = 0; i < TOTAL; i++) {
const customRand = rand.generate();
const mathRand = (Math.floor(Math.random() * 10));
if (!customRandomHash[customRand]) {
customRandomHash[customRand] = 1
}
else {
customRandomHash[customRand] += 1;
}
if (!mathRandomHash[mathRand]) {
mathRandomHash[mathRand] = 1
}
else {
mathRandomHash[mathRand] += 1;
}
}
const convertToPercentage = (hash, total) => {
return Object.keys(hash).forEach(e => {
hash[e] = Math.floor((hash[e] / total) * 100);
})
}
convertToPercentage(mathRandomHash, TOTAL);
convertToPercentage(customRandomHash, TOTAL);
console.log("Math Rand");
console.log(sortObject(mathRandomHash));
console.log("My Rand");
console.log(sortObject(customRandomHash));
```

### 10 Times

```
Math Rand
{ '1': 30, '2': 20, '3': 20, '4': 20, '5': 10 }
My Rand
{ '0': 20, '1': 10, '4': 10, '5': 10, '6': 30, '8': 10, '9': 10 }
```

### 100 Times

```
Math Rand
{
'0': 7,
'1': 10,
'2': 10,
'3': 10,
'4': 9,
'5': 13,
'6': 12,
'7': 10,
'8': 10,
'9': 9
}
My Rand
{
'0': 11,
'1': 7,
'2': 7,
'3': 9,
'4': 10,
'5': 11,
'6': 10,
'7': 11,
'8': 12,
'9': 12
}
```

### 1000 Times

```
Math Rand
{
'0': 9,
'1': 8,
'2': 11,
'3': 11,
'4': 9,
'5': 10,
'6': 10,
'7': 10,
'8': 9,
'9': 10
}
My Rand
{
'0': 9,
'1': 11,
'2': 9,
'3': 11,
'4': 8,
'5': 10,
'6': 9,
'7': 10,
'8': 9,
'9': 10
}
```

### 10000 Times

```
Math Rand
{
'0': 10,
'1': 9,
'2': 9,
'3': 9,
'4': 9,
'5': 9,
'6': 10,
'7': 10,
'8': 10,
'9': 10
}
My Rand
{
'0': 10,
'1': 11,
'2': 10,
'3': 9,
'4': 9,
'5': 9,
'6': 11,
'7': 9,
'8': 9,
'9': 9
}
```

### 100000 Times

```
Math Rand
{
'0': 9,
'1': 9,
'2': 10,
'3': 10,
'4': 9,
'5': 9,
'6': 10,
'7': 10,
'8': 10,
'9': 9
}
My Rand
{
'0': 9,
'1': 10,
'2': 10,
'3': 9,
'4': 9,
'5': 10,
'6': 9,
'7': 9,
'8': 10,
'9': 9
}
```

From the above data, we can observe that both `Math.random()`

and our custom random number generator start off with pretty uneven distribution of generated numbers from 1 to 10, when run for merely 10 or 100 times. But as we keep on increasing the number, the distribution gets even. For 100,000 runs, each number from 1 to 10 appears almost 10% of the time.

#### See also

- Reduce JS Size With Constant Strings
- JavaScript SDK
- JavaScript: Find if the String Has a Particular Case
- Replace All Keys of Deeply Nested Objects or Array of Objects in JavaScript
- Restrict Content for Users of Specific Countries With JavaScript Only
- Track Number of User Visits With JavaScript Local Storage
- React JS Render Form With Dynamic Conditional Fields