Question Générer des nombres entiers aléatoires dans JavaScript dans une plage spécifique?


Comment puis-je générer un nombre entier aléatoire entre deux variables spécifiées en Javascript, par ex. x = 4 et y = 8 sortirait l'un des 4, 5, 6, 7, 8?


1484
2017-10-06 20:05


origine


Réponses:


Il y a quelques exemples sur le Réseau de développeurs Mozilla page:

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

Voici la logique derrière cela. C'est une règle simple de trois:

Math.random() retourne un Number entre 0 (inclus) et 1 (exclusif). Nous avons donc un intervalle comme celui-ci:

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

Maintenant, nous aimerions un nombre entre min (inclus) et max (exclusif):

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

Nous pouvons utiliser le Math.random pour obtenir le correspondant dans l'intervalle [min, max). Mais, d'abord, nous devrions factoriser un peu le problème en soustrayant min à partir du second intervalle:

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

Cela donne:

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

Nous pouvons maintenant appliquer Math.random puis calculez le correspondant. Choisissons un nombre aléatoire:

                Math.random()
                    |
[0 .................................... 1)
[0 .................................... max - min)
                    |
                    x (what we need)

Donc, pour trouver x, nous ferions:

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

Ne pas oublier d'ajouter min retour, de sorte que nous obtenons un nombre dans l'intervalle [min, max):

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

C'était la première fonction de MDN. Le second renvoie un entier entre min et max, les deux inclus.

Maintenant, pour obtenir des entiers, vous pouvez utiliser round, ceil ou floor.

Vous pourriez utiliser Math.round(Math.random() * (max - min)) + min, ceci donne cependant une distribution non-égale. Tous les deux, min et max seulement avoir environ la moitié de la chance de rouler:

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

Avec max exclu de l'intervalle, il a encore moins de chance de rouler que min.

Avec Math.floor(Math.random() * (max - min +1)) + min vous avez une distribution parfaitement égale.

min.... min+1... min+2 ... max-1... max.... max+1 (is excluded from interval)
|        |        |         |        |        |
└───┬───┘└───┬───┘└─── ... ┘└───┬───┘└───┬───┘   ← Math.floor()
   min     min+1               max-1    max

Vous ne pouvez pas utiliser ceil() et -1 dans cette équation parce que max maintenant eu un peu moins de chance de rouler, mais vous pouvez rouler le (indésirable) min-1 résultat aussi.


3050
2017-10-06 20:08



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

463
2017-10-06 20:09



Math.random ()

Du Mozilla Documentation du réseau de développeurs:

// Returns a random integer between min (include) and max (include)

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

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

72
2018-03-25 01:58



function getRandomizer(bottom, top) {
    return function() {
        return Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom;
    }
}

usage:

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

panne:

Nous retournons une fonction (empruntant à la programmation fonctionnelle) qui, lorsqu'elle est appelée, retournera un entier aléatoire entre les valeurs bottom et topinclusivement Nous disons «inclusif» parce que nous voulons inclure à la fois le bas et le haut dans la gamme des nombres qui peuvent être retournés. Par ici, getRandomizer( 1, 6 ) retournera 1, 2, 3, 4, 5 ou 6.

(le bas est le nombre le plus bas, le dessus est le plus grand nombre)

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

Math.random() retourne un double aléatoire entre 0 et 1, et si on le multiplie par un plus la différence entre top et bottom, nous aurons un double quelque part entre 0 et 1+b-a.

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

Math.floor arrondit le nombre à l'entier le plus proche. Nous avons maintenant tous les entiers entre 0 et top-bottom. Le 1 semble confus, mais il doit être là parce que nous sommes toujours en train d'arrondir vers le bas, de sorte que le nombre supérieur ne sera jamais atteint sans lui. La décimale aléatoire que nous générons doit être dans la plage 0 à (1+top-bottom) donc on peut arrondir vers le bas et obtenir un int dans la gamme 0 à top-bottom

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

Le code de l'exemple précédent nous a donné un entier dans la plage 0 et top-bottom, tout ce que nous devons faire maintenant est d'ajouter bottom à ce résultat pour obtenir un nombre entier dans la gamme bottom et top compris. :RÉ


NOTE: Si vous passez une valeur non-entière ou le plus grand nombre d'abord, vous obtiendrez un comportement indésirable, mais à moins que quelqu'un ne le demande, je ne vais pas fouiller dans le code de vérification d'argument comme étant loin de l'intention de la question originale .


48
2017-10-06 20:08



Renvoie un nombre aléatoire entre 1 et 10:

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

Renvoie un nombre aléatoire entre 1 et 100:

Math.floor((Math.random()*100) + 1)

27
2018-03-28 11:31



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

Alternative si vous utilisez Underscore.js vous pouvez utiliser

_.random(min, max)

26
2018-02-09 19:51



Les autres réponses ne tiennent pas compte des paramètres parfaitement raisonnables de 0 et 1. Au lieu de cela, vous devriez utiliser le round  au lieu 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

12
2017-07-21 16:42



Après avoir généré un nombre aléatoire en utilisant un programme d'ordinateur, il est toujours considéré comme un nombre aléatoire si le nombre choisi est une partie ou le nombre entier du nombre initial. Mais si cela a été changé, alors les mathématiciens ne l'acceptent pas comme un nombre aléatoire et ils peuvent l'appeler un nombre biaisé. Mais si vous développez un programme pour une tâche simple, ce ne sera pas un cas à considérer. Mais si vous développez un programme pour générer un nombre aléatoire pour un objet précieux tel qu'un programme de loterie, ou un jeu de hasard, alors votre programme sera rejeté par la direction si vous ne tenez pas compte du cas ci-dessus.

Donc, pour ce genre de personnes, voici ma suggestion:

Générer un nombre aléatoire en utilisant Math.random().(dis-le 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 vous savez lire un tableau de nombres aléatoires pour choisir un nombre aléatoire, vous savez que le processus ci-dessus (multiplier par 1, 10, 100 et ainsi de suite) ne viole pas celui que j'ai mentionné au début (parce qu'il ne change que le lieu de la virgule décimale.)

Étudiez l'exemple suivant et développez-le selon vos besoins.

Si vous avez besoin d'un échantillon [0,9] alors floor of n * 10 est votre réponse et si besoin [0,99] alors floor of n * 100 est votre réponse et ainsi de suite.

Maintenant, laissez entrer dans votre rôle:

Vous avez demandé des numéros parmi la gamme spécifique. (Dans ce cas, vous êtes biaisé dans cette fourchette - En prenant un nombre de [1,6] en jetant un dé, alors vous êtes biaisé en [1,6] mais c'est quand même un aléatoire si et seulement si le dé est neutre .)

Alors considérez votre gamme ==> [78, 247] nombre d'éléments de la gamme = 247 - 78 + 1 = 170; (puisque les deux limites sont inclusives.

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

Remarque: Dans la première méthode, j'ai d'abord créé un tableau qui contient les nombres dont vous avez besoin, puis les place au hasard dans un autre tableau. Dans la deuxième méthode, générez des nombres de manière aléatoire et vérifiez qu'ils sont dans la plage dont vous avez besoin. Ensuite, mettez-le dans un tableau. Ici, j'ai généré deux nombres aléatoires et utilisé le total d'entre eux pour maximiser la vitesse du programme en minimisant le taux de défaillance que l'obtention d'un nombre utile. Cependant, l'ajout de nombres générés donnera également une certaine importance. Donc, je recommanderais ma première méthode pour générer des nombres aléatoires dans une plage spécifique.

Dans les deux méthodes, votre console affichera le résultat. (Appuyez sur f12 dans Chrome pour ouvrir la console)


9
2018-02-10 13:22



Pour un nombre entier aléatoire avec une plage, essayez:

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

8
2017-10-25 22:15



Voici l'implémentation MS DotNet de la classe 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;
}());

Utilisation:

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

8
2017-11-15 05:38



Pour obtenir un nombre aléatoire entre 1 et 6, faites d'abord:

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

Cela multiplie un nombre aléatoire par 6, puis ajoute 0.5 à lui. Prochaine arrondir le nombre à un entier positif en faisant:

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

Ceci arrondit le nombre au nombre entier le plus proche.

Ou pour le rendre plus compréhensible, faites ceci:

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

En général, le code pour faire cela en utilisant des variables est:

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

La raison de supprimer 0,5 de la valeur minimale est que l'utilisation de la valeur minimale seule vous permettrait d'obtenir un nombre entier supérieur de un à votre valeur maximale. En supprimant 0,5 de la valeur minimale, vous évitez essentiellement d'arrondir la valeur maximale.

J'espère que cela pourra aider.


6
2017-07-22 05:56