Как я могу генерировать случайное целое число между двумя указанными переменными в Javascript, например. x = 4
и y = 8
выводит любой из 4, 5, 6, 7, 8?
На странице Mozilla Developer Network есть несколько примеров:
/**
* Returns a random number between min (inclusive) and max (exclusive)
*/
function getRandomArbitrary(min, max) {
return Math.random() * (max - min) + min;
}
/**
* Returns a random integer between min (inclusive) and max (inclusive).
* The value is no lower than min (or the next integer greater than min
* if min isn't an integer) and no greater than max (or the next integer
* lower than max if max isn't an integer).
* Using Math.round() will give you a non-uniform distribution!
*/
function getRandomInt(min, max) {
min = Math.ceil(min);
max = Math.floor(max);
return Math.floor(Math.random() * (max - min + 1)) + min;
}
Здесь логика за этим. Это простое правило трех:
Math.random()
возвращает Number
от 0 (включительно) до 1 (исключение). Итак, у нас есть такой интервал:
[0 .................................... 1)
Теперь мы бы хотели, чтобы число от min
(включительно) до max
(эксклюзив):
[0 .................................... 1)
[min .................................. max)
Мы можем использовать Math.random
чтобы получить корреспондента в интервале [min, max). Но сначала мы должны немного сузить проблему, вычитая min
из второго интервала:
[0 .................................... 1)
[min - min ............................ max - min)
Это дает:
[0 .................................... 1)
[0 .................................... max - min)
Теперь мы можем применить Math.random
а затем вычислить корреспондента. Позвольте выбрать случайное число:
Math.random()
|
[0 .................................... 1)
[0 .................................... max - min)
|
x (what we need)
Итак, чтобы найти x
, мы бы сделали:
x = Math.random() * (max - min);
Не забудьте добавить min
обратно, чтобы мы получили число в интервале [min, max):
x = Math.random() * (max - min) + min;
Это была первая функция от MDN. Второй возвращает целое число от min
до max
, оба включительно.
Теперь для получения целых чисел вы можете использовать round
, ceil
или floor
.
Вы можете использовать Math.round(Math.random() * (max - min)) + min
, однако это дает неравномерное распределение. Оба, min
и max
имеют только половину шансов на бросок:
min...min+0.5...min+1...min+1.5 ... max-0.5....max
└───┬───┘└────────┬───────┘└───── ... ─────┘└───┬──┘ ← Math.round()
min min+1 max
Поскольку max
исключено из интервала, у него даже меньше шансов на бросок, чем min
.
С Math.floor(Math.random() * (max - min +1)) + min
вы получаете идеально ровное распределение.
min.... min+1... min+2 ... max-1... max.... max+1 (is excluded from interval)
| | | | | |
└───┬───┘└───┬───┘└─── ... ┘└───┬───┘└───┬───┘ ← Math.floor()
min min+1 max-1 max
Вы не можете использовать ceil()
и -1
в этом уравнении, потому что у max
теперь было немного меньше шансов на бросок, но вы также можете бросить (нежелательный) min-1
.
floor
, который округляется вниз.
var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
(Math.random() * (maximum - minimum + 1) ) << 0
быстрее.
x << 0
, x | 0
, ~~x
) вместо Math.floor()
преобразует x
в два дополнения с гораздо меньшим диапазоном, чем Number.MAX_SAFE_INTEGER
(2³²⁻¹ против 2⁵³), Таким образом, вы должны использовать его с осторожностью!
Из документации Mozilla Developer Network:
// Returns a random integer between min (include) and max (include)
Math.floor(Math.random() * (max - min + 1)) + min;
Полезные примеры:
// 0 - 10
Math.floor(Math.random() * 11);
// 1 - 10
Math.floor(Math.random() * 10) + 1;
// 5 - 20
Math.floor(Math.random() * 16) + 5;
// -10 - (-2)
Math.floor(Math.random() * 9) - 10;
function getRandomizer(bottom, top) {
return function() {
return Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom;
}
}
использование:
var rollDie = getRandomizer( 1, 6 );
var results = ""
for ( var i = 0; i<1000; i++ ) {
results += rollDie() + " "; //make a string filled with 1000 random numbers in the range 1-6.
}
разбивка:
Мы возвращаем функцию (заимствование из функционального программирования), которая при вызове возвращает случайное целое число между значениями bottom
и top
, включительно. Мы говорим "включительно", потому что мы хотим включить как нижний, так и верхний в диапазон чисел, которые можно вернуть. Таким образом, getRandomizer( 1, 6 )
вернет либо 1, 2, 3, 4, 5, либо 6.
(нижнее нижнее число, верхнее - большее число)
Math.random() * ( 1 + top - bottom )
Math.random()
возвращает случайный двойник между 0 и 1, и если мы умножим его на единицу плюс разницу между top
и bottom
, мы получим double где-то между 0
и 1+b-a
.
Math.floor( Math.random() * ( 1 + top - bottom ) )
Math.floor
округляет число до ближайшего целого. Итак, теперь мы имеем все целые числа между 0
и top-bottom
. 1 выглядит сбивающим с толку, но он должен быть там, потому что мы всегда округляем, поэтому верхнее число никогда не будет достигнуто без него. Производящееся десятичное число, которое мы генерируем, должно находиться в диапазоне от 0
до (1+top-bottom)
, поэтому мы можем округлить и получить int в диапазоне от 0
до top-bottom
Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom
Код в предыдущем примере дал нам целое число в диапазоне 0
и top-bottom
, поэтому все, что нам нужно сделать, это добавить bottom
к этому результату, чтобы получить целое число в диапазоне bottom
и top
включительно.: D
ПРИМЕЧАНИЕ. Если вы передадите не целое значение или большее число, вы получите нежелательное поведение, но, если кто-либо его не попросит, я не буду вникать в код проверки аргументов, поскольку он довольно далек от намерения оригинальный вопрос.
Возвращает случайное число от 1 до 10:
Math.floor((Math.random()*10) + 1);
Возвращает случайное число от 1 до 100:
Math.floor((Math.random()*100) + 1)
function randomRange(min, max) {
return ~~(Math.random() * (max - min + 1)) + min
}
Альтернативно, если вы используете Underscore.js, вы можете использовать
_.random(min, max)
_.uniqueId()
вы можете вызывать для моделей на стороне клиента.
В других ответах не учитываются вполне разумные параметры 0
и 1
. Вместо этого вместо round
вместо используйте ceil
или floor
:
function randomNumber(minimum, maximum){
return Math.round( Math.random() * (maximum - minimum) + minimum);
}
console.log(randomNumber(0,1)); # 0 1 1 0 1 0
console.log(randomNumber(5,6)); # 5 6 6 5 5 6
console.log(randomNumber(3,-1)); # 1 3 1 -1 -1 -1
console.log(randomNumber(5,6)); # 9 6 6 5 7 7
9 и 7 находятся между 5 и 6? ...... вы должны исправить это или объяснить ..
После создания случайного числа с использованием компьютерной программы он по-прежнему считается случайным числом, если выбранное число является частью или полным из исходного. Но если он был изменен, то математики не принимают его как случайное число, и они могут называть его предвзятым числом. Но если вы разрабатываете программу для простой задачи, это не будет случай рассматривать. Но если вы разрабатываете программу для генерации случайного числа для ценного материала, такого как лотерейная программа или игра в азартные игры, тогда ваша программа будет отклонена руководством, если вы не будете рассматривать этот случай.
Итак, для тех людей, вот мое предложение:
Создайте случайное число, используя Math.random()
(скажем, это n
)
Now for [0,10) ==> n*10 (i.e. one digit) and for[10,100) ==> n*100 (i.e. two digits) and so on. Here squire bracket indicates that boundary is inclusive and round bracket indicates boundary is exclusive.
Then remove the rest after the decimal point. (i.e. get floor) - using Math.floor(), this can be done.
Если вы знаете, как читать таблицу случайных чисел, чтобы выбрать случайное число, вы знаете выше процесс (умножение на 1, 10, 100 и т.д.) не нарушает тот, который я упоминал в начале. (Потому что это изменяет только место десятичной точки.)
Изучите следующий пример и разработайте его для ваших нужд.
Если вам нужен образец [0,9], то пол n * 10 - ваш ответ, и если вам нужно [0,99], то пол n * 100 - ваш ответ и т.д.
Теперь введите свою роль:
Вы запросили номера среди определенного диапазона. (В этом случае вы смещены в этом диапазоне. - Приняв число из [1,6], свернув кубик, вы пристраститесь к [1,6], но все же это случайный случай, если и только если смерть непредвзята.)
Итак, рассмотрим ваш диапазон == > [78, 247] количество элементов диапазона = 247 - 78 + 1 = 170; (так как обе границы включены.
/*Mthod 1:*/
var i = 78, j = 247, k = 170, a = [], b = [], c, d, e, f, l = 0;
for(; i <= j; i++){ a.push(i); }
while(l < 170){
c = Math.random()*100; c = Math.floor(c);
d = Math.random()*100; d = Math.floor(d);
b.push(a[c]); e = c + d;
if((b.length != k) && (e < k)){ b.push(a[e]); }
l = b.length;
}
console.log('Method 1:');
console.log(b);
/*Method 2:*/
var a, b, c, d = [], l = 0;
while(l < 170){
a = Math.random()*100; a = Math.floor(a);
b = Math.random()*100; b = Math.floor(b);
c = a + b;
if(c <= 247 || c >= 78){ d.push(c); }else{ d.push(a); }
l = d.length;
}
console.log('Method 2:');
console.log(d);
Примечание. Сначала в первом методе я создал массив, который содержит нужные вам числа, а затем случайным образом помещает их в другой массив. В способе два, произвольно генерируйте числа и проверяйте их в том диапазоне, который вам нужен. Затем поместите его в массив. Здесь я сгенерировал два случайных числа и использовал их для максимизации скорости программы, минимизируя частоту отказов, получая полезное число. Однако добавление сгенерированных чисел также даст некоторую предвзятость. Поэтому я бы рекомендовал мой первый метод генерировать случайные числа в определенном диапазоне.
В обоих методах ваша консоль покажет результат. (Нажмите кнопку f12 в Chrome, чтобы открыть консоль)
Если вам нужна переменная между 0 и max, вы можете использовать:
Math.floor(Math.random() * max);
Вот MS DotNet Внедрение класса Random в javascript -
var Random = (function () {
function Random(Seed) {
if (!Seed) {
Seed = this.milliseconds();
}
this.SeedArray = [];
for (var i = 0; i < 56; i++)
this.SeedArray.push(0);
var num = (Seed == -2147483648) ? 2147483647 : Math.abs(Seed);
var num2 = 161803398 - num;
this.SeedArray[55] = num2;
var num3 = 1;
for (var i_1 = 1; i_1 < 55; i_1++) {
var num4 = 21 * i_1 % 55;
this.SeedArray[num4] = num3;
num3 = num2 - num3;
if (num3 < 0) {
num3 += 2147483647;
}
num2 = this.SeedArray[num4];
}
for (var j = 1; j < 5; j++) {
for (var k = 1; k < 56; k++) {
this.SeedArray[k] -= this.SeedArray[1 + (k + 30) % 55];
if (this.SeedArray[k] < 0) {
this.SeedArray[k] += 2147483647;
}
}
}
this.inext = 0;
this.inextp = 21;
Seed = 1;
}
Random.prototype.milliseconds = function () {
var str = new Date().valueOf().toString();
return parseInt(str.substr(str.length - 6));
};
Random.prototype.InternalSample = function () {
var num = this.inext;
var num2 = this.inextp;
if (++num >= 56) {
num = 1;
}
if (++num2 >= 56) {
num2 = 1;
}
var num3 = this.SeedArray[num] - this.SeedArray[num2];
if (num3 == 2147483647) {
num3--;
}
if (num3 < 0) {
num3 += 2147483647;
}
this.SeedArray[num] = num3;
this.inext = num;
this.inextp = num2;
return num3;
};
Random.prototype.Sample = function () {
return this.InternalSample() * 4.6566128752457969E-10;
};
Random.prototype.GetSampleForLargeRange = function () {
var num = this.InternalSample();
var flag = this.InternalSample() % 2 == 0;
if (flag) {
num = -num;
}
var num2 = num;
num2 += 2147483646.0;
return num2 / 4294967293.0;
};
Random.prototype.Next = function (minValue, maxValue) {
if (!minValue && !maxValue)
return this.InternalSample();
var num = maxValue - minValue;
if (num <= 2147483647) {
return parseInt((this.Sample() * num + minValue).toFixed(0));
}
return this.GetSampleForLargeRange() * num + minValue;
};
Random.prototype.NextDouble = function () {
return this.Sample();
};
Random.prototype.NextBytes = function (buffer) {
for (var i = 0; i < buffer.length; i++) {
buffer[i] = this.InternalSample() % 256;
}
};
return Random;
}());
Применение:
var r = new Random();
var nextInt = r.Next(1, 100); //returns an integer between range
var nextDbl = r.NextDouble(); //returns a random decimal
Для случайного целого с диапазоном, попробуйте:
function random(minimum, maximum) {
var bool = true;
while (bool) {
var number = (Math.floor(Math.random() * maximum + 1) + minimum);
if (number > 20) {
bool = true;
} else {
bool = false;
}
}
return number;
}
Используя следующий код, вы можете генерировать массив случайных чисел без повторения в заданном диапазоне.
function genRandomNumber(how_many_number,min,max) {
// parameters
// how_many_number : how many numbers you want to generate. For example it is 5.
// min(inclusive) : minimum/low value of a range. it must be any positive integer but less than max. i.e 4
// max(inclusive) : maximun value of a range. it must be any positive integer. i.e 50
// return type: array
var random_number = [];
for (var i = 0; i < how_many_number; i++) {
var gen_num = parseInt((Math.random() * (max-min+1)) + min);
do {
var is_exist = random_number.indexOf(gen_num);
if (is_exist >= 0) {
gen_num = parseInt((Math.random() * (max-min+1)) + min);
}
else {
random_number.push(gen_num);
is_exist = -2;
}
}
while (is_exist > -1);
}
document.getElementById('box').innerHTML = random_number;
}
Чтобы получить случайное число, скажем, между 1 и 6, сначала выполните:
0.5 + (Math.random() * ((6 - 1) + 1))
Это умножает случайное число на 6 и затем добавляет к нему 0.5. Затем округлите число до положительного целого числа, выполнив:
Math.round(0.5 + (Math.random() * ((6 - 1) + 1))
Это округляет число до ближайшего целого числа.
Или, чтобы сделать это более понятным, выполните следующее:
var value = 0.5 + (Math.random() * ((6 - 1) + 1))
var roll = Math.round(value);
return roll;
В общем случае код для этого с использованием переменных:
var value = (Min - 0.5) + (Math.random() * ((Max - Min) + 1))
var roll = Math.round(value);
return roll;
Причиной отнять 0,5 от минимального значения является то, что использование только минимального значения позволит вам получить целое число, которое было бы больше вашего максимального значения. Убрав 0,5 от минимального значения, вы по существу предотвращаете округление максимального значения.
Надеюсь, что это поможет.
Я знаю, что этот вопрос уже ответил, но мой ответ может помочь кому-то.
Я нашел этот простой метод в W3Schools:
Math.floor((Math.random() * max) + min);
Надеюсь, это поможет кому-то.
Случайное целое число между самым низким и самым высоким:
function randomRange(l,h){
var range = (h-l);
var random = Math.floor(Math.random()*range);
if (random === 0){random+=1;}
return l+random;
}
Не самое элегантное решение.. но что-то быстрое.
Здесь я использую для генерации случайных чисел.
function random(high,low) {
high++;
return Math.floor((Math.random())*(high-low))+low;
}
Мы выполняем high++
, потому что Math.random()
генерирует случайное число между 0, (включительно) и 1 (исключение). Исключенный, означает, что мы должны увеличивать максимум на один до выполнения любой математики. Затем мы вычитаем низкое значение из максимума, давая нам наибольшее число для генерации - низкое, затем + низкое, что приводит к возврату в нормальное состояние и делает наименьшее число по крайней мере низким. то мы возвращаем результирующее число
random(7,3)
может вернуться 3,4,5,6, or 7
high
используется только один раз, вы также можете использовать high-low+1
вместо того, чтобы использовать отдельный оператор приращения. Кроме того, большинство пользователей ожидают, что low
параметр будет первым.
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
</head>
<body>
<script>
/*
assuming that window.crypto.getRandomValues is available
the real range would be fron 0 to 1,998 instead of 0 to 2,000
See javascript documentation for explanation
https://developer.mozilla.org/en-US/docs/Web/API/RandomSource/getRandomValues
*/
var array = new Uint8Array(2);
window.crypto.getRandomValues(array);
console.log(array[0] + array[1]);
</script>
</body>
</html>
Uint8Array создает массив, заполненный числом до трех цифр, которое должно быть не более 999. Этот код очень короткий.
function rnd(min,max){
return Math.floor(Math.random()*(max-min+1)+min );
}
Вот пример функции javascript, которая может генерировать случайное число любой указанной длины без использования Math.random():
function genRandom(length)
{
const t1 = new Date().getMilliseconds();
var min = "1",max = "9";
var result;
var numLength = length;
if (numLength != 0)
{
for (var i = 1; i < numLength; i++)
{
min = min.toString() + "0";
max = max.toString() + "9";
}
}
else
{
min = 0;
max = 0;
return;
}
for (var i = min; i <= max; i++)
{
//Empty Loop
}
const t2 = new Date().getMilliseconds();
console.log(t2);
result = ((max - min)*t1)/t2;
console.log(result);
return result;
}
это мой выбор случайного числа в диапазоне, так как я хотел получить случайное число в диапазоне от базового до экспоненты. например base = 10, exponent = 2, дает случайное число от 0 до 100, в идеале и т.д.
если он помогает использовать его, вот он:
// get random number within provided base + exponent
// by Goran Biljetina --> 2012
function isEmpty(value){
return (typeof value === "undefined" || value === null);
}
var numSeq = new Array();
function add(num,seq){
var toAdd = new Object();
toAdd.num = num;
toAdd.seq = seq;
numSeq[numSeq.length] = toAdd;
}
function fillNumSeq (num,seq){
var n;
for(i=0;i<=seq;i++){
n = Math.pow(num,i);
add(n,i);
}
}
function getRandNum(base,exp){
if (isEmpty(base)){
console.log("Specify value for base parameter");
}
if (isEmpty(exp)){
console.log("Specify value for exponent parameter");
}
fillNumSeq(base,exp);
var emax;
var eseq;
var nseed;
var nspan;
emax = (numSeq.length);
eseq = Math.floor(Math.random()*emax)+1;
nseed = numSeq[eseq].num;
nspan = Math.floor((Math.random())*(Math.random()*nseed))+1;
return Math.floor(Math.random()*nspan)+1;
}
console.log(getRandNum(10,20),numSeq);
//testing:
//getRandNum(-10,20);
//console.log(getRandNum(-10,20),numSeq);
//console.log(numSeq);
function getRandomInt(lower, upper)
{
//to create an even sample distribution
return Math.floor(lower + (Math.random() * (upper - lower + 1)));
//to produce an uneven sample distribution
//return Math.round(lower + (Math.random() * (upper - lower)));
//to exclude the max value from the possible values
//return Math.floor(lower + (Math.random() * (upper - lower)));
}
Чтобы проверить эту функцию и варианты этой функции, сохраните ниже HTML/JavaScript в файл и откройте его в браузере. В коде будет показан график, показывающий распределение одного миллиона вызовов функций. Код также будет записывать случаи краев, поэтому, если функция вырабатывает значение, большее, чем max, или меньше, чем min, you.will.know.about.it.
<html>
<head>
<script type="text/javascript">
function getRandomInt(lower, upper)
{
//to create an even sample distribution
return Math.floor(lower + (Math.random() * (upper - lower + 1)));
//to produce an uneven sample distribution
//return Math.round(lower + (Math.random() * (upper - lower)));
//to exclude the max value from the possible values
//return Math.floor(lower + (Math.random() * (upper - lower)));
}
var min = -5;
var max = 5;
var array = new Array();
for(var i = 0; i <= (max - min) + 2; i++) {
array.push(0);
}
for(var i = 0; i < 1000000; i++) {
var random = getRandomInt(min, max);
array[random - min + 1]++;
}
var maxSample = 0;
for(var i = 0; i < max - min; i++) {
maxSample = Math.max(maxSample, array[i]);
}
//create a bar graph to show the sample distribution
var maxHeight = 500;
for(var i = 0; i <= (max - min) + 2; i++) {
var sampleHeight = (array[i]/maxSample) * maxHeight;
document.write('<span style="display:inline-block;color:'+(sampleHeight == 0 ? 'black' : 'white')+';background-color:black;height:'+sampleHeight+'px"> [' + (i + min - 1) + ']: '+array[i]+'</span> ');
}
document.write('<hr/>');
</script>
</head>
<body>
</body>
</html>
Генерация случайного числа из пяти цифр
function rn(min, max){
return Math.floor(Math.random() * min + max);
}
пример
rn(2342, 9999)
Надеюсь, поможет
Мне стало интересно, каким будет распределение после достаточного количества прогонов для такой функции рандомизатора.
А также проверить, будет ли это распределение более или менее одинаковым в разных браузерах.
Так что здесь фрагмент для запуска. Цифры могут быть изменены до нажатия кнопки.
function getRandomNumberInRange(Min, Max) {
return Math.floor(Math.random() * (Max - Min + 1)) + Min;
}
function printDictAsTable(dict){
let htmlstr = "<table border=1><tr><th>Number</th><th>Count</th></tr>";
let sortedKeys = Object.keys(dict).sort(function(a,b){return a-b});
for (let i=0; i<sortedKeys.length; i++) {
let key = sortedKeys[i];
htmlstr += "<tr><td>"+ key +" </td><td>" + dict[key] + " </td></tr>";
}
htmlstr += "</table>";
document.getElementById("tableContainer").innerHTML = htmlstr;
}
function loopRandomAndPrint(){
let min = Number(document.getElementById("randomMinLimit").value);
let max = Number(document.getElementById("randomMaxLimit").value);
if (max < min){let temp = max; max = min; min = temp;}
let loopTotal = Number(document.getElementById("loopLimit").value);
let dict = {};
for(i = min; i <= max; ++i){
dict[i] = 0;
}
for(i = 0; i < loopTotal; i++){
let num = getRandomNumberInRange(min, max);
dict[num] = dict[num] + 1;
}
printDictAsTable(dict);
}
loopRandomAndPrint();
<div id="topContainer">
<div id="inputAndButton" style="float: left;">
<p>Min : <input type="number" id="randomMinLimit" value=4></p>
<p>Max : <input type="number" id="randomMaxLimit" value=8></p>
<p>Loops: <input type="number" id="loopLimit" value=1000></p>
<button type="button" onclick="loopRandomAndPrint()">
Loop random function and show </button>
</div>
<div id="tableContainer" style="float: right;">
</div>
</div>
Альтернативное решение: -
let makeGuess = function(guess){
let min = 1;
let max = 5;
let randomNumber = Math.floor(Math.random() * (max - min + 1)) + min
return guess === randomNumber;
}
console.log(makeGuess(1));
/* Написать функцию с именем randUpTo
которая принимает число и возвращает случайное целое число от 0 до этого числа? */
var randUpTo = function(num) {
return Math.floor(Math.random() * (num - 1) + 0);
};
/* Напишите функцию с именем randBetween
которая принимает два числа, представляющих диапазон, и возвращает случайное целое число между этими двумя числами. */
var randBetween = function (min, max) {
return Math.floor(Math.random() * (max - min - 1)) + min;
};
/* Напишите функцию с именем randFromTill
которая принимает два числа, представляющих диапазон, и возвращает случайное число между min (включительно) и max (эксклюзивом). */
var randFromTill = function (min, max) {
return Math.random() * (max - min) + min;
};
/* Напишите функцию с именем randFromTo
которая принимает два числа, представляющих диапазон, и возвращает случайное целое число от min (включительно) до max (включительно) */
var randFromTo = function (min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
};
Это может обрабатывать генерирование до 20 цифр UNIQUE случайных чисел
JS
var generatedNumbers = [];
function generateRandomNumber(precision) { // precision --> number precision in integer
if (precision <= 20) {
var randomNum = Math.round(Math.random().toFixed(precision) * Math.pow(10, precision));
if (generatedNumbers.indexOf(randomNum) > -1) {
if (generatedNumbers.length == Math.pow(10, precision))
return "Generated all values with this precision";
return generateRandomNumber(precision);
} else {
generatedNumbers.push(randomNum);
return randomNum;
}
} else
return "Number Precision shoould not exceed 20";
}
generateRandomNumber(1);