특정 범위의 JavaScript에서 임의의 정수 생성

특정 범위의 JavaScript에서 임의의 정수 생성

예를 들어 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;
}

---

그 배경에는 이런 논리가 있다.간단한 세 가지 규칙입니다.

Math.random()를 반환하다Number에서 1입니다. 0(으)로 1(으)로 하다.라음

[0 .................................... 1)

이번에는 , 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아,min 및 (기호) »max필수):

[0 .................................... 1)
[min .................................. max)

, 그럼 이렇게 .Math.random[min, max] 이에요. 이 요, 뺄게요, 뺄게요.min부터: "Manager" "Manager: "Manager:

[0 .................................... 1)
[min - min ............................ max - min)

그 결과, 다음과 같이 됩니다.

[0 .................................... 1)
[0 .................................... max - min)

, 그럼 이제 now we we 、 금 、 지 、 、 we 、 we 、 、 。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;

Math.random()

min(포함)과 max(포함) 사이의 정수 난수를 반환합니다.

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;

** 그리고 항상 상기시켜줘 (모질라) :

Math.random()은 암호학적으로 안전한 난수를 제공하지 않습니다.보안과 관련된 용도로 사용하지 마십시오.대신 Web Crypto API, 보다 정확하게는 window.crypto.getRandomValues() 메서드를 사용합니다.

용도:

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, 4,, 6을 1, 2, 3, 4, 5, 6, 2, 3, 4, 5, 6은 6을 반환한다.

('하단'은 작은 숫자, '위'는 큰 숫자)

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

Math.random()1 또, 에 0의 , 1의 2배의 차이가 됩니다.top ★★★★★★★★★★★★★★★★★」bottom 사이 수 0 ★★★★★★★★★★★★★★★★★」1+b-a.

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

Math.floor는 숫자를 가장 가까운 정수로 반올림합니다., 이 사이에 가 다 요.0 ★★★★★★★★★★★★★★★★★」top-bottom 반올림하기 할 수 . 1은 혼란스러워 보이지만, 항상 반올림하기 때문에 1이 있어야 합니다.따라서 실제로는 1이 없으면 상위에 도달할 수 없습니다.우리가 생성하는 랜덤 소수점은 다음 범위 내에 있어야 합니다.0로로 합니다.(1+top-bottom)해서 '반올림해서' '반올림해서' 수 .0로로 합니다.top-bottom:

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

에서는 '를 '정수'로 했습니다.0 ★★★★★★★★★★★★★★★★★」top-bottom은 「」를 추가하는 것 bottom, 「」의 의 할 수 있습니다.bottom ★★★★★★★★★★★★★★★★★」top. : D 포 : D

---

메모: 정수 이외의 값이나 큰 값을 먼저 건네주면 바람직하지 않은 동작이 발생하지만, 누군가가 요청하지 않는 한 인수 체크 코드를 자세히 설명하지 않습니다.원래 질문의 의도와는 거리가 멀기 때문입니다.

이 모든 솔루션들이 너무 많은 화력을 사용하고 있다.호출할 필요가 있는 함수는 1개뿐입니다.Math.random();

Math.random() * max | 0;

0(포함)에서 최대(비포함) 사이의 임의의 정수를 반환합니다.

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 대신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

암호화 기능 강화

[x,y] 범위에서 암호학적으로 강력한 랜덤 정수 값을 얻으려면 다음을 수행합니다.

let cs = (x,y) => x + (y - x + 1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32 | 0

console.log(cs(4, 8))

이 함수를 사용하여 지정된 범위의 난수를 가져옵니다.

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

난수 생성에 사용하는 방법은 다음과 같습니다.

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

Math.random()는 0(표준)에서 1(표준) 사이의 숫자를 반환합니다.))) （ max - min ） 。그 결과 0(포함)과 범위 사이의 숫자가 됩니다.

를 들어, 「」를 예로 들면,random(2,5)0 xx < 1 에5 ( 5 - 2 = 3) 곱 0 0 <<x < 3 인 0 0 0 0 0 0 0 >

계산에 합니다. 즉, 1은 범위 계산에 됩니다.Math.random()*(max-min+1)5-2+1=4)는 0x로 합니다.이 계산을 바닥으로 하면 각 결과의 우도(1/4)가 같은 정수: 0µx33이 됩니다.

마지막으로 요청된 값 사이의 정수로 변환해야 합니다.이미 0과 (max-min) 사이의 정수가 있기 때문에 최소값을 추가하여 값을 올바른 범위에 매핑할 수 있습니다.이 예에서는 0과 3 사이의 정수를 2로 더하면 2와 5 사이의 정수가 됩니다.

이것은 Microsoft 입니다.JavaScript에서의 랜덤클래스의 NET 실장:

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

컴퓨터 프로그램을 사용하여 난수를 생성한 후에도 선택한 숫자가 첫 번째 숫자의 일부 또는 전체 숫자일 경우 난수로 간주됩니다.하지만 만약 그것이 바뀌면, 수학자들은 그것을 난수로 받아들이지 않고 그들은 그것을 편향된 숫자라고 부를 수 있다.

그러나 간단한 작업을 위해 프로그램을 개발하는 경우에는 고려할 필요가 없습니다.그러나 복권 프로그램이나 도박 게임과 같은 가치 있는 물건의 난수를 생성하는 프로그램을 개발하고 있다면, 위의 경우를 고려하지 않으면 경영진은 당신의 프로그램을 거절할 것입니다.

그런 분들을 위해 제가 제안하는 것은 다음과 같습니다.

를 사용하여 합니다.Math.random() 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 square bracket indicates that the boundary is inclusive and a round bracket indicates the boundary is exclusive.

그리고 소수점 뒤의 나머지를 제거합니다.(즉, 플로어를 가져옵니다) - Math.floor()를 사용합니다.이것은 할 수 있다.

난수표를 읽고 난수를 선택하는 방법을 알고 있다면 위의 프로세스(1, 10, 100을 곱한 것 등)는 처음에 언급한 프로세스(1진수점 자리만 변경되기 때문에)에 위반되지 않습니다.

다음 예를 학습하여 필요에 따라 개발하십시오.

샘플 [0,9]이 필요한 경우 n10 바닥이 답이고 [0,99]가 필요한 경우 n100 바닥이 답입니다.

이제 자신의 역할에 대해 설명하겠습니다.

특정 범위의 숫자를 요청했습니다.(이 경우, 그 범위로 치우쳐 있습니다.주사위를 굴려 [1,6]에서 숫자를 취하면 [1,6]으로 치우치지만 주사위가 치우치지 않은 경우에만 랜덤 숫자입니다.)

따라서 범위 ==> [78, 247] 범위의 요소 수 = 247 - 78 + 1 = 170;(두 경계 모두 포함되므로)를 고려하십시오.

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

주의: 첫 번째 방법에서는 필요한 숫자를 포함하는 배열을 작성한 후 무작위로 다른 배열에 배치했습니다.

방법 2에서는 숫자를 랜덤으로 생성하여 필요한 범위 내에 있는지 확인합니다.그런 다음 배열에 넣습니다.여기서 나는 두 개의 난수를 생성하고 그 합계를 사용하여 유용한 숫자를 얻는 실패율을 최소화함으로써 프로그램의 속도를 극대화했다.그러나 생성된 숫자를 더하는 것도 어느 정도 편향성을 갖게 됩니다.따라서 특정 범위 내에서 난수를 생성하는 첫 번째 방법을 추천합니다.

두 방법 모두 콘솔에 결과가 표시됩니다(콘솔을 열려면 Chrome을 누르십시오).

예를 들어 설명하겠습니다.

JavaScript에서 5~25 범위의 임의의 정수를 생성하는 함수

개요:

(i) 먼저 0부터 시작하는 범위로 변환한다.

(ii) 원하는 범위로 변환합니다(그러면 매우 쉽게 완료할 수 있습니다).

따라서 기본적으로 5에서 25까지의 임의의 정수를 생성하는 경우:

첫 번째 단계:범위로 변환 - 0부터 시작

"max"와 "min" 모두에서 "lower/minimum number"를 뺍니다.

(5-5) - (25-5)

따라서 범위는 다음과 같습니다.

0-20... 맞죠?

순서 2

두 숫자 모두 범위에 포함되도록 하려면(0과 20) 방정식은 다음과 같습니다.

방정식: 수학방방:::Math.floor((Math.random() * 21))

: 반반방: :Math.floor((Math.random() * (max-min +1)))

이제 범위에 감산/소수(예: 5)를 추가하면 자동으로 0 ~ 20 = > 5 ~ 25 범위를 얻을 수 있습니다.

스텝 3

이제 방정식에서 뺀 차이(즉, 5)를 더하고 전체 방정식에 "Math.floor"를 추가합니다.

방정식: 수학방방:::Math.floor((Math.random() * 21) + 5)

: 반반방: :Math.floor((Math.random() * (max-min +1)) + min)

마지막으로 기능은 다음과 같습니다.

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

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를 파일에 저장한 후 브라우저에서 엽니다.이 코드에서는 100만 개의 함수 호출 분포를 나타내는 그래프가 생성됩니다.이 코드에서는 엣지 케이스도 기록됩니다.따라서 함수가 최대값 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">&nbsp;[' + (i + min - 1) + ']:&nbsp;'+array[i]+'</span>&nbsp;&nbsp;');
        }
        document.write('<hr/>');
        </script>
    </head>
    <body>

    </body>
</html>

범위가 있는 임의의 정수의 경우 다음을 수행합니다.

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

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를 삭제하는 이유는 최소값만 사용하면 최대값보다 1 많은 정수를 얻을 수 있기 때문입니다.최소값에서 0.5를 빼면 최대값이 반올림되지 않습니다.

다음 코드를 사용하면 특정 범위에서 반복하지 않고 난수 배열을 생성할 수 있습니다.

function genRandomNumber(how_many_numbers, min, max) {

    // Parameters
    //
    //   how_many_numbers: 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):  Maximum 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_numbers; 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;
}

다음은 최소값과 최대값 사이의 난수를 생성하는 함수입니다.

const randomInt = (max, min) => Math.round(Math.random() * (max - min)) + min;

최소값과 최대값 사이의 임의의 정수:

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

가장 우아한 해결책은 아니지만 빠른 해결책이다.

W3 Schools에서 다음과 같은 간단한 방법을 찾았습니다.

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

Math.random()는 빠르고 다양한 목적에 적합하지만 암호적으로 안전한 값(안전하지 않음)이 필요한 경우 또는 완전히 균일한 치우침이 없는 분포의 정수가 필요한 경우(다른 응답에 사용되는 곱셈 접근법에 의해 특정 값이 다른 응답보다 약간 더 자주 생성됩니다).

런런 in in를 사용할 수 .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.

는 유사한합니다. JavaScript의 수 큰입니다. 왜냐하면 이 정수는 JavaScript 표준으로 나타낼 수 있는 가장 큰 공통 정수 크기이기 때문입니다.number (할 수 . （ 에이 ( 。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]

다음으로 Math.random()을 사용하지 않고 지정된 길이의 난수를 생성할 수 있는 JavaScript 함수의 예를 나타냅니다.

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 from
                0 to 1,998 instead of 0 to 2,000.

                See the JavaScript documentation
                for an 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자리까지 3자리 숫자로 채워진 어레이를 만듭니다.이 코드는 매우 짧습니다.

이것은 어떤 범위의 난수에 대한 저의 견해입니다. 예를 들어, 저는 기저에서 지수까지의 범위 내에서 난수를 얻고 싶었습니다.예를 들어, 기준 = 10, 지수 = 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);

이것은 모든 기고문 중에서 가장 간단한 것이라고 생각합니다.

maxNum = 8,
minNum = 4

console.log(Math.floor(Math.random() * (maxNum - minNum) + minNum))

console.log(Math.floor(Math.random() * (8 - 4) + 4))

이렇게 하면 콘솔에 4에서8 사이의 랜덤 번호가 기록됩니다(4에서 8 포함).

Ionu g G. Stan은 훌륭한 답변을 썼지만, 내가 이해하기엔 너무 복잡했다.Math.floor ( Math . random )* ( max - min + 1) + min )에서 같은 개념에 대해 보다 간단하게 설명했습니다. 제이슨 아넬로의 설명.

주의: Jason의 설명을 읽기 전에 알아야 할 중요한 것은 "truncate"의 정의입니다.그는 그 용어를 사용해서Math.floor()은 "를 다음과 같이 정의합니다 교묘히 하다

윗부분이나 끝을 잘라 (뭔가를) 줄인다.

라고 하는 함수randUpTo과 그합니다.

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

라고 하는 함수randBetween범위를 나타내는2개의 숫자를 받아들여 이들 2개의 숫자 사이에 임의의 정수를 반환합니다.

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

라고 하는 함수randFromTill범위를 나타내는 2개의 숫자를 받아들여 최소값(최소값)과 최대값(최소값) 사이의 난수를 반환합니다.

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

라고 하는 함수randFromTo는 범위를 나타내는2개의 숫자를 받아들여 min(최소값)에서 max(최소값) 사이의 임의의 정수를 반환합니다.

var randFromTo = function (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;
}

언급URL : https://stackoverflow.com/questions/1527803/generating-random-whole-numbers-in-javascript-in-a-specific-range