Генерирование случайных целых чисел в JavaScript в определенном диапазоне?
Как я могу генерировать случайные целые числа между двумя указанными переменными в JavaScript, например, x = 4 и y = 8 будет выводить любое из 4, 5, 6, 7, 8?
Ответы
Ответ 1
На странице 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.
Ответ 2
var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
Ответ 3
Из документации 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;
Ответ 4
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
ПРИМЕЧАНИЕ. Если вы передадите не целое значение или большее число, вы получите нежелательное поведение, но, если кто-либо его не попросит, я не буду вникать в код проверки аргументов, поскольку он довольно далек от намерения оригинальный вопрос.
Ответ 5
function randomRange(min, max) {
return ~~(Math.random() * (max - min + 1)) + min
}
Альтернативно, если вы используете Underscore.js, вы можете использовать
_.random(min, max)
Ответ 6
Возвращает случайное число от 1 до 10:
Math.floor((Math.random()*10) + 1);
Возвращает случайное число от 1 до 100:
Math.floor((Math.random()*100) + 1)
Ответ 7
Если вам нужна переменная между 0 и max, вы можете использовать:
Math.floor(Math.random() * max);
Ответ 8
В других ответах не учитываются вполне разумные параметры 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
Ответ 9
Вот 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
Ответ 10
Используйте эту функцию, чтобы получить случайные числа между заданным диапазоном
function rnd(min,max){
return Math.floor(Math.random()*(max-min+1)+min );
}
Ответ 11
После создания случайного числа с использованием компьютерной программы он по-прежнему считается случайным числом, если выбранное число является частью или полным из исходного. Но если он был изменен, то математики не принимают его как случайное число, и они могут называть его предвзятым числом. Но если вы разрабатываете программу для простой задачи, это не будет случай рассматривать. Но если вы разрабатываете программу для генерации случайного числа для ценного материала, такого как лотерейная программа или игра в азартные игры, тогда ваша программа будет отклонена руководством, если вы не будете рассматривать этот случай.
Итак, для тех людей, вот мое предложение:
Создайте случайное число, используя 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, чтобы открыть консоль)
Ответ 12
Для случайного целого с диапазоном, попробуйте:
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;
}
Ответ 13
Чтобы получить случайное число, скажем, между 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 от минимального значения, вы по существу предотвращаете округление максимального значения.
Надеюсь, что это поможет.
Ответ 14
Используя следующий код, вы можете генерировать массив случайных чисел без повторения в заданном диапазоне.
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;
}
Ответ 15
Я знаю, что этот вопрос уже ответил, но мой ответ может помочь кому-то.
Я нашел этот простой метод в W3Schools:
Math.floor((Math.random() * max) + min);
Надеюсь, это поможет кому-то.
Ответ 16
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>
Ответ 17
Случайное целое число между самым низким и самым высоким:
function randomRange(l,h){
var range = (h-l);
var random = Math.floor(Math.random()*range);
if (random === 0){random+=1;}
return l+random;
}
Не самое элегантное решение.. но что-то быстрое.
Ответ 18
Здесь я использую для генерации случайных чисел.
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
Ответ 19
<!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. Этот код очень короткий.
Ответ 20
Вот пример функции 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;
}
Ответ 21
это мой выбор случайного числа в диапазоне, так как я хотел получить случайное число в диапазоне от базового до экспоненты. например 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);
Ответ 22
Math.random() быстр и подходит для многих целей, но он не подходит, если вам нужны криптографически безопасные значения (небезопасные) или если вам нужны целые числа из абсолютно равномерного несмещенного распределения (подход умножения, используемый в других ответах, дает некоторые значения немного чаще, чем другие).
В таких случаях мы можем использовать crypto.getRandomValues() для генерации безопасных целых чисел и отклонения любых сгенерированных значений, которые мы не можем равномерно отобразить в целевой диапазон. Это будет медленнее, но это не должно быть значительным, если вы не генерируете очень большое количество значений.
Чтобы прояснить проблему смещенного распределения, рассмотрим случай, когда мы хотим сгенерировать значение от 1 до 5, но у нас есть генератор случайных чисел, который выдает значения от 1 до 16 (4-битное значение). Мы хотим иметь одинаковое количество сгенерированных значений, сопоставляемых с каждым выходным значением, но 16 не делится поровну на 5: остается остаток от 1. Поэтому нам нужно отклонить 1 из возможных сгенерированных значений и продолжить только тогда, когда мы получим одно из 15 меньших значений, которые могут быть равномерно отображены в нашем целевом диапазоне. Наше поведение может выглядеть следующим образом:
Generate a 4-bit integer in the range 1-16.
If we generated 1, 6, or 11 then output 1.
If we generated 2, 7, or 12 then output 2.
If we generated 3, 8, or 13 then output 3.
If we generated 4, 9, or 14 then output 4.
If we generated 5, 10, or 15 then output 5.
If we generated 16 then reject it and try again.
В следующем коде используется аналогичная логика, но вместо этого генерируется 32-разрядное целое число, поскольку это самый большой общий целочисленный размер, который может быть представлен стандартным number типом JavaScript. (Это можно изменить, чтобы использовать BigInt если вам нужен больший диапазон.) Независимо от выбранного диапазона, доля генерируемых значений, которые отклоняются, всегда будет меньше 0,5, поэтому ожидаемое количество отклонений всегда будет меньше 1,0, и обычно близко к 0.0; Вам не нужно беспокоиться о том, что это зациклится навсегда.
const randomInteger = (min, max) => {
const range = max - min;
const maxGeneratedValue = 0xFFFFFFFF;
const possibleResultValues = range + 1;
const possibleGeneratedValues = maxGeneratedValue + 1;
const remainder = possibleGeneratedValues % possibleResultValues;
const maxUnbiased = maxGeneratedValue - remainder;
if (!Number.isInteger(min) || !Number.isInteger(max) ||
max > Number.MAX_SAFE_INTEGER || min < Number.MIN_SAFE_INTEGER) {
throw new Error('Arguments must be safe integers.');
} else if (range > maxGeneratedValue) {
throw new Error('Range of ${range} (from ${min} to ${max}) > ${maxGeneratedValue}.');
} else if (max < min) {
throw new Error('max (${max}) must be >= min (${min}).');
} else if (min === max) {
return min;
}
let generated;
do {
generated = crypto.getRandomValues(new Uint32Array(1))[0];
} while (generated > maxUnbiased);
return min + (generated % possibleResultValues);
};
console.log(randomInteger(-8, 8)); // -2
console.log(randomInteger(0, 0)); // 0
console.log(randomInteger(0, 0xFFFFFFFF)); // 944450079
console.log(randomInteger(-1, 0xFFFFFFFF));
// Error: Range of 4294967296 covering -1 to 4294967295 is > 4294967295.
console.log(new Array(12).fill().map(n => randomInteger(8, 12)));
// [11, 8, 8, 11, 10, 8, 8, 12, 12, 12, 9, 9]
Ответ 23
Вы можете этот фрагмент кода,
let randomNumber = function(first,second){
let number = Math.floor(Math.random()*Math.floor(second));
while(number<first){
number = Math.floor(Math.random()*Math.floor(second));
}
return number;
}
Ответ 24
Это может обрабатывать генерирование до 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);
![введите описание изображения здесь]()
JsFiddle
Ответ 25
/* Написать функцию с именем 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;
};
Ответ 26
Я сделал эту функцию, которая учитывает такие параметры, как min, max, exclude (список целых чисел, которые нужно исключить) и seed (на случай, если вам нужен генератор случайных чисел с семенами).
get_random_int = function(args={})
{
let def_args =
{
min: 0,
max: 1,
exclude: false,
seed: Math.random
}
args = Object.assign(def_args, args)
let num = Math.floor(args.seed() * (args.max - args.min + 1) + args.min)
if(args.exclude)
{
let diff = args.max - args.min
let n = num
for(let i=0; i<diff*2; i++)
{
if(args.exclude.includes(n))
{
if(n + 1 <= args.max)
{
n += 1
}
else
{
n = args.min
}
}
else
{
num = n
break
}
}
}
return num
}
Может использоваться как:
let n = get_random_int
(
{
min: 0,
max: some_list.length - 1,
exclude: [3, 6, 5],
seed: my_seed_function
}
)
Или проще:
let n = get_random_int
(
{
min: 0,
max: some_list.length - 1
}
)
Тогда вы можете сделать:
let item = some_list[n]
Суть: https://gist.github.com/madprops/757deb000bdec25776d5036dae58ee6e
Ответ 27
- random (min, max) генерирует случайное число от min (включительно) до max (исключая)
Math.floor округляет число до ближайшего целого числа
function generateRandomInteger (min, max) {
return Math.floor(random(min,max))
}'
Таким образом, чтобы сгенерировать случайное целое число от 4 до 8 включительно, вызовите вышеуказанную функцию со следующими аргументами:
generateRandomInteger (4,9)
Ответ 28
Чтобы получить крипто-сильное случайное целое число в ragne [x, y], попробуйте
let rand= (x,y)=> x+(y-x+1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32|0
console.log(rand(4,8))
Ответ 29
Ionuț G. Stan написал отличный ответ, но он был слишком сложным для меня, чтобы понять. Итак, я нашел еще более простое объяснение тех же понятий в https://teamtreehouse.com/community/mathfloor-mathrandom-max-min-1-min-explanation Джейсоном Анелло.
ПРИМЕЧАНИЕ: Единственная важная вещь, которую вы должны знать перед прочтением объяснения Джейсона, - это определение "усечь". Он использует этот термин при описании Math.floor(). Оксфордский словарь определяет "усечение" как:
Укоротить (что-то), отрезав верх или конец.
Ответ 30
Альтернативное решение: -
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));
