repetir - ¿Generando números enteros al azar en JavaScript en un rango específico?
numeros aleatorios en javascript sin repetir (25)
¿Cómo puedo generar un número entero aleatorio entre dos variables especificadas en Javascript, por ejemplo, x = 4 e y = 8 daría como resultado cualquiera de 4, 5, 6, 7, 8?
Math.random()
De la documentación de la Red de Desarrolladores de Math.random() :
// Returns a random integer between min (include) and max (include)
Math.floor(Math.random() * (max - min + 1)) + min;
Ejemplos utiles:
// 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;
/ * ¿Escribir una función llamada randUpTo que acepte un número y devuelva un número entero aleatorio entre 0 y ese número? * /
var randUpTo = function(num) {
return Math.floor(Math.random() * (num - 1) + 0);
};
/ * Escribe una función llamada randBetween que acepta dos números que representan un rango y devuelve un número entero aleatorio entre esos dos números. * /
var randBetween = function (min, max) {
return Math.floor(Math.random() * (max - min - 1)) + min;
};
/ * Escribe una función llamada randFromTill que acepte dos números que representan un rango y devuelve un número aleatorio entre min (incluido) y max (exclusivo). * /
var randFromTill = function (min, max) {
return Math.random() * (max - min) + min;
};
/ * Escribe una función llamada randFromTo que acepte dos números que representan un rango y devuelve un entero aleatorio entre min (inclusivo) y max (inclusivo) * /
var randFromTo = function (min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
};
Aquí está la clase de implementación aleatoria de MS DotNet en 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;
}());
Utilizar:
var r = new Random();
var nextInt = r.Next(1, 100); //returns an integer between range
var nextDbl = r.NextDouble(); //returns a random decimal
Después de generar un número aleatorio usando un programa de computadora, todavía se considera como un número aleatorio si el número seleccionado es una parte o el número entero del inicial. Pero si se cambió, entonces los matemáticos no lo aceptan como un número aleatorio y pueden llamarlo un número sesgado. Pero si está desarrollando un programa para una tarea simple, este no será un caso a considerar. Pero si está desarrollando un programa para generar un número aleatorio para un material valioso como un programa de lotería o un juego de apuestas, la administración rechazará su programa si no tiene en cuenta el caso anterior.
Así que para ese tipo de personas, aquí está mi sugerencia:
Genera un número aleatorio usando Math.random() . ( Math.random() esto 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.
Si sabe cómo leer la tabla de números aleatorios para elegir un número aleatorio, sabe que el proceso anterior (multiplicar por 1, 10, 100 y así sucesivamente) no viola el que mencioné al principio. (Porque solo cambia la lugar de la coma decimal)
Estudia el siguiente ejemplo y desarrollalo según tus necesidades.
Si necesita una muestra [0,9], entonces piso de n * 10 es su respuesta y si necesita [0,99] entonces piso de n * 100 es su respuesta y así sucesivamente.
Ahora deja entrar en tu papel:
Has pedido números entre rango específico. (En este caso, está sesgado entre ese rango. - Al tomar un número de [1,6] tirando un dado, entonces está sesgado en [1,6] pero aún así es aleatorio si y solo si el dado es imparcial .)
Entonces considere su rango ==> [78, 247] número de elementos del rango = 247 - 78 + 1 = 170; (ya que ambos límites son 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: En el método uno, primero creé una matriz que contiene los números que necesitas y luego los puse aleatoriamente en otra matriz. En el método dos, genere números al azar y verifique que estén en el rango que necesita. Luego ponlo en una matriz. Aquí generé dos números aleatorios y utilicé el total de ellos para maximizar la velocidad del programa al minimizar la tasa de falla que obtiene un número útil. Sin embargo, la adición de números generados también dará un cierto sesgo. Así que recomendaría mi primer método para generar números aleatorios dentro de un rango específico.
En ambos métodos, la consola mostrará el resultado. (Presione f12 en Chrome para abrir la consola)
Devuelve un número aleatorio entre 1 y 10:
Math.floor((Math.random()*10) + 1);
Devuelve un número aleatorio entre 1 y 100:
Math.floor((Math.random()*100) + 1)
Esto es lo que uso para generar números aleatorios.
function random(high,low) {
high++;
return Math.floor((Math.random())*(high-low))+low;
}
Math.random() high++ porque Math.random() genera un número aleatorio entre 0, (inclusive) y 1 (exclusivo). El que se excluye, significa que debemos aumentar el alto en uno antes de ejecutar cualquier cálculo matemático. Luego restamos bajo de alto, dándonos el número más alto para generar: bajo, luego + bajo, devolviendo el alto a la normalidad y haciendo que el número más bajo sea al menos bajo. luego devolvemos el número resultante
random(7,3) podría devolver 3,4,5,6, or 7
Esto puede manejar la generación de hasta 20 dígitos de un número aleatorio ÚNICO
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);
Hay algunos ejemplos en la página de la Red de Desarrolladores de Mozilla :
/**
* 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;
}
Aquí está la lógica detrás de esto. Es una regla simple de tres:
Math.random() devuelve un Number entre 0 (incluido) y 1 (exclusivo). Entonces tenemos un intervalo como este:
[0 .................................... 1)
Ahora, nos gustaría un número entre min (incluido) y max (exclusivo):
[0 .................................... 1)
[min .................................. max)
Podemos usar Math.random para obtener el corresponsal en el intervalo [min, max]. Pero, primero deberíamos analizar un poco el problema restando min del segundo intervalo:
[0 .................................... 1)
[min - min ............................ max - min)
Esto da:
[0 .................................... 1)
[0 .................................... max - min)
Ahora podemos aplicar Math.random y luego calcular el corresponsal. Vamos a elegir un número aleatorio:
Math.random()
|
[0 .................................... 1)
[0 .................................... max - min)
|
x (what we need)
Entonces, para encontrar x , haríamos:
x = Math.random() * (max - min);
No olvide agregar min vuelta, para que obtengamos un número en el intervalo [min, max):
x = Math.random() * (max - min) + min;
Esa fue la primera función de MDN. El segundo, devuelve un entero entre min y max , ambos inclusive.
Ahora para obtener números enteros, puedes usar round , ceil o floor .
Podría usar Math.round(Math.random() * (max - min)) + min , pero esto da una distribución no uniforme. Ambos, min y max solo tienen aproximadamente la mitad de la posibilidad de rodar:
min...min+0.5...min+1...min+1.5 ... max-0.5....max
└───┬───┘└────────┬───────┘└───── ... ─────┘└───┬──┘ ← Math.round()
min min+1 max
Con el max excluido del intervalo, tiene incluso menos posibilidades de rodar que el min .
Con Math.floor(Math.random() * (max - min +1)) + min tienes una distribución perfectamente uniforme.
min.... min+1... min+2 ... max-1... max.... max+1 (is excluded from interval)
| | | | | |
└───┬───┘└───┬───┘└─── ... ┘└───┬───┘└───┬───┘ ← Math.floor()
min min+1 max-1 max
No puedes usar ceil() y -1 en esa ecuación porque max ahora tenía una probabilidad ligeramente menor de tirar, pero también puedes sacar el resultado min-1 (no deseado).
Hola chicos. He creado una función javascript igual a Math.random () mediante la cual podemos generar un número aleatorio de cualquier longitud especificada . Sin utilizar ninguna función 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;
}
Las otras respuestas no tienen en cuenta los parámetros perfectamente razonables de 0 y 1 . En su lugar, debe utilizar la round lugar de ceil o 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
Me pregunté cómo sería la distribución después de suficientes ejecuciones para una función aleatoria de este tipo.
Y también para comprobar si esa distribución sería más o menos la misma en los diferentes navegadores.
Así que aquí hay un fragmento para ejecutar. Los números se pueden cambiar antes de presionar el botón.
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>
Número entero aleatorio entre el más bajo y el más alto:
function randomRange(l,h){
var range = (h-l);
var random = Math.floor(Math.random()*range);
if (random === 0){random+=1;}
return l+random;
}
No es la solución más elegante ... pero algo rápida.
Para obtener un número aleatorio, digamos entre 1 y 6, primero haz:
0.5 + (Math.random() * ((6 - 1) + 1))
Esto multiplica un número aleatorio por 6 y luego le agrega 0.5. Luego redondea el número a un entero positivo haciendo:
Math.round(0.5 + (Math.random() * ((6 - 1) + 1))
Esto redondea el número al número entero más cercano.
O para hacerlo más comprensible haz esto:
var value = 0.5 + (Math.random() * ((6 - 1) + 1))
var roll = Math.round(value);
return roll;
En general, el código para hacer esto usando variables es:
var value = (Min - 0.5) + (Math.random() * ((Max - Min) + 1))
var roll = Math.round(value);
return roll;
La razón para quitar 0.5 del valor mínimo es porque usar solo el valor mínimo le permitiría obtener un número entero que era uno más que su valor máximo. Al eliminar 0.5 del valor mínimo, esencialmente evita que el valor máximo se redondee.
Espero que ayude.
Para un entero aleatorio con un rango, intente:
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;
}
Sé que esta pregunta ya está contestada, pero mi respuesta podría ayudar a alguien.
Encontré este método simple en W3Schools:
Math.floor((Math.random() * max) + min);
Espero que esto ayude a alguien.
Si necesitas una variable entre 0 y max puedes usar:
Math.floor(Math.random() * max);
Solución 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));
Usando el siguiente código puede generar una matriz de números aleatorios, sin repetir, en un rango dado.
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;
}
esta es mi opinión sobre un número aleatorio dentro de un rango, ya que quería obtener un número aleatorio dentro de un rango de base a exponente. por ejemplo, base = 10, exponente = 2, da un número aleatorio de 0 a 100, idealmente, y así sucesivamente.
Si ayuda a usarlo, aquí 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);
<!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 crea una matriz rellena con un número de hasta 3 dígitos que sería un máximo de 999. Este código es muy corto.
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 probar esta función, y las variaciones de esta función, guarde el código HTML / JavaScript a continuación en un archivo y ábralo con un navegador. El código producirá un gráfico que muestra la distribución de un millón de llamadas a funciones. El código también registrará los casos de borde, por lo que si la función produce un valor mayor que el máximo, o menor que el mínimo, usted lo sabrá.about.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 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.
}
Descompostura:
Estamos devolviendo una función (tomando prestado de la programación funcional) que cuando se le llama, devolverá un entero aleatorio entre los valores bottom y top , inclusive. Decimos ''inclusivo'' porque queremos incluir los valores superior e inferior en el rango de números que se pueden devolver. De esta manera, getRandomizer( 1, 6 ) devolverá 1, 2, 3, 4, 5 o 6.
(la parte inferior es el número más bajo, la parte superior es el número mayor)
Math.random() * ( 1 + top - bottom )
Math.random() devuelve un doble aleatorio entre 0 y 1, y si lo multiplicamos por uno más la diferencia entre la top e bottom , obtendremos un doble en algún lugar entre 0 y 1+ba .
Math.floor( Math.random() * ( 1 + top - bottom ) )
Math.floor redondea el número al entero más cercano. Así que ahora tenemos todos los números enteros entre 0 y top-bottom . El 1 parece confuso, pero debe estar allí porque siempre estamos redondeando hacia abajo, por lo que el número superior nunca se alcanzará sin él. El decimal aleatorio que generamos debe estar en el rango de 0 a (1+top-bottom) para que podamos redondear hacia abajo y obtener un int en el rango de 0 hasta top-bottom
Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom
El código en el ejemplo anterior nos dio un número entero en el rango 0 y top-bottom , por lo que todo lo que tenemos que hacer ahora es agregar la bottom a ese resultado para obtener un número entero en el rango bottom y top inclusive. :RE
NOTA: Si pasa un valor no entero o el número mayor primero obtendrá un comportamiento no deseado, pero a menos que alguien lo solicite, no voy a profundizar en el código de verificación de argumentos, ya que está bastante lejos de la intención de la pregunta original. .
function randomRange(min, max) {
return ~~(Math.random() * (max - min + 1)) + min
}
Alternativa si está usando Underscore.js puede usar
_.random(min, max)
function rnd(min,max){
return Math.floor(Math.random()*(max-min+1)+min );
}
var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;