Вопрос: Генерирование случайных целых чисел в JavaScript в определенном диапазоне?


Как я могу генерировать случайное целое число между двумя указанными переменными в Javascript, например. x = 4а также y = 8будет выводить любой из 4, 5, 6, 7, 8?


1451


источник


Ответы:


Есть несколько примеров Сеть разработчиков Mozilla страница:

/**
 * 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)
 * Using Math.round() will give you a non-uniform distribution!
 */
function getRandomInt(min, 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результат тоже.


2975



var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;

447



Math.random ()

Из Mozilla Документация разработчика:

// 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;

68



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+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


ПРИМЕЧАНИЕ. Если вы передадите не целое число или большее число, вы получите нежелательное поведение, но если кто-либо его не попросит, я не буду вникать в код проверки аргументов, поскольку он довольно далеко от цели исходного вопроса ,


47



function randomRange(min, max) {
  return ~~(Math.random() * (max - min + 1)) + min
}

Альтернатива, если вы используете Underscore.js вы можете использовать

_.random(min, max)

26



Возвратите случайное число от 1 до 10:

Math.floor((Math.random()*10) + 1); 

Возвращает случайное число от 1 до 100:

Math.floor((Math.random()*100) + 1)

26



В других ответах не учитываются вполне разумные параметры 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

12



After generating a random number using a computer program, it is still consider as a random number if the picked number is a part or the full one of the initial one. But if it was changed, then mathematicians are not accept it as a random number and they can call it a biased number. But if you are developing a program for a simple task, this will not be a case to consider. But if you are developing a program to generate a random number for a valuable stuff such as lottery program, or gambling game, then your program will be rejected by the management if you are not consider about the above case.

So for those kind of people, here is my suggestion:

Generate a random number using Math.random().(say this 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.

If you know how to read random number table to pick a random number, you know above process(multiplying by 1, 10, 100 and so on) is not violates the one that I was mentioned at the beginning.( Because it changes only the place of the decimal point.)

Study the following example and develop it to your needs.

If you need a sample [0,9] then floor of n*10 is your answer and if need [0,99] then floor of n*100 is your answer and so on.

Now let enter into your role:

You've asked numbers among specific range. (In this case you are biased among that range. - By taking a number from [1,6] by roll a die, then you are biased into [1,6] but still it is a random if and only if die is unbiased.)

So consider your range ==> [78, 247] number of elements of the range = 247 - 78 + 1 = 170; (since both the boundaries are inclusive.

/*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);

Note: In method one, first I created an array which contains numbers that you need and then randomly put them into another array. In method two, generate numbers randomly and check those are in the range that you need. Then put it into an array. Here I generated two random numbers and used total of them to maximize the speed of the program by minimizing the failure rate that obtaining a useful number. However adding generated numbers will also give some biassness. So I would recommend my first method to generate random numbers within a specific range.

In both methods, your console will show the result.(Press f12 in Chrome to open the console)


9



For a random integer with a range, try:

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;
}

8



Here is the MS DotNet Implementation of Random class in 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;
}());

Use:

        var r = new Random();
        var nextInt = r.Next(1, 100); //returns an integer between range
        var nextDbl = r.NextDouble(); //returns a random decimal

8