どのように私は例えば、JavaScriptで指定された2つの変数の間のランダムな整数を生成することができますx = 4
し、y = 8
出力はどんなのだろうか4, 5, 6, 7, 8
?
どのように私は例えば、JavaScriptで指定された2つの変数の間のランダムな整数を生成することができます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;
}
その背後にある論理は次のとおりです。これは、3つの単純なルールです。
Math.random()
Number
0(包括的)から1(排他的)の間のa を返します。したがって、次のような間隔があります。
[0 .................................... 1)
ここで、min
(包括的)とmax
(排他的)の間の数値が必要です。
[0 .................................... 1)
[min .................................. max)
を使用しMath.random
て、[min、max)間隔でコレスポンデントを取得できます。ただし、最初にmin
2番目の間隔から差し引くことで問題を少し因数分解する必要があります。
[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
を使用することはできません。max
ローリングする機会がわずかに減ったためです。ただし、(不要な)min-1
結果をロールすることもできます。
floor
、それが行われているだけです。
round
が、その後の両方、min
およびmax
他の数字が行うようにのみロールに半分のチャンスがありました。また、1を引いて、を取ることもできますceil
。ただし、これmax
により、[0,1)
間隔のためにローリングする可能性が最小限に抑えられます。
var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
(Math.random() * (maximum - minimum + 1) ) << 0
はより高速です。
x << 0
、x | 0
、~~x
)の代わりに、Math.floor()
変換x
よりもはるかに小さい範囲を持つ2つの補数にNumber.MAX_SAFE_INTEGER
(2³²⁻¹対2⁵³)、したがって、あなたは慎重にそれを使用する必要があります!
657348096152|0
、あなたは(バイナリで1100111111111111000010011000)218099864を取得します。
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()メソッドを使用します。
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つのを加えた違いによる場合top
とbottom
、私たちはどこかの間に二重を得るでしょう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
注:最初に整数以外の値またはより大きな数値を渡すと、望ましくない動作が発生しますが、誰かがそれを要求しない限り、元の質問の意図からかなり離れているため、引数チェックコードを掘り下げることはしません。
function randomRange(min, max) {
return ~~(Math.random() * (max - min + 1)) + min
}
あなたが使用できるUnderscore.jsを使用している場合の代替
_.random(min, max)
_.uniqueId()
クライアント側モデルに呼び出すことができる関数を提供します。
x << 0
、x | 0
、~~x
)の代わりに、Math.floor()
変換x
よりもはるかに小さい範囲を持つ2つの補数にNumber.MAX_SAFE_INTEGER
(2³²⁻¹対2⁵³)、したがって、あなたは慎重にそれを使用する必要があります!
1から10までの乱数を返します。
Math.floor((Math.random()*10) + 1);
1から100までの乱数を返します。
Math.floor((Math.random()*100) + 1)
他の回答は、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
console.log(randomNumber(5,6)); # 9 6 6 5 7 7
。9と7は5と6の間に来ますか?......あなたはそれを修正するか説明する必要があります...
これは、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
この関数を使用して、指定された範囲内の乱数を取得します
function rnd(min,max){
return Math.floor(Math.random()*(max-min+1)+min );
}
コンピュータプログラムを使用して乱数を生成した後でも、選択した番号が最初の番号の一部または完全な番号である場合は、乱数と見なされます。しかし、それが変更された場合、数学者はそれを乱数として受け入れず、偏った数と呼ぶことができます。ただし、単純なタスク用のプログラムを開発している場合、これは考慮すべきケースではありません。しかし、宝くじプログラムやギャンブルゲームなどの貴重なものの乱数を生成するプログラムを開発している場合、上記のケースを考慮しないと、プログラムは管理者によって拒否されます。
そのような人々のために、ここに私の提案があります:
を使用して乱数を生成し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を押してコンソールを開きます)。
Math.floor(Math.random() * (6 - 1 + 1) + 1)
]では、数字1と6は必然的に2、3、4、5 よりも少ない回数しかロールされないということだと思います。しかし、違いは基本的にわずかです。
範囲を持つランダムな整数の場合は、次を試してください:
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;
}
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"> [' + (i + min - 1) + ']: '+array[i]+'</span> ');
}
document.write('<hr/>');
</script>
</head>
<body>
</body>
</html>
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_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;
}
この質問はすでに回答済みですが、私の回答は誰かを助けることができます。
私はW3Schoolsでこの簡単な方法を見つけました:
Math.floor((Math.random() * max) + min);
これが誰かを助けることを願っています。
最低と最高の間のランダムな整数:
function randomRange(l,h){
var range = (h-l);
var random = Math.floor(Math.random()*range);
if (random === 0){random+=1;}
return l+random;
}
最もエレガントなソリューションではありませんが、簡単なものです。
これが私が乱数を生成するために使用するものです。
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
high
に一度だけ使用されている、あなたにも使用することhigh-low+1
なく、独立したインクリメント文を持っています。また、ほとんどのユーザーは、low
パラメーターが最初に来ることを期待します。
<!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桁までの数字で満たされた配列を作成します。このコードは非常に短いです。
以下は、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;
}
これは、範囲内の乱数の私の見方です。たとえば、底から指数の範囲内の乱数を取得したかったからです。たとえば、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);
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]
あなたはこのコードスニペットをすることができます、
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;
}
do - while
代わりに使用するwhile
Ionuț G. Stanは素晴らしい答えを書きましたが、理解するには少し複雑すぎました。そのため、Jason Anelloによるhttps://teamtreehouse.com/community/mathfloor-mathrandom-max-min-1-min-explanationで、同じ概念のさらに簡単な説明を見つけました。
注: Jasonの説明を読む前に知っておくべき重要なことは、「切り捨て」の定義です。彼は説明するときにその用語を使用しMath.floor()
ます。オックスフォード辞書は「切り捨て」を次のように定義しています。
トップまたはエンドを切り取って(何かを)短くします。
これは、最大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);
/ * 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;
};
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