JavaScriptで特定の範囲のランダムな整数を生成しますか?


1955

どのように私は例えば、JavaScriptで指定された2つの変数の間のランダムな整数を生成することができますx = 4し、y = 8出力はどんなのだろうか4, 5, 6, 7, 8


1
ここに便利な要点があります:gist.github.com/kerimdzhanov/7529623
Dan KK

9
余談ですが、npmを使用していて、迅速で信頼性の高い既製のソリューションを探している人のために、lodash.randomがあります。これは、非常に小さなフットプリントで簡単に要求できます(lodash全体ではなく、メソッド自体だけをインポートします)。
のび太の

それは安全な暗号である必要があればdeveloper.mozilla.org/en-US/docs/Web/API/RandomSource/...を
幸せ

回答:


3834

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

その背後にある論理は次のとおりです。これは、3つの単純なルールです。

Math.random()Number0(包括的)から1(排他的)の間のa を返します。したがって、次のような間隔があります。

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

ここで、min(包括的)とmax(排他的)の間の数値が必要です。

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

を使用しMath.randomて、[min、max)間隔でコレスポンデントを取得できます。ただし、最初にmin2番目の間隔から差し引くことで問題を少し因数分解する必要があります。

[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の最初の機能でした。もう一つは、間の整数を返しminmax、の両方を包括。

整数を取得するためにroundceilまたはを使用できます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結果をロールすることもできます。


10
切り捨てるを呼び出しているためfloor、それが行われているだけです。
Josh Stodola、

4
@ thezachperson31あなたが使用することができますroundが、その後の両方、minおよびmax他の数字が行うようにのみロールに半分のチャンスがありました。また、1を引いて、を取ることもできますceil。ただし、これmaxにより、[0,1)間隔のためにローリングする可能性が最小限に抑えられます。
クリストフ

12
このメソッドの配布をテストしたい場合は、JSFiddleを作成しました。jsfiddle.net/ F9UTG / 1
ahren

8
@JackFrostええ、そうです。ばかじゃなくて、ただ学んでいるだけです:)
Ionuț G. Stan

3
この質問は古くなっていますが、この答えを理解するのに時間がかかりすぎましたOo、次のJavaScriptバージョンでmath.randomを拡張することは、一種の役に立つと思います
Jonathan Ortega

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

19
私はこれが非常に古い答えであることを知っていますが、使用(Math.random() * (maximum - minimum + 1) ) << 0はより高速です。
Ismael Miguel

11
@IsmaelMiguel二項演算子を使用して(x << 0x | 0~~x)の代わりに、Math.floor()変換xよりもはるかに小さい範囲を持つ2つの補数にNumber.MAX_SAFE_INTEGER(2³²⁻¹対2⁵³)、したがって、あなたは慎重にそれを使用する必要があります!
le_m

@IsmaelMiguel Yoコンソールでメソッドを試したところ、ランダムに負の値が出ました!Math.randRange =(最小、最大)=>(Math.random()*(最大-最小+ 1))<< 0 Math.randRange(2,657348096152)-1407373159
bluejayke

@bluejayke 657348096152(バイナリでは1001100100001100111111111111000010011000)は40ビットですが、ビット単位の演算では32ビットを使用するためです。あなたが行う場合657348096152|0、あなたは(バイナリで1100111111111111000010011000)218099864を取得します。
イスマエルミゲル

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

または最小(含まれる)と最大(含まれない)の間の任意の乱数

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

壊す:

関数(関数型プログラミングから借用)を返します。この関数は、呼び出されると、値bottomとの間のランダムな整数を返しますtop。返される数値の範囲に最下部と最上位の両方を含めるため、「包括的」と言います。この方法でgetRandomizer( 1, 6 )は、1、2、3、4、5、または6のいずれかが返されます。

(下が小さい数、上が大きい数)

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

Math.random()0と1の間のランダムなダブルを返し、我々は乗算、それとの間に1つのを加えた違いによる場合topbottom、私たちはどこかの間に二重を得るでしょう0し、1+b-a

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

Math.floor数値を最も近い整数に切り捨てます。これで、0との間のすべての整数が得られましたtop-bottom。1は混乱しているように見えますが、常に切り捨てられるため、そこにある必要があります。したがって、1がないと、実際にトップ数に到達することはありません。私たちは範囲内であることが必要性を生成するランダムな小数0(1+top-bottom)我々は切り捨てと範囲のint得ることができるように0するにtop-bottom

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

前の例のコードでは、範囲内で私たちに整数を与えた0し、top-bottom私たちが今行う必要があるすべての追加であるので、bottom範囲の整数を取得するためにその結果にbottomしてtop包括的に。:D


注:最初に整数以外の値またはより大きな数値を渡すと、望ましくない動作が発生しますが、誰かがそれを要求しない限り、元の質問の意図からかなり離れているため、引数チェックコードを掘り下げることはしません。


1
これは約2.5年後のことですが、入力1と6を使用すると、関数は値1、2、3、4、5を返しますが、「包括的」である場合のように6は決して返しません。
いくつかの

9
@いくらか悪化する可能性があります。私は2½年+ 1日後です^^
ajax333221

+1、私はあなたのコードをテストしました、それは正しい値を作成するようです。コードで何度も繰り返される可能性のある固定シナリオを処理するための創造的な構造。
クリス

このための関数内に関数があるのはなぜですか?
Alph.Dev 2017年

1
@ Alph.Dev乱数ジェネレータを使用するロジックを、使用する乱数分布を正確に決定するロジックから切り離す。乱数ジェネレーターを使用するコードがそれをパラメーター(常に新しい乱数を返す0引数関数)として受け入れる場合、任意の種類の乱数ジェネレーターで機能します。
ゴードングスタフソン2017年

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

あなたが使用できるUnderscore.jsを使用している場合の代替

_.random(min, max)

1
Underscoreは、実際には_.uniqueId()クライアント側モデルに呼び出すことができる関数を提供します。
obfk 2015年

(二項演算子を使用してx << 0x | 0~~x)の代わりに、Math.floor()変換xよりもはるかに小さい範囲を持つ2つの補数にNumber.MAX_SAFE_INTEGER(2³²⁻¹対2⁵³)、したがって、あなたは慎重にそれを使用する必要があります!
le_m

31

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 '27

1
それは部分的に包括的です:[1、*)
Ivan Z

関数の最後に+ 1が必要なのは何ですか?それは完璧に機能すると思います。
Shachi

18

0とmaxの間の変数が必要な場合は、以下を使用できます。

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

maxは包括的または排他的ですか?
ツリー

2
Math.floor maxを使用した@Treeは排他的です。maxを含めたい場合は、Math.roundを使用できます。
ルーク

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 7。9と7は5と6の間に来ますか?......あなたはそれを修正するか説明する必要があります...
サチン

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では、ランダムに数値を生成し、それらが必要な範囲内にあることを確認します。次に、それを配列に入れます。ここで私は2つの乱数を生成し、それらの合計を使用して、有用な数を取得する失敗率を最小化することによってプログラムの速度を最大化しました。ただし、生成された数値を追加すると、バイアスも発生します。したがって、特定の範囲内の乱数を生成する最初の方法をお勧めします。

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


3
「ランダム」は、必ずしも「均一に分散」することを意味しません。「偏見」は「非ランダム」を意味するものではありません。確率分布から抽出されたランダムな平均。
syzygy 2015

6
この答えが何を言おうとしているのかほとんど分かりません。ただし、宝くじ番号やギャンブルなどの用途で乱数が必要な場合。まず、おそらくクライアントでそれらを生成するべきではありません。次に、暗号化された安全な乱数ジェネレータが必要であり、提供されたアルゴでは不十分です。randomを繰り返し呼び出すと、結果が「よりランダム」になるわけではありません。著者はバイアスについて心配しているようですが、それを防ぐための良いアルゴリズムを提供していません。実際、提供される他の短い回答は、不偏乱数を生成します(基になるランダムジェネレーターが不偏であると想定しています)。
ジェフウォーカーコードレンジャー

@JeffWalkerCodeRanger彼が意味したのは、「通常の」アルゴリズム[つまりMath.floor(Math.random() * (6 - 1 + 1) + 1)]では、数字1と6は必然的に2、3、4、5 よりも少ない回数しかロールされないということだと思います。しかし、違いは基本的にわずかです。
オールドボーイ

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をファイルに保存し、ブラウザーで開きます。このコードは、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>

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を削除する理由は、最小値のみを使用すると、最大値よりも1大きい整数を取得できるためです。最小値から0.5を取り除くことにより、基本的に最大値が切り上げられるのを防ぎます。

お役に立てば幸いです。


0を除外する場合は、0から0.5の範囲を切り捨てる必要はありません。
ILMostro_7 2016年

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.floor((Math.random()* 1)+ 0); 常に0を
返す

1
@madprops最大数は排他的であるため。0または1を取得するには、最大数として2を設定する必要があります。
NutCracker 2017

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ずつ増やす必要があることを意味します。次に、highからlowを差し引いて、生成する最も高い数-low、次に+ lowを与え、highを通常に戻し、最も低い数を少なくともlowにします。次に、結果の数値を返します

random(7,3) 戻ることができた 3,4,5,6, or 7


2
以下のようhighに一度だけ使用されている、あなたにも使用することhigh-low+1なく、独立したインクリメント文を持っています。また、ほとんどのユーザーは、lowパラメーターが最初に来ることを期待します。
クリスウォルシュ2017年

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()を使用せずに、指定された長さの乱数を生成できる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;
    }

t1 / t2は常に1に非常に近いため、関数が繰り返し呼び出されると、関数は同じ数を返します。jsbin.com/xogufacera/edit?js,console
Sunil 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の小さい値の1つ。私たちの行動は次の疑似コードのようになります。

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ビット整数を生成しますnumber。これは、JavaScriptの標準型で表すことができる最大の一般的な整数サイズであるためです。(これは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
JaviMarzán19年

1

Ionuț G. Stanは素晴らしい答えを書きましたが、理解するには少し複雑すぎました。そのため、Jason Anelloによるhttps://teamtreehouse.com/community/mathfloor-mathrandom-max-min-1-min-explanationで、同じ概念のさらに簡単な説明を見つけました。

注: Jasonの説明を読む前に知っておくべき重要なことは、「切り捨て」の定義です。彼は説明するときにその用語を使用しMath.floor()ます。オックスフォード辞書は「切り捨て」を次のように定義しています。

トップまたはエンドを切り取って(何かを)短くします。


0

これは、最大20桁の一意の乱数の生成を処理できます。

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


私はこれを賛成しています。
Taylor Ackley、2018年

1
@TaylorAckleyこの回答は質問に対応していません。
RomainValeri

0

/ * randUpTo数値を受け取り、0とその数値の間のランダムな整数を返す、呼び出される関数を記述しますか?* /

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つの数値を受け入れ、min(両端を含む)とmax(両端を含まない)の間の乱数を返す、呼び出される関数を記述します。* /

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

1
美しい、randBetweenが(exclusive)(exclusive)であることに注意してください。
pfdint

0

min、max、exclude(除外するintのリスト)、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)

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.