在JavaScript中生成特定范围内的随机整数？_Javascript_Random_Integer

在JavaScript中生成特定范围内的随机整数？

javascript random

在JavaScript中生成特定范围内的随机整数？,javascript,random,integer,Javascript,Random,Integer,如何在JavaScript中的两个指定变量之间生成随机整数，例如x=4和y=8将输出4、5、6、7、8中的任意一个？页面上有一些示例：这是背后的逻辑。这是一条简单的三条规则： Math.random（）返回一个介于0（包含）和1（排除）之间的数字。我们有一个这样的间隔： [0 .................................... 1) 现在，我们想要一个介于min（包括）和max（不包括）之间的数字：我们可以使用Math.random获得[min，max]区间内的对应

如何在JavaScript中的两个指定变量之间生成随机整数，例如

x=4

和

y=8

将输出

4、5、6、7、8

中的任意一个？

页面上有一些示例：

这是背后的逻辑。这是一条简单的三条规则：

Math.random（）

返回一个介于0（包含）和1（排除）之间的

数字。我们有一个这样的间隔：
[0 .................................... 1)

现在，我们想要一个介于min
（包括）和max
（不包括）之间的数字：
我们可以使用Math.random
获得[min，max]区间内的对应值。但是，首先我们应该通过从第二个区间减去min
来考虑问题：
[0 .................................... 1)
[min - min ............................ max - min)

x = Math.random() * (max - min) + 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]间隔内的一个数字：
[0 .................................... 1)
[min - min ............................ max - min)

x = Math.random() * (max - min) + min;

这是MDN中的第一个函数。第二个函数返回一个介于min
和max
之间的整数，两者都包含在内
/*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);

现在，要获取整数，可以使用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
结果
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.
}

Math.random（）
返回一个介于0和1之间的随机双精度，如果我们将它乘以1加上top
和bottom
之间的差值，我们将得到一个介于0
和1+b-a
之间的双精度
Math.floor( Math.random() * ( 1 + top - bottom ) )

Math.floor
将数字向下舍入到最接近的整数。因此，我们现在有了0
和上下
之间的所有整数。1看起来令人困惑，但它必须在那里，因为我们总是向下舍入，因此没有它，实际上永远不会到达顶部数字。我们生成的随机小数必须在范围0
到（1+上下）
因此我们可以向下取整，得到范围0
到上下

Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom

上一个示例中的代码为我们提供了一个范围0
和top-bottom
的整数，因此我们现在需要做的就是将bottom
添加到该结果中，以获得范围bottom
和top
的整数。：D

注意：如果您首先传入一个非整数值或更大的数值，您将得到不受欢迎的行为，但除非有人请求，否则我不会深入研究参数检查代码，因为它与原始问题的意图相去甚远
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保存到一个文件中，并使用浏览器打开。代码将生成一个图形，显示一百万个函数调用的分布。代码还将记录边缘情况，因此，如果函数生成的值大于最大值或小于最小值，则您将.k现在，关于它
<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">&nbsp;[' + (i + min - 1) + ']:&nbsp;'+array[i]+'</span>&nbsp;&nbsp;');
        }
        document.write('<hr/>');
        </script>
    </head>
    <body>

    </body>
</html>


函数getRandomInt（下、上）
{
//创建均匀样本分布的步骤
返回Math.floor（下+（Math.random（）*（上-下+1））；
//产生不均匀的样本分布
//返回Math.round（下限+（Math.random（）*（上限-下限））；
//从可能值中排除最大值的步骤
//返回Math.floor（下+（Math.random（）*（上-下））；
}
var min=-5；
var max=5；
var数组=新数组（）；
对于（var i=0；i对于具有范围的随机整数，请尝试：
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;
}

如果您使用的是，则可以使用
_.random(min, max)

用计算机程序生成随机数后，如果被选取的数是初始数的一部分或全部，它仍然被认为是随机数。但是如果它被改变了，那么<强>数学家不会接受它作为一个随机数，它可以称之为有偏数。< /强>但是如果你正在为一个SIM开发程序。PLE任务，这不是一个需要考虑的问题。<强>但是如果你正在开发一个程序来生成一个有价值的东西，比如彩票计划或赌博游戏的随机数，那么你的程序将被管理者拒绝，如果你不考虑上述情况。< /强> 
因此，对于这类人，我的建议如下：
使用Math.random（）
生成一个随机数（这样说n
）
如果您知道如何读取随机数表来选择随机数，那么您就知道上面的过程（乘以1、10、100等等）与我在开头提到的过程没有冲突（因为它只更改小数点的位置）
研究以下示例并根据您的需要进行开发
如果你需要一个样本[0,9]，那么n*10是你的答案，如果你需要[0,99]，那么n*100是你的答案，依此类推
现在让我们进入您的角色：
您已经询问了特定范围内的数字。（在本例中，您在该范围内有偏差。-通过掷骰子从[1,6]中取一个数字，那么您将有偏差进入[1,6]，但当且仅当骰子无偏差时，它仍然是随机的。）
考虑你的范围＝> >〔78, 247〕
范围内的元素数量=247-78+1=170；（si）
function randomRange(min, max) {
  return ~~(Math.random() * (max - min + 1)) + min
}

_.random(min, max)

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.

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

    0.5 + (Math.random() * ((6 - 1) + 1))

    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;

function randomRange(l,h){
  var range = (h-l);
  var random = Math.floor(Math.random()*range);
  if (random === 0){random+=1;}
  return l+random;
}

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

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

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

function random(high,low) {
    high++;
    return Math.floor((Math.random())*(high-low))+low;
}

function randomInteger(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

function randomNumber(min, max) {
  return Math.random() * (max - min) + 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 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;
        }

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

Math.floor((Math.random() * max) + min);

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

Math.floor(Math.random() *  max);

var randUpTo = function(num) {
    return Math.floor(Math.random() * (num - 1) + 0);
};

var randBetween = function (min, max) {
    return Math.floor(Math.random() * (max - min - 1)) + min;
};

var randFromTill = function (min, max) {
    return Math.random() * (max - min) + min;
};

var randFromTo = function (min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
};

function rnd(min,max){
    return Math.floor(Math.random()*(max-min+1)+min );
}

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

Math.floor((Math.random() * 10) % n)

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