webdevqa.jp.net

JavaScriptで2つの数字の間に乱数を生成する

JavaScriptで指定された範囲(1から6まで:1、2、3、4、5、6など)で乱数を生成する方法はありますか

1407
Mirgorod

1から6までの値を取得したい場合は、次のように計算します。

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

どこで: 

  • 1は開始番号です 
  • 6は可能な結果の数です(1 +開始 (6) - 終了 (1)
1760
khr055
function randomIntFromInterval(min,max) // min and max included
{
    return Math.floor(Math.random()*(max-min+1)+min);
}

「余分」とは、1で始まらないランダムな間隔を許可することです。したがって、たとえば10から15の乱数を取得できます。柔軟性.

1833
Francisc

Math.random()

Mozilla 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;
224
Lior Elrom

その他の解決策

  • (Math.random() * 6 | 0) + 1
  • ~~(Math.random() * 6) + 1
80
Vishal

TL; DR

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

乱数を取得するには generateRandomInteger(-20, 20);

以下の説明

最小整数と最大整数の間に _ x _ と言うランダムな整数を得る必要があります。

右? 

すなわち、 min <= X <= max

式からminを引くと、これは以下と等価になります。 

0 <=(X - min)<=(max - min)

さて、これに乱数 r を掛けてみましょう。 

0 <=(X - 最小)* r <=(最大 - 最小)* r

それでは、式に min を追加してみましょう。

min <= min +(X - min)* r <= min +(max - min)* r

それでは、結果が r になるような関数を選んで、式の範囲を[min、max]として満たすようにしましょう。これは 0 <= r <= 1 の場合にのみ可能です

OK。さて、 r [0,1]の範囲は、Math.random()関数の結果とよく似ています。そうではありませんか?

Math.random()関数は、浮動小数点の擬似乱数を[0、1)の範囲で返します。つまり、0(包括的)からまでで、1(排他的)を含みます。

例えば、

ケースr = 0

min+ 0 *(maxname __-minname__)= min

ケースr = 1

min+ 1 *(maxname __-minname__)= max

Math.randomを使ったランダムケース0 <= r <1

min+ r *(maxname____minname__)= _ x _ ここで、 _ x _ min <= _ x _ < 最大

上記の結果 _ x _ は乱数です。しかしMath.random()のために、左境界は包括的で、右境界は排他的です。右境界を含めるには、右境界を1だけ増やして結果を下げます。

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

乱数を取得する

generateRandomInteger(-20, 20);

40

jsfiddle: https://jsfiddle.net/cyGwf/477/

ランダム整数 minmaxの間のランダムな整数を取得するには、次のコードを使用します。

function getRandomInteger(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min)) + min;
}

ランダムな浮動小数点数 minmaxの間のランダムな浮動小数点数を取得するには、次のコードを使用します。

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

参照: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random

19
Razan Paul
var x = 6; // can be any number
var Rand = Math.floor(Math.random()*x) + 1;
18
ryebr3ad

または、 にアンダースコア

_.random(min, max)
18
vladiim

数学は私の強みではありませんが、私は正と負の両方の乱数をたくさん生成する必要があるプロジェクトに取り組んでいます。 

function randomBetween(min, max) {
    if (min < 0) {
        return min + Math.random() * (Math.abs(min)+max);
    }else {
        return min + Math.random() * max;
    }
}

例えば 

randomBetween(-10,15)//or..
randomBetween(10,20)//or...
randomBetween(-200,-100)

もちろん、数値以外のものでこれを行わないように検証を追加することもできます。また、minが常にmax以下であることを確認してください。

13
Petter Thowsen

私はあなたに乱数を与えることができるが整数だけでなくもっと柔軟な関数を書いた。

function Rand(min,max,interval)
{
    if (typeof(interval)==='undefined') interval = 1;
    var r = Math.floor(Math.random()*(max-min+interval)/interval);
    return r*interval+min;
}

var a = Rand(0,10); //can be 0, 1, 2 (...) 9, 10
var b = Rand(4,6,0.1); //can be 4.0, 4.1, 4.2 (...) 5.9, 6.0

修正バージョン.

8
ElChupacabra

1から10までの乱数を返します。

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

結果は以下のようになります。 3

自分で試してみてください: ここ

-

または、lodash/Unscoreを使用します。

_.random(min, max)

ドキュメント: - lodash - Unscore

7
Sebastián Lara

私はTypeScriptで書かれた乱数発生器を検索していました、そして私はすべての答えを読んだ後にこれを書きました。

    Rand(min: number, max: number): number {
        return (Math.random() * (max - min + 1) | 0) + min;
    }   
4
Erdi İzgi

多くの答えとほぼ同じ結果にもかかわらず。私は自分の答えを追加してその働きを説明したいと思います。 1行のコードをコピーアンドペーストするのではなく、その機能を理解することが重要です。乱数を生成することは単純な数学に他なりません。 

コード:

function getR(lower, upper) {

  var percent = (Math.random() * 100);
  // this will return number between 0-99 because Math.random returns decimal number from 0-0.9929292 something like that
  //now you have a percentage, use it find out the number between your INTERVAL :upper-lower 
  var num = ((percent * (upper - lower) / 100));
  //num will now have a number that falls in your INTERVAL simple maths
  num += lower;
  //add lower to make it fall in your INTERVAL
  //but num is still in decimal
  //use Math.floor>downward to its nearest integer you won't get upper value ever
  //use Math.ceil>upward to its nearest integer upper value is possible
  //Math.round>to its nearest integer 2.4>2 2.5>3   both lower and upper value possible
  console.log(Math.floor(num), Math.ceil(num), Math.round(num));
}
4
Arun Sharma

あなたが最大数に1を加える必要があるように感じて、それからこれのどれかが働くために最小数を引く、そして私はランダムな整数をたくさん作る必要がある、この関数は働く。

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

これは負の数でも正の数でも動作します。私は図書館の小数部に取り組んでいます。

2
Travis

Javascriptで乱数を作成するために、組み込みのjavascript Mathオブジェクトを使うことができます。 Mathオブジェクトは関数Math.random()を持ちます。この機能は次のことを行います(ソースMDN)。

Math.random()関数は、0から1までの範囲(0を含むが1は含まない)の浮動小数点の疑似乱数を、その範囲にわたってほぼの一様分布で返しますそれからあなたはそれからあなたが望む範囲にスケールすることができます。

この機能があれば、これをより複雑なシナリオに簡単に拡張できます。例えば:

function randomNR (x, y){
return Math.round((Math.random() * x + y));
}

// dice >> random number between 1-6
// dice functionality without function >> Math.round((Math.random() * 5 + 1))
console.log(randomNR(5,1));


// coin >> random number between 0-1
// coin functionality without function >> Math.round((Math.random() * 1))
console.log(randomNR(1,0))

1

ES6のデフォルトパラメータを使用してこれを行うための非常に新しい方法を発見しました。 1つの引数または2つの引数のいずれかを許可するため、非常に便利です。ここにあります:

function random(n, b = 0) {
    return Math.random() * (b-n) + n;
}
0
maburdi94

これは動作するはずです:

const getRandomNum = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min
0
sbr_amd

@ Francisc's answerのfloatバージョンに基づいて固定精度バージョンでintを追加

function randomFloatFromInterval (min, max, fractionDigits) {
  const fractionMultiplier = Math.pow(10, fractionDigits)
  return Math.round(
    (Math.random() * (max - min) + min) * fractionMultiplier,
  ) / fractionMultiplier
}

そう:

randomFloatFromInterval(1,3,4) // => 2.2679, 1.509, 1.8863, 2.9741, ...

そしてintの答えのために

randomFloatFromInterval(1,3,0) // => 1, 2, 3
0
yonatanmn

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.

次のコードでも同様のロジックを使用していますが、JavaScriptの標準のnumber型で表すことができる最大の共通整数サイズであるため、代わりに32ビット整数を生成します。選択した範囲に関係なく、拒否される生成値の割合は常に0.5未満になるため、予想される拒否数は常に0.5になります。これは、BigIntsを使用するように変更できます。 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]
0
Jeremy