javascript - 重複なし - jquery 乱数




特定の範囲の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;

どのように私はJavascriptの2つの指定された変数の間にランダムな整数を生成できますか?例えばx = 4y = 8は4,5,6,7,8のいずれかを出力しますか?


/ * randUpToという関数を書くと、 randUpToを受け取り、0とその数値の間のランダムな整数を返します。 * /

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

/ *範囲を表す2つの数値を受け取り、その2つの数値の間にランダムな整数を返す関数randBetweenを書く。 * /

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

/ * randFromTillという関数を書くと、範囲を表す2つの数値を受け取り、min(max)とmax(max)の間の乱数を返します。 * /

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

/ *範囲を表す2つの数値を受け取り、min(max)とmax(max)の間のランダムな整数を返すrandFromToという関数を書く* /

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

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を取り除くことで、最大値が切り上げられるのを本質的に防ぎます。

希望が役立ちます。


1と10の間の乱数を返します。

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

1と100の間の乱数を返します。

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

ここでは、MS DotNetの実装は、ランダムなクラスのjavascript-

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 random(high,low) {
    high++;
    return Math.floor((Math.random())*(high-low))+low;
}

Math.random()は0以上1以下の乱数を生成するので、 high++実行します。除外されているのは、任意の数式を実行する前に1を増やす必要があるということです。 その後、低い値から低い値を引いて、生成する最も高い値を与えます。低い値、次に低い値、高い値を正常値に戻し、最も低い値を最低値にします。 結果の数値を返します

random(7,3)3,4,5,6, or 7


これは私が範囲の乱数を取ることです。指数の基数の範囲内で乱数を取得したかったからです。 例えばbase = 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);

そのようなランダマイザー機能のためには、十分な実行後のディストリビューションがどのようになるのだろうかと思いました。

また、そのディストリビューションがさまざまなブラウザで同じかどうかを確認することもできます。

ここには実行するスニペットがあります。 番号は、ボタンを押す前に変更することができます。

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

注:方法1では、最初に必要な数の配列を作成し、次にそれらをランダムに別の配列に配置しました。 方法2では、数字をランダムに生成し、それらが必要な範囲内にあることを確認します。 それを配列に入れます。 ここでは、2つの乱数を生成し、それらの合計を使用して、有用な数を取得する失敗率を最小限に抑えることによってプログラムの速度を最大限に高めました。 しかし、生成された数字を追​​加することはまた、いくつかのバイアスを与えるでしょう。 だから私は特定の範囲内の乱数を生成する私の最初の方法をお勧めします。

どちらの方法でも、コンソールに結果が表示されます(Chromeでf12を押してコンソールを開きます)


他の答えは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 randomRange(l,h){
  var range = (h-l);
  var random = Math.floor(Math.random()*range);
  if (random === 0){random+=1;}
  return l+random;
}

最もエレガントなソリューションではありませんが、迅速なものです。


次のコードを使用すると、指定された範囲で繰り返しを使わずに乱数の配列を生成できます。

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

    <!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桁までの数値で配列を作成します。このコードは非常に短いです。


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間のランダムな整数を返す関数(関数型プログラミングから借用)を返しています。 返される数値の範囲にbottomとtopの両方を含めるため、 'inclusive'と言っています。 このようにして、 getRandomizer( 1, 6 )getRandomizer( 1, 6 ) 、または6のいずれかを返します。

(下が数字、上が数字)

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

Math.random()は0と1の間のランダムなdoubleを返します。そして、それに1を加えたものとtopbottom差を掛ければ、 01+ba間のどこかにdoubleが得られます。

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

Math.floorは数値を最も近い整数に丸めます。 したがって、すべての整数は0からtop-bottomです。 1は混乱しているように見えますが、常に丸められているため、そこに存在する必要があります。したがって、先頭の数値には実際には到達しません。 私たちが生成するランダムな小数点は、 0から(1+top-bottom)の範囲にある必要がありますので、 0からtop-bottomまでの範囲で整数を取得します

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

前の例のコードでは、 0top-bottom範囲の整数が与えられていましたので、ここで行う必要があるのは、 bottomtop含む整数を得るために結果にbottomを追加することだけです。 :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