javascript - 함수 - 자바스크립트 랜덤




특정 범위의 JavaScript에서 임의의 정수 생성? (17)

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;

어떻게하면 자바 스크립트에서 두 개의 지정된 변수 사이의 임의의 정수를 생성 할 수 있습니까? 예 : x = 4y = 8 은 4, 5, 6, 7, 8 중 하나를 출력합니까?


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

/ * 범위를 나타내는 두 개의 숫자를 허용하고 min (포함)과 max (제외) 사이의 난수를 반환하는 randFromTill 이라는 함수를 작성합니다. * /

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

/ * 범위를 나타내는 두 개의 숫자를 허용하고 min (포함)과 max (포함) 사이의 임의의 정수를 반환하는 randFromTo 라는 함수를 작성합니다. * /

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

1에서 10 사이의 임의의 숫자를 반환합니다.

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

1에서 100 사이의 임의의 숫자를 반환합니다.

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

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을 빼앗으므로 본질적으로 최대 값이 반올림되는 것을 방지 할 수 있습니다.

희망이 도움이됩니다.


나는이 질문에 이미 답변되어 있지만 내 대답은 누군가를 도울 수 있다는 것을 안다.

W3Schools에서이 간단한 방법을 발견했습니다.

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

희망이 사람을 도울 것입니다.


다른 대답은 01 의 완벽하게 합리적인 매개 변수를 설명하지 않습니다. 대신에 ceil 이나 floor 대신 round 사용해야합니다.

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

우리는 Math.random() 이 0, (포함), 1 (배타적) 사이의 난수를 생성하기 때문에 high++ 실행합니다. 제외되는 것은 임의의 수학을 실행하기 전에 높이를 하나씩 늘려야 함을 의미합니다. 그런 다음 높은 값에서 낮은 값을 뺀 값을 낮게, 그 다음에 낮게, 높은 값을 정상 값으로 가져오고 가장 낮은 값을 최저로 만듭니다. 그 다음 결과 수를 반환합니다.

random(7,3)3,4,5,6, or 7 반환 할 수 있습니다.


대체 솔루션 : -

let makeGuess = function(guess){
    let min = 1;
    let max = 5;   
    let randomNumber = Math.floor(Math.random() * (max - min + 1)) + min

    return guess === randomNumber;

}
console.log(makeGuess(1));

안녕 얘들 아 내가 지정한 길이난수 를 생성 할 수있는 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;
    }

여기에 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

이것은 최대 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);

JsFiddle


충분한 런 후 배포가 랜더 마이저 기능을 위해 어떻게 될지 궁금해졌습니다.

또한 다른 브라우저에서 그 배포본이 더 많든 적든 똑같은지 확인해야합니다.

그래서 여기에 실행할 스 니펫이 있습니다. 단추를 누르기 전에 번호를 변경할 수 있습니다.

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>


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)
 * 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() 은 0 (포함)과 1 (포함하지 않음) 사이의 Number 를 반환합니다. 그래서 우리는 다음과 같은 간격을 갖습니다 :

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

이제 min (포함)과 max (제외) 사이의 숫자를 원합니다.

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

Math.random 을 사용하여 [최소, 최대] 간격으로 통신원을 얻을 수 있습니다. 그러나 먼저, 두 번째 간격에서 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 다시 추가하는 것을 잊지 말고, [최소, 최대] 간격으로 숫자를 얻습니다.

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

이것이 MDN의 첫 번째 기능이었습니다. 두 번째 매개 변수는 minmax 사이의 정수를 반환합니다.

이제 정수를 얻으려면 round , ceil 또는 floor 사용할 수 있습니다.

Math.round(Math.random() * (max - min)) + min 을 사용할 수 있지만 비 균등 분포를 제공합니다. minmax 모두 롤백 할 확률이 약 절반입니다.

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 결과도 롤백 할 수 있습니다.


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


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 의 값 사이에 임의의 정수를 반환합니다. 우리는 'inclusive'라고 말합니다. 왜냐하면 반환 할 수있는 숫자의 범위에 bottom과 top을 모두 포함하기를 원하기 때문입니다. 이렇게하면 getRandomizer( 1, 6 ) 는 1, 2, 3, 4, 5 또는 6 중 하나를 반환합니다.

(하단은 낮은 수, 상단은 더 큰 수)

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

Math.random() 은 0과 1 사이의 무작위 배정을 반환하며, 배수에 1을 더한 값과 topbottom 값의 차이를 곱하면 01+ba 사이의 어딘가에 두 배가됩니다.

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

Math.floor 는 숫자를 가장 가까운 정수로 반올림합니다. 이제 모든 정수가 0top-bottom 사이에 있습니다. 1은 혼란스러워 보이지만, 우리는 항상 반올림을하기 때문에 거기에 있어야합니다. 그래서 최상위 숫자는 실제로 절대로 도달하지 않습니다. 우리가 생성하는 random decimal은 0 에서 (1+top-bottom) 범위에 있어야하므로 0 부터 top-bottom 까지의 범위에서 int를 구할 수 있습니다.

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

앞의 예제에서 코드는 0top-bottom 범위의 정수를 우리에게주었습니다. 그래서 지금해야 할 일은 그 결과에 bottom 을 추가하여 bottomtop 범위의 정수를 얻는 것입니다. :디

참고 : 정수가 아닌 값 또는 큰 숫자를 먼저 전달하면 바람직하지 않은 동작이 발생하지만 누군가가 요청하지 않는 한 원래의 질문의 의도와 다소 거리가있는 인수 검사 코드를 파헤 치지 않을 것입니다. .


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