¿Generar números enteros aleatorios en JavaScript en un rango específico?

1955

¿Cómo puedo generar números enteros aleatorios entre dos variables especificadas en JavaScript, por ejemplo, x = 4y y = 8generaría alguna 4, 5, 6, 7, 8?

zacharyliu
fuente
1
Aquí hay un resumen
Dan KK
99
Como nota al margen: para aquellos que usan npm y buscan una solución rápida, confiable y lista para usar , hay lodash.random que se puede requerir fácilmente con una huella súper pequeña (importará solo el método en sí y no todo el lodash).
Nobita
si necesita ser cripto seguro developer.mozilla.org/en-US/docs/Web/API/RandomSource/…
feliz

Respuestas:

3835

Hay algunos ejemplos en la página 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;
}

Aquí está la lógica detrás de esto. Es una regla simple de tres:

Math.random()devuelve un valor Numberentre 0 (incluido) y 1 (exclusivo). Entonces tenemos un intervalo como este:

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

Ahora, nos gustaría un número entre min(inclusive) y max(exclusivo):

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

Podemos usar el Math.randompara obtener el correspondiente en el intervalo [min, max). Pero, primero debemos factorizar un poco el problema restando mindel segundo intervalo:

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

Esto da:

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

Ahora podemos aplicar Math.randomy luego calcular el corresponsal. Elija 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 minvolver a agregar , 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 número entero entre miny max, ambos inclusive.

Ahora para obtener enteros, puedes usar round, ceilo floor.

Podría usar Math.round(Math.random() * (max - min)) + min, sin embargo, esto proporciona una distribución no uniforme. Ambos, miny maxsolo tienen aproximadamente la mitad de posibilidades de rodar:

min...min+0.5...min+1...min+1.5   ...    max-0.5....max
└───┬───┘└────────┬───────┘└───── ... ─────┘└───┬──┘    Math.round()
   min          min+1                          max

Con maxexcluidos del intervalo, tiene incluso menos posibilidades de rodar que min.

Con Math.floor(Math.random() * (max - min +1)) + minusted tiene 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 puede usar ceil()y -1en esa ecuación porque maxahora tenía una probabilidad ligeramente menor de rodar, pero también puede rodar el resultado (no deseado) min-1.

Ionuț G. Stan
fuente
10
Solo está haciendo eso porque está llamando floor, que se redondea.
Josh Stodola
44
@ thezachperson31 Podría usar round, pero luego ambos, miny maxsolo tenía la mitad de posibilidades de rodar como lo hacen los otros números. También puedes restar uno y tomar ceil. Sin embargo, esto deja al maxnúmero con una probabilidad mínima de rodar debido al [0,1)intervalo.
Christoph
12
He creado un JSFiddle si alguien quiere probar la distribución de este método: jsfiddle.net/F9UTG/1
ahren
8
@JackFrost sí, eso es correcto. No eres tonto, solo estás aprendiendo :)
Ionuț G. Stan
3
Esta pregunta es antigua, pero comprender esta respuesta me llevó demasiado tiempo Oo, creo que expandir las matemáticas al azar en la próxima versión de JavaScript sería algo útil
Jonathan Ortega
527
var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
Darin Dimitrov
fuente
19
Sé que esta es una respuesta MUY antigua, pero el uso (Math.random() * (maximum - minimum + 1) ) << 0es más rápido.
Ismael Miguel
11
@IsmaelMiguel Utilización de operadores binarios ( x << 0, x | 0, ~~x) en lugar de Math.floor()los convertidos xen dos complemento con un rango mucho menor que Number.MAX_SAFE_INTEGER(vs 2³²⁻¹ 2⁵³), por lo tanto usted tiene que usarlo con precaución!
le_m
@IsmaelMiguel Yo ¡Acabo de probar tu método en la consola y obtuve un valor negativo al azar! Math.randRange = (mínimo, máximo) => (Math.random () * (máximo - mínimo + 1)) << 0 Math.randRange (2,657348096152) -1407373159
bluejayke
@bluejayke Porque 657348096152 (1001100100001100111111111111000010011000 en binario) tiene 40 bits, mientras que la aritmética bit a bit usa 32 bits. Si lo haces 657348096152|0, obtienes 218099864 (1100111111111111000010011000 en binario).
Ismael Miguel
1
Esta es una respuesta inteligente. Al hacer el rango internamente [min, max + 1) en realidad se logra el resultado deseado de [min, max] siendo ambos inclusivos. ¡Gracias! :)
Mladen B.
135

Math.random ()

Devuelve un número aleatorio entero entre min ( incluido ) y max ( incluido ):

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

O cualquier número aleatorio entre min ( incluido ) y max ( no incluido ):

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

Ejemplos útiles (enteros):

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

** Y siempre es bueno recordarlo (Mozilla):

Math.random () no proporciona números aleatorios criptográficamente seguros. No los use para nada relacionado con la seguridad. Utilice la API de cifrado web en su lugar y, más precisamente, el método window.crypto.getRandomValues ​​().

Lior Elrom
fuente
56
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 prestada de la programación funcional) que cuando se llama, devolverá un número entero aleatorio entre los valores bottome topinclusive. Decimos "inclusivo" porque queremos incluir tanto los de abajo como los de arriba 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 inferior, la 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 topy bottom, obtendremos un doble en algún lugar entre 0y 1+b-a.

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

Math.floorredondea el número al entero más cercano. Entonces ahora tenemos todos los enteros entre 0y 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 0para (1+top-bottom)poder redondear hacia abajo y obtener un int en el rango 0paratop-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 0y top-bottom, por lo tanto, todo lo que tenemos que hacer ahora es agregar bottoma ese resultado para obtener un número entero en el rango bottome topinclusive. :RE


NOTA: Si pasa un valor no entero o el número mayor primero, obtendrá un comportamiento indeseable, 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 .

Gordon Gustafson
fuente
1
Me doy cuenta de que esto es aproximadamente 2 años y medio después, pero con la entrada 1 y 6 su función devuelve valores 1,2,3,4 y 5, pero nunca un 6, como lo haría si fuera "inclusivo".
Algunos de
99
@some, podría ser peor, tengo 2 años y medio + 1 día después ^^
ajax333221
+1, probé su código, parece crear un valor correcto. Estructura creativa para manejar escenarios fijos que pueden repetirse mucho en el código.
Chris
¿Por qué tienes una función dentro de una función para esto?
Alph.Dev
1
@ Alph.Dev Para desacoplar la lógica que usa el generador de números aleatorios de la lógica que decide exactamente qué distribución de números aleatorios usar. Cuando el código que usa el generador de números aleatorios lo acepta como parámetro (una función de argumento 0 que siempre devuelve un nuevo número aleatorio) puede funcionar con cualquier tipo de generador de números aleatorios.
Gordon Gustafson
31
function randomRange(min, max) {
  return ~~(Math.random() * (max - min + 1)) + min
}

Alternativa si está utilizando Underscore.js puede usar

_.random(min, max)
Codler
fuente
1
El subrayado en realidad proporciona una _.uniqueId()función que puede llamar para modelos del lado del cliente.
obfk
Utilización de operadores binarios ( x << 0, x | 0, ~~x) en lugar de Math.floor()los convertidos xen una de dos complemento con un rango mucho menor que Number.MAX_SAFE_INTEGER(vs 2³²⁻¹ 2⁵³), por lo tanto usted tiene que usarlo con precaución!
le_m
31

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)
Prasobh.Kollattu
fuente
¿Es su "entre" inclusivo o exclusivo? es decir, [1,10], [1,10), (1,10] o (1,10)?
evandrix
1
Es parcialmente inclusivo: [1, *)
Ivan Z
¿Cuál es la necesidad de + 1 al final de la función? Funciona perfectamente, supongo.
Shachi
18

Si necesita una variable entre 0 y max, puede usar:

Math.floor(Math.random() *  max);
Stanislav Vincent
fuente
¿Es max inclusivo o exclusivo>?
Árbol
2
@Tree usando Math.floor max es exclusivo. Si desea que max sea inclusivo, puede usar Math.round.
Lucas
14

Las otras respuestas no tienen en cuenta los parámetros perfectamente razonables de 0y 1. En su lugar, debe usar el en round lugar de ceilo 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
Starkers
fuente
1
Su respuesta es verdadera, pero creo que su ejemplo es incorrecto. console.log(randomNumber(5,6)); # 9 6 6 5 7 7¿Los números 9 y 7 se encuentran entre 5 y 6? ...... deberías corregirlo o explicarlo ..
Sachin
12

Aquí está la implementación MS DotNet de la clase Random 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
Ariful Islam
fuente
La clase MS DotNet Random está bajo la licencia Ms-RSL , lo que significa que tiene derechos de autor. Por lo tanto, tenga cuidado al usar este código derivado, ya que puede ser motivo para casos de infracción de derechos de autor.
JohannesB
12

Use esta función para obtener números aleatorios entre el rango dado

function rnd(min,max){
    return Math.floor(Math.random()*(max-min+1)+min );
}
revs Aylian Craspa
fuente
10

Después de generar un número aleatorio utilizando un programa de computadora, todavía se considera como un número aleatorio si el número seleccionado es parte o el número completo 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 azar, la administración rechazará su programa si no tiene en cuenta el caso anterior.

Entonces, para ese tipo de personas, aquí está mi sugerencia:

Genere un número aleatorio usando Math.random(). (Diga 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, etc.) no viola el que mencioné al principio. (Porque solo cambia el lugar del punto decimal.)

Estudie el siguiente ejemplo y desarrolle según sus necesidades.

Si necesita una muestra [0,9], entonces el piso de n * 10 es su respuesta y si necesita [0,99] entonces el piso de n * 100 es su respuesta y así sucesivamente.

Ahora deja entrar en tu rol:

Has pedido números entre un rango específico. (En este caso, estás sesgado dentro de ese rango. - Al tomar un número de [1,6] tirando un dado, entonces estás sesgado en [1,6] pero aún así es aleatorio si y solo si el dado es imparcial .)

Así que 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 números que necesita y luego los puse al azar en otra matriz. En el método dos, genere números al azar y verifique que estén en el rango que necesita. Luego póngalo en una matriz. Aquí generé dos números aleatorios y usé el total de ellos para maximizar la velocidad del programa minimizando la tasa de falla que obtenía un número útil. Sin embargo, agregar números generados también dará cierta parcialidad. Por lo tanto, recomendaría mi primer método para generar números aleatorios dentro de un rango específico.

En ambos métodos, su consola mostrará el resultado. (Presione f12 en Chrome para abrir la consola)

Janaka R Rajapaksha
fuente
3
"aleatorio" no necesariamente significa "distribuido uniformemente". "sesgado" no implica "no aleatorio". medios aleatorios extraídos de una distribución de probabilidad.
syzygy
66
Apenas puedo decir lo que esta respuesta está tratando de decir. Sin embargo, si necesita números aleatorios para usos como números de lotería y juegos de azar. Primero, probablemente no debería generarlos en el cliente. En segundo lugar, necesita un generador de números aleatorios criptográficamente seguro y el algoritmo suministrado no es suficiente. Llamar al azar repetidamente no hace que el resultado sea "más aleatorio". El autor parece estar preocupado por el sesgo, pero no proporciona un buen método para prevenirlo. De hecho, las otras respuestas cortas proporcionadas producen números aleatorios imparciales (suponiendo que el generador aleatorio subyacente sea imparcial).
Jeff Walker Code Ranger el
@JeffWalkerCodeRanger Creo que lo que quiso decir es que con el algoritmo "normal" [es decir, Math.floor(Math.random() * (6 - 1 + 1) + 1)] los números 1 y 6 necesariamente se rodarán menos veces que 2, 3, 4 y 5. Sin embargo, la diferencia es básicamente insignificante.
oldboy
10

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;
}
usuario1764199
fuente
8
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 siguiente HTML / JavaScript 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 límite, por lo que si la función produce un valor mayor que el máximo, o menor que el mínimo, usted.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">&nbsp;[' + (i + min - 1) + ']:&nbsp;'+array[i]+'</span>&nbsp;&nbsp;');
        }
        document.write('<hr/>');
        </script>
    </head>
    <body>

    </body>
</html>
Chris
fuente
7

Para obtener un número aleatorio que diga entre 1 y 6, primero haga:

    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, haga 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 fuera uno más que su valor máximo. Al quitar 0.5 del valor mínimo, esencialmente evita que el valor máximo se redondee hacia arriba.

Espero que ayude.

Learner.js
fuente
Tiene sentido si excluye 0 , entonces no es necesario "redondear" el rango de 0 a 0.5.
ILMostro_7
7

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;
        }
Yusuf
fuente
7

Sé que esta pregunta ya está respondida, 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.

Cascanueces
fuente
1
Math.floor ((Math.random () * 1) + 0); siempre da 0
madprops
1
@madprops Porque el número máximo es exclusivo. Para obtener 0 o 1, debe establecer 2 como número máximo.
NutCracker
1
o simplemente agrega + 1 en la función que llama a este método
Pietro Coelho
6

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ápido.

brooklynsweb
fuente
5

Esto es lo que uso para generar números aleatorios.

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

Realizamos la ejecución high++porque Math.random()genera un número aleatorio entre 0, (inclusive) y 1 (exclusivo). El excluido significa que debemos aumentar el valor 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 al menos sea bajo. luego devolvemos el número resultante

random(7,3) podría volver 3,4,5,6, or 7

Travis
fuente
2
Como highsolo se usa una vez, también puede usar en high-low+1lugar de tener la declaración de incremento separada. Además, la mayoría de los usuarios esperarían que el lowparámetro sea lo primero.
Chris Walsh
4
    <!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 llena de un número de hasta 3 dígitos que sería un máximo de 999. Este código es muy corto.

contento
fuente
4

Aquí hay un ejemplo de una función de JavaScript que puede generar un número aleatorio de cualquier longitud especificada sin usar 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;
    }
Nilesh Pawar
fuente
t1 / t2 siempre muy cerca de 1. y, por lo tanto, su función devuelve el mismo número cuando la función se llama repetidamente. jsbin.com/xogufacera/edit?js,console
Sunil BN
comprueba la URL jsbin .. verá la salida a ti mismo
Sunil BN
Funciona muy bien cuando la longitud está entre 4-10 (como lo he probado en mi máquina), porque los valores de las constantes T1 y T2 deben tener la distancia adecuada.
Nilesh Pawar
3

Esta es mi opinión sobre un número aleatorio en 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);
Goran B.
fuente
3

Math.random() es rápido y adecuado para muchos propósitos, pero no es apropiado si necesita valores criptográficamente seguros (no es seguro) o si necesita números enteros de una distribución imparcial completamente uniforme (el enfoque de multiplicación utilizado en otras respuestas produce ciertos valores un poco más a menudo que otros).

En tales casos, podemos usar crypto.getRandomValues()para generar enteros seguros y rechazar cualquier valor generado que no podamos asignar de manera uniforme en el rango objetivo. Esto será más lento, pero no debería ser significativo a menos que esté generando cantidades extremadamente grandes de valores.

Para aclarar el problema de la distribución sesgada, considere el caso en el que queremos generar un valor entre 1 y 5, pero tenemos un generador de números aleatorios que produce valores entre 1 y 16 (un valor de 4 bits). Queremos tener el mismo número de valores generados que se asignen a cada valor de salida, pero 16 no se divide equitativamente por 5: deja un resto de 1. Por lo tanto, debemos rechazar 1 de los posibles valores generados, y solo continuar cuando obtengamos uno de los 15 valores menores que se pueden mapear uniformemente en nuestro rango objetivo. Nuestro comportamiento podría parecerse a este pseudocódigo:

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.

El siguiente código utiliza una lógica similar, pero en su lugar genera un número entero de 32 bits, porque ese es el tamaño entero común más grande que puede ser representado por el numbertipo estándar de JavaScript . (Esto podría modificarse para usar BigInts si necesita un rango mayor). Independientemente del rango elegido, la fracción de valores generados que se rechazan siempre será menor que 0.5, por lo que el número esperado de rechazos siempre será menor que 1.0 y usualmente cerca de 0.0; no necesita preocuparse por que se repita para siempre.

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]

Jeremy Banks
fuente
3

Crypto-Strong

Para obtener un número entero aleatorio cripto-fuerte en ragne [x, y] intente

let cs= (x,y)=>x+(y-x+1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32|0

console.log(cs(4,8))

Kamil Kiełczewski
fuente
44
este es fascinante
Akin Hwan
1

Puedes este fragmento de código,

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;
}
Achintha Isuru
fuente
1
Hay una línea duplicada innecesaria aquí. Solo use en do - whilelugar dewhile
Javi Marzán
1

Ionuț G. Stan escribió una gran respuesta, pero fue un poco demasiado complejo para mí. Entonces, encontré una explicación aún más simple de los mismos conceptos en https://teamtreehouse.com/community/mathfloor-mathrandom-max-min-1-min-explanation por Jason Anello.

NOTA: Lo único importante que debe saber antes de leer la explicación de Jason es una definición de "truncar". Él usa ese término cuando describe Math.floor(). El diccionario de Oxford define "truncar" como:

Acorte (algo) cortando la parte superior o el extremo.

Dani Amsalem
fuente
0

Esto puede manejar la generación de números aleatorios ÚNICOS de hasta 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);

ingrese la descripción de la imagen aquí

JsFiddle

Nofi
fuente
Estoy votando esto solo porque.
Taylor Ackley
1
@TaylorAckley Esta respuesta no responde a la pregunta.
RomainValeri
0

/ * ¿Escribir una función llamada randUpToque acepta un número y devuelve un número entero aleatorio entre 0 y ese número? * /

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

/ * Escriba una función llamada randBetweenque acepte dos números que representen un rango y devuelva un número entero aleatorio entre esos dos números. * /

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

/ * Escriba una función llamada randFromTillque acepte dos números que representen un rango y devuelva un número aleatorio entre min (inclusive) y max (exclusivo). * /

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

/ * Escribe una función llamada randFromToque acepta dos números que representan un rango y devuelve un entero aleatorio entre min (inclusive) y max (inclusive) * /

var randFromTo = function (min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
};
Prakhar Mittal
fuente
1
Hermoso, ¿podrías notar que randBetween es (exclusivo) (exclusivo)?
pfdint
0

Hice esta función que tiene en cuenta opciones como min, max, exclude (una lista de entradas para excluir) y seed (en caso de que desee un generador aleatorio sembrado).

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
}

Se puede usar como:

let n = get_random_int
(
    {
        min: 0,
        max: some_list.length - 1,
        exclude: [3, 6, 5],
        seed: my_seed_function
    }
)

O más simplemente:

let n = get_random_int
(
    {
        min: 0,
        max: some_list.length - 1
    }
)

Entonces puedes hacer:

let item = some_list[n]

Gist: https://gist.github.com/madprops/757deb000bdec25776d5036dae58ee6e

madprops
fuente
0
  • random (min, max) genera un número aleatorio entre min (inclusive) y max (exclusivo)
  • Math.floor redondea un número hacia abajo al entero más cercano

    function generateRandomInteger (min, max) { 
        return Math.floor(random(min,max)) 
    }`

Entonces, para generar un entero aleatorio entre 4 y 8 inclusive, llame a la función anterior con los siguientes argumentos:

generateRandomInteger (4,9)
Normajean
fuente
0

Mi método para generar un número aleatorio entre 0 yn, donde n <= 10 (n excluido):

Math.floor((Math.random() * 10) % n)
Nitin Jadhav
fuente