Gerando números inteiros randoms em JavaScript em um intervalo específico?

Como posso gerar um número inteiro random entre duas variables ​​especificadas em JavaScript, por exemplo, x = 4 e y = 8 produziria qualquer um dos 4, 5, 6, 7, 8?

Existem alguns exemplos na página da 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) * Using Math.round() will give you a non-uniform distribution! */ function getRandomInt(min, max) { return Math.floor(Math.random() * (max - min + 1)) + min; } 

Aqui está a lógica por trás disso. É uma regra simples de três:

Math.random() retorna um Number entre 0 (inclusive) e 1 (exclusivo). Então nós temos um intervalo assim:

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

Agora, gostaríamos de um número entre min (inclusive) e max (exclusive):

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

Podemos usar o Math.random para obter o correspondente no intervalo [min, max]. Mas, primeiro devemos fatorar um pouco o 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 random:

  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 min back, para que possamos obter um número no intervalo [min, max]:

 x = Math.random() * (max - min) + min; 

Essa foi a primeira function do MDN. O segundo, retorna um inteiro entre min e max , ambos inclusivos.

Agora, para obter números inteiros, você poderia usar round , ceil ou floor .

Você pode usar Math.round(Math.random() * (max - min)) + min , isso, no entanto, fornece uma distribuição não uniforme. Ambos, min e max têm apenas 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 o max excluído do intervalo, ele tem uma chance ainda menor de rolar do que o min .

Com Math.floor(Math.random() * (max - min +1)) + min você tem 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 

Você não pode usar ceil() e -1 nessa equação porque max agora tem uma chance ligeiramente menor de rolar, mas você também pode rolar o resultado (indesejado) min-1 .

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

Math.random ()

Da documentação da Mozilla Developer Network:

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

uso:

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

demolir:

Estamos retornando uma function (emprestada da functional programming) que, quando chamada, retornará um inteiro random entre os valores bottom e top , inclusive. Dizemos "inclusivo" porque queremos include a parte inferior e a superior no intervalo de números que podem ser retornados. Dessa forma, getRandomizer( 1, 6 ) retornará 1, 2, 3, 4, 5 ou 6.

(inferior é menor, top é maior)

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

Math.random() retorna um double random entre 0 e 1, e se multiplicarmos por um mais a diferença entre top e bottom , obteremos um double em algum lugar entre 0 e 1+ba .

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

Math.floor arredonda o número para o número inteiro mais próximo. Então agora temos todos os inteiros entre 0 e o top-bottom . O 1 parece confuso, mas precisa estar lá porque estamos sempre arredondando para baixo, então o número mais alto nunca será realmente alcançado sem ele. O decimal random que geramos precisa estar no intervalo de 0 a (1+top-bottom) para que possamos arredondar para baixo e obter um int no intervalo de 0 a top-bottom

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

O código no exemplo anterior nos forneceu um inteiro no intervalo 0 e na top-bottom , portanto, tudo o que precisamos fazer agora é adicionar bottom a esse resultado para obter um inteiro no intervalo bottom e top inclusive. : D


OBSERVAÇÃO: Se você passar um valor não-inteiro ou o número maior primeiro, obterá um comportamento indesejável, mas, a menos que alguém o solicite, não irei me aprofundar no código de verificação de argumentos, pois ele está muito longe da intenção da pergunta original. .

Retornar um número random entre 1 e 10:

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

Retornar um número random entre 1 e 100:

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

Alternativa se você estiver usando Underscore.js você pode usar

 _.random(min, max) 

As outras respostas não respondem pelos parâmetros perfeitamente razoáveis ​​de 0 e 1 . Em vez disso, você deve usar a round vez 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 random usando um programa de computador, ele ainda é considerado como um número random se o número selecionado for uma parte ou o número completo do inicial. Mas, se foi mudado, os matemáticos não o aceitam como um número random e podem chamá-lo de número parcial. Mas se você estiver desenvolvendo um programa para uma tarefa simples, isso não será um caso a considerar. Mas se você estiver desenvolvendo um programa para gerar um número random para um material valioso, como um programa de loteria ou um jogo de azar, seu programa será rejeitado pela gerência se você não considerar o caso acima.

Então, para esse tipo de pessoa, esta é minha sugestão:

Gere um número random usando Math.random() (diga isso n )

 Now for [0,10) ==> n*10 (ie one digit) and for[10,100) ==> n*100 (ie 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. (ie get floor) - using Math.floor(), this can be done. 

Se você sabe ler a tabela numérica aleatória para escolher um número random, você sabe que o processo acima (multiplicando por 1, 10, 100 e assim por diante) não viola o que eu fui mencionado no começo (porque muda apenas o lugar do ponto decimal.)

Estude o seguinte exemplo e desenvolva-o de acordo com suas necessidades.

Se você precisar de uma amostra [0,9], então o piso de n * 10 é sua resposta e, se necessário [0,99], o piso de n * 100 é sua resposta e assim por diante.

Agora vamos entrar em sua function:

Você pediu números entre um intervalo específico. (Nesse caso, você é tendencioso nesse intervalo. – Tirar um número de [1,6] rolando um dado, então você é inclinado para [1,6], mas ainda assim é random se e somente se morrer for imparcial .)

Portanto, considere o seu intervalo ==> [78, 247] número de elementos do intervalo = 247 – 78 + 1 = 170; (desde 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 primeiro método, criei uma matriz que contém números que você precisa e, em seguida, coloque-os aleatoriamente em outra matriz. No método dois, gere números aleatoriamente e verifique se estão no intervalo de que você precisa. Em seguida, coloque-o em uma matriz. Aqui eu gerei dois números randoms e usei o total deles para maximizar a velocidade do programa minimizando a taxa de falha que obtém um número útil. No entanto, a adição de números gerados também dará algum viés. Então, eu recomendaria meu primeiro método para gerar números randoms dentro de um intervalo específico.

Nos dois methods, o console mostrará o resultado (pressione f12 no Chrome para abrir o console)

Para um inteiro random 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 Implementation of Random 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; }()); 

Usar:

  var r = new Random(); var nextInt = r.Next(1, 100); //returns an integer between range var nextDbl = r.NextDouble(); //returns a random decimal 

Para obter um número random, diga entre 1 e 6, primeiro faça:

  0.5 + (Math.random() * ((6 - 1) + 1)) 

Isso multiplica um número random por 6 e adiciona 0,5 a ele. Na próxima rodada o número para um inteiro positivo, fazendo:

  Math.round(0.5 + (Math.random() * ((6 - 1) + 1)) 

Isso arredonda o número para o número inteiro mais próximo.

Ou, para tornar mais compreensível, faça isso:

  var value = 0.5 + (Math.random() * ((6 - 1) + 1)) var roll = Math.round(value); return roll; 

Em geral, o código para fazer isso usando variables ​​é:

  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 usar apenas o valor mínimo permitiria obter um inteiro que fosse um a mais que seu valor máximo. Tirando 0.5 do valor mínimo você está impedindo essencialmente que o valor máximo seja arredondado.

Espero que ajude.

Usando o código a seguir, você pode gerar um array de números randoms, sem repetir, em um determinado 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. ie 4 // max(inclusive) : maximun value of a range. it must be any positive integer. ie 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; } 

Se você precisa de uma variável entre 0 e max você pode usar:

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

Número inteiro random entre o menor e o maior:

 function randomRange(l,h){ var range = (hl); 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.

Eu sei que esta pergunta já foi respondida, mas minha resposta poderia ajudar alguém.

Eu encontrei este método simples no W3Schools:

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

Espero que isso ajude alguém.

Aqui está o que eu uso para gerar números randoms.

 function random(high,low) { high++; return Math.floor((Math.random())*(high-low))+low; } 

Nós executamos high++ porque Math.random() gera um número random entre 0, (inclusive), e 1 (exclusive) O que está sendo excluído, significa que devemos aumentar o valor alto por um antes de executar qualquer matemática. Em seguida, subtraímos de baixo para cima, dando-nos o maior número para gerar – baixo, depois + baixo, elevando o nível de volta ao normal e diminuindo o número mais baixo. então retornamos o número resultante

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

           

Uint8Array cria uma matriz preenchida com um número até 3 dígitos, que seria um máximo de 999. Este código é muito curto.

Esta é a minha opinião sobre um número random em um intervalo, como em que eu queria obter um número random dentro de um intervalo de base para expoente. ex. base = 10, expoente = 2, dá um número random de 0 a 100, idealmente, e assim por diante.

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

Ei pessoal Eu criei uma function javascript mesmo que Math.random () usando o qual podemos gerar um número random de qualquer comprimento especificado . Sem usar qualquer function Math.random .

  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 essa function e variações dessa function, salve o HTML / JavaScript abaixo em 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 function. O código também registrará os casos de borda, portanto, se a function produzir um valor maior que o max, ou menor que o min, you.will.know.about.it.

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

Isso pode manipular a geração de até 20 dígitos UNIQUE número random

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

insira a descrição da imagem aqui

JsFiddle

/ * Escreve uma function chamada randUpTo que aceita um número e retorna um número inteiro random entre 0 e esse número? * /

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

/ * Escreva uma function chamada randBetween que aceita dois números representando um intervalo e retorna um número inteiro random entre esses dois números. * /

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

/ * Escreve uma function chamada randFromTill que aceita dois números representando um intervalo e retorna um número random entre min (inclusive) e max (exclusive). * /

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

/ * Escreve uma function chamada randFromTo que aceita dois números representando um intervalo e retorna um inteiro random entre 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)); 

Fiquei me perguntando como seria a distribuição após execuções suficientes para essa function de aleatorização.

E também para verificar se essa distribuição seria mais ou menos a mesma nos diferentes navegadores.

Então aqui está um trecho para ser executado. Os números podem ser alterados antes de pressionar o botão.

 function getRandomNumberInRange(Min, Max) { return Math.floor(Math.random() * (Max - Min + 1)) + Min; } function printDictAsTable(dict){ let htmlstr = ""; let sortedKeys = Object.keys(dict).sort(function(a,b){return ab}); for (let i=0; i"; } htmlstr += "
NumberCount
" + dict[key] + "
"; 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();
 

Min :

Max :

Loops: