특정 범위에서 JavaScript로 임의의 정수를 생성합니까?


1955

어떻게 자바 스크립트 예에서 지정된 두 변수 사이의 임의의 정수를 생성 할 수 있습니다 x = 4y = 8의 것 출력 어떤 4, 5, 6, 7, 8?


1
유용한 요지가 여기 있습니다 : gist.github.com/kerimdzhanov/7529623
Dan KK

9
참고로 : npm을 사용하고 빠르고 안정적이며 기성품 솔루션을 찾고있는 사람들을 위해 lodash.random 이 있습니다.
Nobita

암호화 된 보안이 필요한 경우 developer.mozilla.org/en-US/docs/Web/API/RandomSource/…
happy

답변:


3832

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()Number0 (포함)과 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등식을 사용할 수 없습니다 .maxmin-1


10
floor반올림하는을 호출하기 때문에 그렇게하고 있습니다.
Josh Stodola

4
@ thezachperson31 당신은 사용할 수 있습니다 round, 그러나 모두, min그리고 max다른 숫자처럼 만 롤에 절반 기회가 있었다. 당신은 또한 하나를 빼고 걸릴 수 있습니다 ceil. 그러나 이로 max인해 [0,1)간격 으로 인해 롤링 가능성이 최소화 됩니다.
Christoph

12
누군가이 방법의 분포를 테스트하려면 JSFiddle을 만들었습니다. jsfiddle.net/F9UTG/1
ahren

8
@JackFrost 그래, 맞아. 당신은 바보가 아닙니다, 당신은 단지 배우고 있습니다 :)
Ionuț G. Stan

3
이 질문은 내가 어떤 도움이 될 것입니다 다음 자바 스크립트 버전 인 Math.random을 확장 생각, 오래된,하지만이 답변을 이해하는 것은 나에게 너무 많은 시간 각종했다
조나단 오르테가

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

19
나는 이것이 매우 오래된 대답이라는 것을 알고 있지만 사용하는 (Math.random() * (maximum - minimum + 1) ) << 0것이 더 빠릅니다.
Ismael Miguel

11
@IsmaelMiguel 바이너리 연산자 사용 ( x << 0, x | 0, ~~x) 대신 Math.floor()변환 x보다 훨씬 더 작은 범위의 두 보완에 Number.MAX_SAFE_INTEGER(2³²⁻¹ 대 2⁵³), 따라서 당신이주의를 사용해야합니다!
le_m

@IsmaelMiguel Yo 방금 콘솔에서 메소드를 시도하고 무작위로 음수 값을 얻었습니다! Math.randRange = (최소, 최대) => (Math.random () * (최대-최소 + 1)) << 0 Math.randRange (2,657348096152) -1407373159
bluejayke

@bluejayke 657348096152 (2 진의 1001100100001100111111111111000010011000)에는 40 비트가 있으며 비트 산술에는 32 비트가 사용됩니다. 그렇게 657348096152|0하면 218099864 (2 진으로 1100111111111111000010011000)를 얻습니다.
Ismael Miguel

1
현명한 답변입니다. 내부적으로 [min, max + 1) 범위를 설정하면 [min, max] 모두 원하는 결과를 얻을 수 있습니다. 감사합니다! :)
Mladen B.

135

Math.random ()

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

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

또는 min ( 포함 )과 max ( 포함되지 않음 ) 사이의 임의의 숫자 :

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;

** 그리고 항상 상기시켜주는 것이 좋습니다 (Mozilla) :

Math.random ()은 암호로 안전한 임의의 숫자를 제공하지 않습니다. 보안과 관련하여 사용하지 마십시오. 대신 Web Crypto API를 사용하십시오.보다 정확하게는 window.crypto.getRandomValues ​​() 메소드입니다.


56
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.
}

고장:

우리는 함수 함수에서 빌려온 함수를 반환합니다. 함수 함수는 호출 될 때 값 bottomtop에 포함 된 임의의 정수를 반환 합니다. 반환 할 수있는 숫자 범위에 아래쪽과 위쪽을 모두 포함 시키려고하므로 '포함'이라고합니다. 이 방법으로 getRandomizer( 1, 6 )1, 2, 3, 4, 5 또는 6을 반환합니다.

(아래가 낮은 숫자, 위가 큰 숫자)

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

Math.random()0과 1 사이의 임의의 두 배를 반환하고, 우리는 곱셈 그 사이에 하나 개 플러스의 차이에 의한 경우 topbottom, 우리는 사이에 두 곳을거야 0하고 1+b-a.

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

Math.floor숫자를 가장 가까운 정수로 내림합니다. 이제 0와 사이에 모든 정수가 top-bottom있습니다. 1은 혼란스러워 보이지만 항상 반올림하기 때문에 거기에 있어야하므로 최상위 숫자가 없으면 실제로 도달하지 않습니다. 우리가 요구를 생성하는 랜덤 진수 범위로 0(1+top-bottom)우리가 범위의 int를 내림 얻을 수 0top-bottom

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

이전 예제의 코드는 범위에서 우리에게 정수를 준 0그리고 top-bottom우리가 지금해야 할 일은 추가하므로, bottom범위의 정수를 얻기 위해 그 결과 bottomtop포함합니다. :디


참고 : 정수가 아닌 값이나 더 큰 숫자를 먼저 전달하면 바람직하지 않은 동작이 발생하지만 다른 사람이 요청하지 않으면 원래 질문의 의도와는 거리가 멀기 때문에 인수 확인 코드를 자세히 조사하지 않습니다. .


1
나는 이것이 약 반년이 지난 것을 알고 있지만, 입력 1과 6을 사용하면 함수는 1,2,3,4와 5를 반환하지만 "포괄적"인 것처럼 6을 반환하지 않습니다.

9
@some, 그것은 더 나쁠 수 있습니다, 나는 2 년 반 + 1 일 후 ^^
ajax333221

+1, 코드를 테스트했는데 올바른 값을 만드는 것 같습니다. 코드에서 많이 반복 될 수있는 고정 시나리오를 처리하기위한 독창적 인 구조.
Chris

왜 함수 안에 함수가 있습니까?
Alph.Dev

1
@ Alph.Dev 사용할 난수 분포를 정확하게 결정하는 논리에서 난수 생성기를 사용하는 논리를 분리합니다. 난수 생성기를 사용하는 코드가이를 매개 변수 (항상 새로운 난수를 리턴하는 0 인수 함수)로 승인하면 모든 종류의 난수 생성기와 작동 할 수 있습니다.
Gordon Gustafson

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

Underscore.js 를 사용하는 경우 대안으로 사용할 수 있습니다.

_.random(min, max)

1
Underscore는 실제로 _.uniqueId()클라이언트 측 모델을 호출 할 수 있는 기능을 제공합니다 .
obfk

(이진 연산자를 사용하여 x << 0, x | 0, ~~x) 대신 Math.floor()변환 x보다 훨씬 더 작은 범위의 두 보완으로 Number.MAX_SAFE_INTEGER(2³²⁻¹ 대 2⁵³), 따라서 당신은 신중하게 사용한다!
le_m

30

1에서 10 사이의 난수를 반환합니다.

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

1에서 100 사이의 난수를 반환합니다.

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

당신의 "사이"가 포괄적이거나 독점적입니까? 즉 [1,10], [1,10), (1,10] 또는 (1,10)입니까?
evandrix

1
부분적으로 포함 : [1, *)
Ivan Z

함수 끝에서 + 1이 필요한 것은 무엇입니까? 그것은 내가 생각하는 완벽하게 작동합니다.
Shachi

18

0에서 최대 사이의 변수가 필요한 경우 다음을 사용할 수 있습니다.

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

max가 포괄적입니까 아니면 독점적입니까?
Tree

2
Math.floor max를 사용한 @Tree는 독점적입니다. max를 포함하려면 Math.round를 사용할 수 있습니다.
Luke

14

다른 답변은 0및 의 완벽하게 합리적인 매개 변수를 설명하지 않습니다 1. 대신 또는 round 대신 을 사용해야합니다 .ceilfloor

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
당신의 대답은 사실이지만 당신의 모범은 틀렸다고 생각합니다. console.log(randomNumber(5,6)); # 9 6 6 5 7 79와 7은 5와 6 사이에 있습니까? ...... 수정하거나 설명해야합니다.
Sachin

12

다음은 javascript에서 임의 클래스의 MS DotNet 구현입니다.

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

MS DotNet Random 클래스는 Ms-RSL 라이센스에 따라 저작권이 있습니다. 따라서이 파생 코드를 사용할 때는 저작권 침해 사례가 발생할 수 있으므로주의해야합니다.
JohannesB

12

주어진 범위 사이의 난수를 얻기 위해이 함수를 사용하십시오

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

10

컴퓨터 프로그램을 사용하여 난수를 생성 한 후에도 선택된 숫자가 초기 숫자의 일부이거나 전체 인 경우 난수로 간주됩니다. 그러나 그것이 변경 되었다면, 수학자들은 그것을 임의의 숫자로 받아들이지 않고 그것을 편향된 숫자라고 부를 수 있습니다. 그러나 간단한 작업을위한 프로그램을 개발하는 경우에는 고려해야 할 사항이 아닙니다. 그러나 복권 프로그램이나 도박 게임과 같은 귀중한 물건에 임의의 숫자를 생성하는 프로그램을 개발하는 경우 위의 경우를 고려하지 않으면 관리자가 프로그램을 거부합니다.

이런 종류의 사람들에게는 여기 내 제안이 있습니다.

사용하여 난수를 생성합니다 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);

참고 : 방법 1에서는 먼저 필요한 숫자가 포함 된 배열을 만든 다음 임의로 다른 배열에 넣습니다. 방법 2에서는 임의로 숫자를 생성하고 필요한 범위에 있는지 확인하십시오. 그런 다음 배열에 넣으십시오. 여기서는 두 개의 난수를 생성하고 총합을 사용하여 유용한 수를 얻는 실패율을 최소화하여 프로그램 속도를 최대화했습니다. 그러나 생성 된 숫자를 추가하면 약간의 편차가 생깁니다. 따라서 특정 범위 내에서 난수를 생성하는 첫 번째 방법을 권장합니다.

두 가지 방법 모두 콘솔에 결과가 표시됩니다 (Chrome에서 f12를 눌러 콘솔을 엽니 다).


3
"무작위"가 반드시 "균일하게 분포 된"을 의미하는 것은 아닙니다. "편견"은 "무작위"를 의미하지 않습니다. 확률은 확률 분포에서 도출됩니다.
syzygy

6
이 답변이 무엇을 말하려고하는지 거의 말할 수 없습니다. 그러나 복권 번호 및 도박과 같은 용도로 임의의 숫자가 필요한 경우. 먼저 클라이언트에서 생성해서는 안됩니다. 둘째, 암호로 안전한 난수 생성기가 필요하며 제공된 알고리즘으로는 충분하지 않습니다. random을 반복해서 호출한다고해서 결과가 "무작위"가되지는 않습니다. 저자는 편견에 대해 우려하는 것처럼 보이지만이를 예방하기위한 좋은 알고리즘을 제공하지는 않습니다. 실제로, 제공되는 다른 짧은 답변은 편향되지 않은 난수를 생성합니다 (기본 난수 생성기가 편향되지 않은 것으로 가정).
Jeff Walker 코드 레인저

@JeffWalkerCodeRanger "정상적인"알고리즘을 사용 Math.floor(Math.random() * (6 - 1 + 1) + 1)하면 숫자 1과 6은 반드시 2, 3, 4, 5보다 적은 횟수로 롤링 될 것입니다. 그러나 그 차이는 기본적으로 중요하지 않습니다.
oldboy

10

범위가있는 임의의 정수의 경우 다음을 시도하십시오.

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
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를 파일에 저장하고 브라우저에서여십시오. 이 코드는 백만 개의 함수 호출 분포를 보여주는 그래프 를 생성 합니다. 이 코드는 또한 엣지 케이스를 기록하므로 함수가 최대 값보다 크거나 최소값보다 작은 값을 생성하는 경우 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>

7

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를 제거하면 기본적으로 최대 값이 반올림되는 것을 방지 할 수 있습니다.

희망이 도움이됩니다.


0을 제외하면 0에서 0.5 사이의 범위를 "반올림"할 필요가 없습니다.
ILMostro_7

7

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

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

7

이 질문에 이미 답변되어 있지만 내 답변이 도움이 될 수 있음을 알고 있습니다.

W3Schools 에서이 간단한 방법을 찾았습니다.

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

이것이 누군가를 도울 수 있기를 바랍니다.


1
수학 플로어 ((Math.random () * 1) + 0); 항상 0
madprops를

1
@madprops 최대 수는 독점적이기 때문입니다. 0 또는 1을 얻으려면 2를 최대 수로 설정해야합니다.
NutCracker

1
또는이 메소드를 호출하는 함수에 + 1을 추가하면됩니다.
Pietro Coelho

6

최저와 최고 사이의 임의의 정수 :

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

가장 우아한 솔루션은 아니지만 빠른 것입니다.


5

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

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

0, (포함) 및 1 (제외) 사이의 임의의 숫자를 생성 하기 high++때문에 실행 Math.random()합니다. 제외되는 것은 수학을 실행하기 전에 1을 늘려야 함을 의미합니다. 그런 다음 우리는 low에서 high를 빼서 가장 높은 숫자를 생성합니다. low, 그 다음 + low는 정상으로 돌아가고 가장 낮은 숫자를 최소한으로 만듭니다. 그런 다음 결과 번호를 반환합니다

random(7,3) 돌아올 수 있었다 3,4,5,6, or 7


2
으로 high한 번만 사용됩니다, 당신은뿐만 아니라 사용할 수 있습니다 high-low+1보다는 별도의 증가 문이있다. 또한 대부분의 사용자는 low매개 변수가 먼저 나타날 것으로 예상합니다 .
Chris Walsh

4
    <!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는 최대 999의 최대 3 자리 숫자로 채워진 배열을 만듭니다.이 코드는 매우 짧습니다.


4

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

T1 / T2 항상 매우 가까이 따라서 1과로 함수가 반환 함수가 .. 반복적으로 호출 같은 수의 jsbin.com/xogufacera/edit?js,console
선일 BN

jsbin url을 확인하십시오. 출력을 직접 볼 수 있습니다
Sunil BN

상수 T1 & T2의 값이 적절한 거리를 가져야하기 때문에 길이가 4-10 사이 (내 기계에서 테스트 한 것처럼) 사이에 효과적입니다.
Nilesh Pawar

3

이것은 기본 범위에서 지수 범위 내에서 임의의 숫자를 얻으려는 것처럼 범위의 임의의 숫자를 취합니다. 예를 들어 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);

3

Math.random() 빠르고 안전하며 여러 목적에 적합하지만 암호로 안전한 값이 필요하거나 (안전하지 않음) 완전히 균일 한 편견 분포의 정수가 필요한 경우에는 적절하지 않습니다 (다른 답변에 사용되는 곱셈 접근법은 특정 값을 약간 더 자주 생성합니다) 다른 사람보다).

그런 경우에는 사용할 수 있습니다 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.

다음 코드는 유사한 논리를 사용하지만 대신 32 비트 정수를 생성합니다. 이는 JavaScript의 표준 number유형 으로 표시 될 수있는 최대 공통 정수 크기이기 때문입니다 . ( BigInt더 큰 범위가 필요한 경우 s 를 사용하도록 수정 될 수 있습니다 .) 선택한 범위에 관계없이 거부 된 생성 값의 비율은 항상 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]



1

이 코드 스 니펫을 사용할 수 있습니까?

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

1
여기에 불필요한 중복 줄이 있습니다. do - while대신 사용하십시오while
Javi Marzán

1

Ionuț G. Stan 은 훌륭한 답변을 썼지 만 이해하기에는 너무 복잡했습니다. 그래서 나는 같은 개념에 대한 더 간단한 설명을 https://teamtreehouse.com/community/mathfloor-mathrandom-max-min-1-min-explanation Jason Anello의 .

참고 : Jason의 설명을 읽기 전에 알아야 할 중요한 것은 "잘라 내기"의 정의입니다. 그는 설명 할 때 그 용어를 사용합니다 Math.floor(). 옥스포드 사전은 "잘라 내기"를 다음과 같이 정의합니다.

상단 또는 끝을 잘라내어 무언가를 줄이십시오.


0

최대 20 자리 UNIQUE 난수 생성을 처리 할 수 ​​있습니다.

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

여기에 이미지 설명을 입력하십시오

JS 피들


난 그냥 이것을 찬성 해요.
Taylor Ackley

1
@TaylorAckley이 답변은 질문을 다루지 않습니다.
RomainValeri

0

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

1
아름답습니다. randBetween이 (독점) (독점)임을 알 수 있습니까?
pfdint

0

min, max, exclude (제외 할 정수 목록) 및 seed (시드 시드 임의 생성기를 원할 경우)와 같은 옵션을 고려하는이 ​​기능을 만들었습니다.

get_random_int = function(args={})
{
    let def_args =
    {
        min: 0,
        max: 1,
        exclude: false,
        seed: Math.random
    }

    args = Object.assign(def_args, args)

    let num = Math.floor(args.seed() * (args.max - args.min + 1) + args.min)

    if(args.exclude)
    {
        let diff = args.max - args.min
        let n = num

        for(let i=0; i<diff*2; i++)
        {
            if(args.exclude.includes(n))
            {
                if(n + 1 <= args.max)
                {
                    n += 1
                }

                else
                {
                    n = args.min
                }
            }

            else
            {
                num = n
                break
            }
        }
    }

    return num
}

다음과 같이 사용할 수 있습니다.

let n = get_random_int
(
    {
        min: 0,
        max: some_list.length - 1,
        exclude: [3, 6, 5],
        seed: my_seed_function
    }
)

또는 더 간단하게 :

let n = get_random_int
(
    {
        min: 0,
        max: some_list.length - 1
    }
)

그럼 당신은 할 수 있습니다 :

let item = some_list[n]

요점 : https://gist.github.com/madprops/757deb000bdec25776d5036dae58ee6e


0
  • random (min, max)는 min (포함)과 max (제외) 사이의 난수를 생성합니다.
  • Math.floor는 숫자를 가장 가까운 정수로 내림합니다.

    function generateRandomInteger (min, max) { 
        return Math.floor(random(min,max)) 
    }`

따라서 4에서 8 사이의 임의의 정수를 생성하려면 다음 인수를 사용하여 위 함수를 호출하십시오.

generateRandomInteger (4,9)

0

0과 n 사이의 난수를 생성하는 내 방법은 n <= 10 (n 제외)입니다.

Math.floor((Math.random() * 10) % n)
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.