Как я могу генерировать случайные целые числа между двумя указанными переменными в 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;
}
& Лт; hr >
Вот логика, стоящая за этим. Это простое правило трех:
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
.
var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
Из документации 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
, мы получим двойной где-то между0
и 1 + б-а
.
Math.floor( Math.random() * ( 1 + top - bottom ) )
Math.floor
округляет число до ближайшего целого числа. Таким образом, теперь у нас есть все целые числа между 0
и top-bottom
. 1 выглядит запутанно, но он должен быть там, потому что мы всегда округляемся вниз, поэтому верхний номер никогда не будет достигнут без него. Случайный десятичный знак, который мы генерируем, должен находиться в диапазоне от «0» до «(1 + верхний нижний)», чтобы мы могли округлить и получить int в диапазоне от «0» до «верхнего дна»
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)
Если вам нужна переменная от 0 до макс, вы можете использовать:
Math.floor(Math.random() * max);
Другие ответы не учитывают совершенно разумные параметры 0
и 1
. Вместо этого вы должны использовать round
instead 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
Вот MS DotNet Реализация случайного класса в 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 rnd(min,max){
return Math.floor(Math.random()*(max-min+1)+min );
}
После генерации случайного числа с помощью компьютерной программы оно все равно рассматривается как случайное число, если выбранное число является частью или полным начальным. Но если это было изменено, то математики не принимают это как случайное число, и они могут назвать это предвзятым числом. Но если вы разрабатываете программу для простой задачи, это не будет иметь значения. Но если вы разрабатываете программу для генерации случайного числа для ценных вещей, таких как лотерейная программа или азартная игра, тогда ваша программа будет отклонена руководством, если вы не рассматриваете вышеупомянутый случай.
Итак, для таких людей, вот мое предложение:
Сгенерируйте случайное число, используя 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, чтобы открыть консоль)
Для случайного целого числа с диапазоном попробуйте:
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;
}
Я знаю, что на этот вопрос уже дан ответ, но мой ответ может кому-то помочь.
Я нашел этот простой метод в W3Schools:
Math.floor((Math.random() * max) + min);
Надеюсь, это кому-нибудь поможет.
Чтобы получить случайное число, скажем, от 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 из минимального значения, вы по существу предотвращаете округление максимального значения.
Надеюсь, это поможет.
Используя следующий код, вы можете генерировать массив случайных чисел, не повторяя, в заданном диапазоне.
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;
}
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 в файле и откройте с помощью браузера. Код будет создавать graph , показывающий распределение одного миллиона вызовов функций. Код также будет записывать крайние случаи, поэтому, если функция выдает значение, превышающее максимальное, или меньше минимального, 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 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 или 7
Вот пример функции 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;
}
<!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 создает массив, заполненный цифрой до 3 цифр, которая будет максимум 999. Этот код очень короткий.