javascript - repetir - sintaxis de random




¿Generando números enteros al azar en JavaScript en un rango específico? (17)

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

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

JsFiddle


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


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>


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

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

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

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




integer