random entière - Générer des nombres entiers aléatoires dans JavaScript dans une plage spécifique?



partie deviner (18)

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


Answers

En utilisant le code suivant, vous pouvez générer un tableau de nombres aléatoires, sans répéter, dans une plage donnée.

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

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

Math.random()

Dans la documentation de Math.random() Developer Network:

// Returns a random integer between min and max

function getRandomInt(min, max) {
  return 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;

    <!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 crée un tableau rempli d'un nombre de 3 chiffres maximum qui serait un maximum de 999. Ce code est très court.


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

Cela peut gérer générer jusqu'à 20 chiffres UNIQUE nombre aléatoire

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


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é, 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érez un nombre aléatoire en utilisant Math.random() . (Dites ceci 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 .)

Considérez donc 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)


Si vous avez besoin d'une variable entre 0 et max, vous pouvez utiliser:

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

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

Pour tester cette fonction et les variations de cette fonction, enregistrez le code HTML / JavaScript ci-dessous dans un fichier et ouvrez-le avec un navigateur. Le code produira un graphique montrant la distribution d'un million d'appels de fonction. Le code enregistrera également les cas de bords, donc si la fonction produit une valeur supérieure à la valeur max, ou inférieure à la valeur min, you.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>

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

Alternative si vous utilisez Underscore.js vous pouvez utiliser

_.random(min, max)

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. Arrondissez ensuite le nombre à un nombre entier positif en procédant comme suit:

    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.


Je sais que cette question a déjà répondu mais ma réponse pourrait aider quelqu'un.

J'ai trouvé cette méthode simple sur W3Schools:

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

J'espère que cela aidera quelqu'un.


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

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)

Nombre entier aléatoire entre le plus bas et le plus haut:

function randomRange(l,h){
  var range = (h-l);
  var random = Math.floor(Math.random()*range);
  if (random === 0){random+=1;}
  return l+random;
}

Pas la solution la plus élégante .. mais quelque chose de rapide.


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

Voici ce que j'utilise pour générer des nombres aléatoires.

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

Nous Math.random() high++ car Math.random() génère un nombre aléatoire compris entre 0, (inclusif) et 1 (exclusif). Celui exclu signifie que nous devons augmenter le haut de un avant d'exécuter un calcul. Nous soustrayons ensuite les valeurs basses et les valeurs les plus élevées, ce qui nous donne le nombre le plus élevé à générer - faible, puis + faible, ce qui ramène le haut à la normale, et rend le nombre le plus bas au moins bas. puis nous retournons le nombre résultant

random(7,3) pourrait renvoyer 3,4,5,6, or 7


Vous pouvez utiliser la méthode StaticRandom Jon Skeet dans la bibliothèque de classes MiscUtil qu'il a créée pour un nombre pseudo-aléatoire.

using System;
using MiscUtil;

class Program
{
    static void Main(string[] args)
    {
        for (int i = 0; i < 100; i++)
        {
            Console.WriteLine(StaticRandom.Next());
        }
    }
}




javascript random integer