Gerar números inteiros aleatórios em JavaScript numa gama específica?
Como posso gerar um número inteiro aleatório entre duas variáveis especificadas em Javascript, por exemplo x = 4
e y = 8
iria produzir qualquer um dos 4, 5, 6, 7, 8?
25 answers
Existem alguns exemplos na rede de desenvolvimento Mozilla página:
/**
* 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;
}
Eis a lógica por detrás disto. É uma regra simples de três:
Math.random()
devolve um Number
entre 0 (inclusive) e 1 (exclusivo). Então temos um intervalo como este:
[0 .................................... 1)
Agora, gostaríamos de um número entre min
(inclusive) e max
(exclusivo):
[0 .................................... 1)
[min .................................. max)
Podemos usar o Math.random
para obter o correspondente no intervalo [min, max). Mas, primeiro devemos factor um pouco do problema subtraindo min
do segundo intervalo:
[0 .................................... 1)
[min - min ............................ max - min)
Isto dá:
[0 .................................... 1)
[0 .................................... max - min)
Podemos agora aplicar Math.random
e depois calcular o correspondente. Vamos escolher um número aleatório:
Math.random()
|
[0 .................................... 1)
[0 .................................... max - min)
|
x (what we need)
Então, para encontrar x
, faríamos:
x = Math.random() * (max - min);
Não se esqueça de adicionar {[[12]} de volta, para que tenhamos um número no intervalo [min, max):
x = Math.random() * (max - min) + min;
Essa foi a primeira função da MDN. O segundo, devolve um inteiro entre min
e max
ambos, inclusive.
Agora para obter inteiros, você poderia usar round
, ceil
ou floor
.
Você poderia usar Math.round(Math.random() * (max - min)) + min
, isto no entanto dá uma distribuição não uniforme. Ambos, min
e max
só têm aproximadamente metade da chance de rolar:
min...min+0.5...min+1...min+1.5 ... max-0.5....max
└───┬───┘└────────┬───────┘└───── ... ─────┘└───┬──┘ ← Math.round()
min min+1 max
Com max
excluído do intervalo, tem ainda menos hipóteses de rolar do que min
.
Com Math.floor(Math.random() * (max - min +1)) + min
tens uma distribuição perfeitamente uniforme.
min.... min+1... min+2 ... max-1... max.... max+1 (is excluded from interval)
| | | | | |
└───┬───┘└───┬───┘└─── ... ┘└───┬───┘└───┬───┘ ← Math.floor()
min min+1 max-1 max
Não podes usar ceil()
e -1
nisso. equação porque max
agora tinha um pouco menos de chance de rolar, mas você pode rolar o resultado (indesejado) min-1
Também.
var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
Math.Aleatório()
A partir doMozilla documentação da rede de desenvolvimento:
// Returns a random integer between min (include) and max (include)
Math.floor(Math.random() * (max - min + 1)) + min;
Exemplos úteis:
// 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;
function getRandomizer(bottom, top) {
return function() {
return Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom;
}
}
Utilização:
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.
}
Repartição:
Estamos a devolver uma função (tomando emprestado da programação funcional) que, quando chamada, irá devolver um inteiro aleatório entre os valores bottom
e top
, inclusive. Dizemos "inclusivo" porque queremos incluir tanto de baixo como de cima na gama de números que podem ser devolvidos. Desta forma, getRandomizer( 1, 6 )
vai voltar ou 1, 2, 3, 4, 5, 6.
(o fundo é menor, o topo é maior)
Math.random() * ( 1 + top - bottom )
Math.random()
devolve um duplo aleatório entre 0 e 1, e se o multiplicarmos por um mais a diferença entre top
e bottom
, teremos um duplo algures entre 0
e 1+b-a
.
Math.floor( Math.random() * ( 1 + top - bottom ) )
Math.floor
reduz o número para o número inteiro mais próximo. Então agora temos todos os inteiros entre 0
e top-bottom
. O 1 parece confuso, mas precisa estar lá porque estamos sempre arredondando para baixo, de modo que o número de topo nunca será realmente alcançado sem ele. A casa decimal aleatória que geramos tem de estar em o intervalo 0
para {[17] } para que possamos arredondar e obter um int no intervalo 0
para top-bottom
Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom
O código no exemplo anterior deu-nos um número inteiro no intervalo 0
e top-bottom
, então tudo o que precisamos fazer agora é adicionar bottom
para que o resultado para obter um número inteiro no intervalo bottom
e top
inclusiva. : D
Nota: Se você passar por um valor não-inteiro ou o maior número Primeiro você terá comportamento indesejável, mas a menos que alguém o solicite eu não vou mergulhar no argument checking code as its rather far from the intent of the original question.
Devolve um número aleatório entre 1 e 10:
Math.floor((Math.random()*10) + 1);
Devolve um número aleatório entre 1 e 100:
Math.floor((Math.random()*100) + 1)
function randomRange(min, max) {
return ~~(Math.random() * (max - min + 1)) + min
}
Alternativa se estiver a utilizar sublinhado.js pode utilizar
_.random(min, max)
As outras respostas não têm em conta os parâmetros perfeitamente razoáveis de 0
e 1
. Em vez disso, deve usar o round
em vez de de ceil
ou 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
Depois de gerar um número aleatório usando um programa de computador, ele ainda é considerado como um número aleatório se o número escolhido é uma parte ou o completo Um do inicial. Mas se foi mudado, então os matemáticos não o aceitam como um número aleatório e podem chamá-lo de um número tendencioso. mas se você está desenvolvendo um programa para uma tarefa simples, este não será um caso a considerar. mas se você está desenvolvendo um programa para gerar um número aleatório para um material valioso como programa de loteria, ou jogo de jogo, em seguida, o seu programa será rejeitado pela gerência se você não é considerado sobre o caso acima.
Então, para esse tipo de pessoas, aqui está a minha sugestão:Gerar um número aleatório usando Math.random()
.(say this 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.
Se você sabe como ler a tabela de números aleatórios para escolher um número aleatório, Você sabe acima processo (multiplicando por 1, 10, 100 e assim por diante) não viola o que eu fui mencionado no início.(Porque altera apenas a casa decimal.)
Estude o seguinte exemplo e desenvolva-o de acordo com as suas necessidades.
Se precisar de uma amostra [0,9], o piso de n*10 é a sua resposta e, se necessário [0,99], o piso de n*100 é a sua resposta e assim por diante.
Agora vamos entrar no seu papel:
Você perguntou números entre o alcance específico. (Neste caso, você é tendenciosa entre essa faixa. - Ao tirar um número de [1,6] rolando um dado, então você é parcial em [1,6] mas ainda é um Aleatório se e somente se morrer é imparcial.)
Por isso, considere o seu intervalo = > [78, 247] número de elementos da Gama = 247 - 78 + 1 = 170; (já que ambos os limites são inclusivos.
/*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);
Nota: no método um, primeiro criei um array que contém números que você precisa e, em seguida, colocá-los aleatoriamente em outro array.
No método dois, gerar números aleatoriamente e verificar que estão na faixa que você precisa. Então coloque-o em uma matriz. Aqui criei dois números aleatórios e usei total deles para maximizar a velocidade do programa, minimizando a taxa de falha que obter um número útil. No entanto, a adição de números gerados também dará alguma biassness. Então eu recomendaria meu primeiro método para gerar números aleatórios dentro de uma faixa específica.
Em ambos os métodos, a sua consola irá mostrar o resultado.(Pressione f12 no Chrome para abrir a consola)
Para um inteiro aleatório com um intervalo, tente:
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;
}
Aqui está a implementação do MS DotNet de classe aleatória em 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;
}());
Utilização:
var r = new Random();
var nextInt = r.Next(1, 100); //returns an integer between range
var nextDbl = r.NextDouble(); //returns a random decimal
Se necessitar de uma variável entre 0 e o máximo pode utilizar:
Math.floor(Math.random() * max);
0.5 + (Math.random() * ((6 - 1) + 1))
Isto multiplica um número aleatório por 6 e depois adiciona-lhe 0,5. Próximo round o número para um inteiro positivo, fazendo:
Math.round(0.5 + (Math.random() * ((6 - 1) + 1))
Este arredondado o número para o número inteiro mais próximo.
Ou para que seja mais compreensível fazer isto:
var value = 0.5 + (Math.random() * ((6 - 1) + 1))
var roll = Math.round(value);
return roll;
Em geral, o código para fazer isto usando variáveis é:
var value = (Min - 0.5) + (Math.random() * ((Max - Min) + 1))
var roll = Math.round(value);
return roll;
A razão para retirar 0, 5 do valor mínimo é porque se utiliza o valor mínimo o valor sozinho permitiria que você começ um inteiro que era um a mais do que seu valor máximo. Ao retirar 0,5 do valor mínimo, está essencialmente a impedir que o valor máximo seja arredondado.
Espero que isso ajude.
Se usar o seguinte código, poderá gerar uma série de números aleatórios, sem repetir, num dado intervalo.
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;
}
Número inteiro aleatório entre o mais baixo e o mais alto:
function randomRange(l,h){
var range = (h-l);
var random = Math.floor(Math.random()*range);
if (random === 0){random+=1;}
return l+random;
}
Não é a solução mais elegante.. mas algo rápido.
Encontrei este método simples em W3Schools:
Math.floor((Math.random() * max) + min);
Espero que isto ajude alguém.
function random(high,low) {
high++;
return Math.floor((Math.random())*(high-low))+low;
}
Executamos high++
Porque Math.random()
gera um número aleatório entre 0, (inclusivo), e 1(exclusivo) o que está a ser excluído, significa que temos de aumentar o alto por um antes de executar qualquer matemática. Em seguida, subtrai - se baixo de alto, dando-nos o número mais alto para gerar-baixo, em seguida, mais baixo, trazendo alto de volta ao normal, e tornando o número mais baixo pelo menos baixo baixo. então nós retornamos o número resultante
random(7,3)
pode voltar 3,4,5,6, or 7
<!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 criar um array cheio com um número até 3 dígitos que seria um máximo de 999. Este código é muito curto.
Se ajuda a usá-lo, aqui está:
// 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 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;
}
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)));
}
Para testar esta função, e variações desta função, salve o HTML/JavaScript abaixo para um arquivo e abra com um navegador. O código produzirá um gráfico mostrando a distribuição de um milhão de chamadas de funções. O código também registrará os casos de bordas, então se a função produzir um valor maior que o máximo, ou menor que o min, 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>
function rnd(min,max){
return Math.floor(Math.random()*(max-min+1)+min );
}
Isto consegue gerar um número aleatório único de 20 dígitos
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);
/*
Escreva uma função chamada randUpTo
que aceita um número e devolve um
um número aleatório entre 0 e esse número?
*/
var randUpTo = function(num) {
return Math.floor(Math.random() * (num - 1) + 0);
};
/*
Escreva uma função chamada randBetween
que aceita dois números
representa um intervalo e devolve um número inteiro aleatório entre esses dois
numero.
*/
var randBetween = function (min, max) {
return Math.floor(Math.random() * (max - min - 1)) + min;
};
/*
Escreva uma função chamada randFromTill
que aceita dois números
representa um intervalo e devolve um número aleatório entre min (inclusive)
e max (exclusivo).
*/
var randFromTill = function (min, max) {
return Math.random() * (max - min) + min;
};
/*
Escreva uma função chamada randFromTo
que aceita dois números
representando um intervalo e devolve um inteiro aleatório entre o min (inclusive)
e max (inclusive)
*/
var randFromTo = function (min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
};
Solução Alternativa: -
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));
E também para verificar se essa distribuição seria mais ou menos a mesma nos diferentes navegadores.
Então aqui está um excerto para executar. Os números podem ser alterados antes de carregar no botão.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>