javascript - числа - как сгенерировать случайное число в диапазоне




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

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


Math.random()

Из документации Math.random() 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;

/ * Напишите функцию 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;
};

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

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

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

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

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

Вот что я использую для генерации случайных чисел.

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


Для случайного целого с диапазоном, попробуйте:

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

Мне стало интересно, как распределение после достаточного количества прогонов будет для такой функции рандомизатора.

А также проверить, будет ли это распределение более или менее одинаковым в разных браузерах.

Итак, вот фрагмент для запуска. Номера можно изменить, прежде чем нажимать кнопку.

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>


После генерации случайного числа с использованием компьютерной программы он по-прежнему считается случайным числом, если выбранное число является частью или полным из исходного. Но если это было изменено, то математики не принимают его как случайное число, и они могут называть его предвзятым числом. Но если вы разрабатываете программу для простой задачи, это не будет рассматриваться. Но если вы разрабатываете программу для генерации случайного числа для ценного материала, такого как лотерейная программа или игра в азартные игры, то ваша программа будет отклонена руководством, если вы не будете рассматривать этот случай.

Итак, для тех людей, вот мое предложение:

Создайте случайное число, используя 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, чтобы открыть консоль)


Привет, ребята, я создал функцию javascript, такую ​​же, как Math.random (), с помощью которой мы можем генерировать случайное число любой заданной длины . Без использования какой- либо функции 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;
    }

Чтобы получить случайное число, скажем от 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 от минимального значения, вы по существу предотвращаете округление максимального значения.

Надеюсь, это поможет.


Это может обрабатывать генерацию до 20-значного УНИКАЛЬНОГО случайного числа

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


это мой выбор случайного числа в диапазоне, так как я хотел получить случайное число в диапазоне от базового до экспоненты. например 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);

    <!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. Этот код очень короткий.


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

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

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


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

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

_.random(min, max)

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




integer