Generarea aleatoare de numere întregi în JavaScript într-un anumit interval?

Cum pot genera aleator numere întregi între două variabile specificate în JavaScript, de exemplu x = 4 si y = 8 ar ieșire oricare dintre4, 5, 6, 7, 8?

thadeuszlay
Întrebarea editată 11 martie 2019 в 1:34
Programare
javascript random integer
6 octombrie 2009 в 8:05
41 vizualizări
Comentarii la întrebare (3)
Soluția

Există unele exemple pe Mozilla Developer Network pagina:

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

Aici's logica. L's un simplu regula de trei:

Matematica.random() returnează un Număr între 0 (inclusiv) si 1 (exclusiv). Deci, avem un interval de genul asta:

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

Acum, ne-am'd ca un număr între " min "(inclusiv) și "max." (exclusiv):

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

Putem folosi Matematica.aleatorie pentru a obține corespondent în [min, max) interval. Dar, în primul rând ar trebui să factor un pic problema prin scăderea " min " de la cel de-al doilea interval:

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

Acest lucru vă oferă:

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

Putem acum aplica Matematica.aleator și apoi se calculează corespondent. Las's alege un număr aleator:

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

Deci, în scopul de a găsi "x", ne-ar face:

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

Don't uitați să adăugați "min." înapoi, astfel încât să putem obține un număr în [min, max) interval:

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

Asta a fost prima funcție din MDN. Cel de-al doilea, returnează un număr întreg între " min " și " max.", ambele inclusiv.

Acum, pentru obtinerea de numere întregi, ai putea folosi rotund, ceil sau "podea".

Ai putea folosi Matematica.round(Math.random() * (max - min)) + min`, totuși, acest lucru vă oferă un non-chiar și de distribuție. Ambele, " min " și "max." doar aproximativ jumătate șansa de a roll:

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

Cu "max." excluse din interval, ea are o șansă să se rostogolească decât " min.".

Cu Matematica.floor(Math.random() * (max - min +1)) + min` ai un perfect chiar și distribuție.

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

Puteți't folosi ceil() și " -1 "în ecuația asta pentru că" max. " acum a avut un ușor mai mică șansă să se rostogolească, dar puteți arunca (nedorite) min-1 rezultat.

micnic
Răspuns editat 13 aprilie 2019 в 9:01
Comentarii (29)
 
var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
Comentarii (5)

Matematica.random()

De Mozilla Developer Network documentație:

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

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

Exemple utile:

// 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;
Lior Elrom
Răspuns editat 6 iunie 2018 в 2:16
Comentarii (0)
function getRandomizer(bottom, top) {
    return function() {
        return Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom;
    }
}

utilizare:


var rollDie = getRandomizer( 1, 6 );

var results = ""
for ( var i = 0; i
Comentarii (7)

Întoarce un număr aleator între 1 și 10:

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

Întoarce un număr aleator între 1 și 100:

Math.floor((Math.random()*100) + 1)
nbro
Răspuns editat 26 noiembrie 2015 в 10:13
Comentarii (3)
function randomRange(min, max) {
  return ~~(Math.random() * (max - min + 1)) + min
}

Alternativă dacă utilizați Underscore.js puteți utiliza

_.random(min, max)
Comentarii (3)

Dacă ai nevoie de variabilă între 0 și max se pot utiliza:

Math.floor(Math.random() *  max);
isherwood
Răspuns editat 7 august 2018 в 4:22
Comentarii (2)

Alte răspunsuri don't considerare pentru perfect rezonabil parametri de " 0 " și "1". În schimb, ar trebui să utilizați de "rotund" ** în loc de a ceil sau "podea":

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
Comentarii (1)

Aici este MS DotNet punerea în Aplicare a Aleatoare clasă în 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
Comentarii (1)

Utilizați această funcție pentru a obține numere aleatoare între interval dat

function rnd(min,max){
    return Math.floor(Math.random()*(max-min+1)+min );
}
Aylian Craspa
Răspuns editat 30 mai 2019 в 7:14
Comentarii (0)

După generarea unui număr aleator folosind un program de calculator, se mai considera ca un numar aleator ales dacă numărul este o parte sau un complet de cea inițială. Dar dacă a fost schimbat, atunci matematicieni nu sunt accepta ca un număr aleator și se poate numi un părtinitoare număr. Dar dacă sunteți în curs de dezvoltare un program pentru o sarcină simplă, acest lucru nu va fi un caz să ia în considerare. Dar dacă sunteți în curs de dezvoltare un program pentru a genera un număr aleator pentru lucruri de valoare, cum ar fi loterie program sau joc de noroc, atunci programul va fi respins de management dacă nu ia în considerare cu privire la cazul de mai sus.

Deci, pentru cei ce fel de oameni, aici este sugestia mea:

Genera un număr aleator folosind Matematica.random().(spun astan`)

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.

Dacă știi cum să citească numere aleatoare de masă pentru a alege un număr aleator, știi procesul de mai sus(înmulțirea cu 1, 10, 100 și așa mai departe) nu încalcă una care nu a fost menționat la început.( Pentru că se schimbă doar locul punctului zecimal.)

Studiu următorul exemplu și de a dezvolta-l la nevoile tale.

Dacă ai nevoie de o mostră [0,9], apoi etaj de n10 este răspunsul dumneavoastră și, dacă este nevoie [0,99] atunci etaj al n100 este răspunsul dumneavoastră și așa mai departe.

Acum, să intre în rolul tau:

Te'am cerut numere printre anumit interval. (În acest caz că sunt părtinitoare, printre care variază. - De a lua o serie de [1,6] de rola un zar, atunci ești părtinitoare în [1,6], dar încă este o întâmplare dacă și numai dacă a muri este imparțial.)

Deci, ia în considerare intervalul ==> [78, 247] numărul de elemente din gama = 247 - 78 + 1 = 170; (deoarece ambele limite sunt inclusive.


/*Mthod 1:*/
    var i = 78, j = 247, k = 170, a = [], b = [], c, d, e, f, l = 0;
    for(; i
Comentarii (4)

Pentru un număr întreg aleator, cu o gamă largă, încercați:

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;
}
Comentarii (0)

Stiu ca aceasta intrebare a raspuns deja dar răspunsul meu ar putea ajuta cineva.

Am găsit această metodă simplă de pe W3Schools:

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

Sper că acest lucru ar ajuta pe cineva.

Comentarii (3)

Pentru a obține un număr aleator între 1 și 6, în primul rând face:

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

Aceasta multiplică de un număr aleator de 6 și apoi se adaugă 0,5 la ea. Următoarea rundă de număr la un număr întreg pozitiv de a face:

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

Această rundă număr la cel mai apropiat număr întreg.

Sau pentru a face mai ușor de înțeles a face acest lucru:

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

În general, codul pentru a face acest lucru, folosind variabile este:

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

Motivul pentru a lua distanță de 0,5 din valoarea minimă este pentru că utilizează valoarea minimă singur ar permite să obțineți un număr întreg care a fost unul mai mult decât valoarea maximă. Luându-0.5 din valoarea minimă sunteți în esență prevenirea valoarea maximă de a fi rotunjit.

Sper că vă ajută.

Comentarii (1)

Folosind următorul cod puteți genera matrice de numere aleatoare, fără a repeta, într-un interval dat.

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;
        }
Comentarii (0)
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)));
}

Pentru a testa această funcție, și variații de această funcție, cu excepția de mai jos HTML/JavaScript într-un fișier și deschideți cu browser-ul. Cod va produce o grafic arată distribuția de un milion de apeluri de funcții. Codul va înregistra, de asemenea, cazuri de margine, așa că, dacă funcția de a produce o valoare mai mare decât max, sau mai mică decât min, te.va.știu.despre.acesta.




        <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
Comentarii (0)

Aleatoare număr întreg între cel mai mic și cel mai mare:

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

Nu mai eleganta solutie.. dar ceva rapid.

Comentarii (0)

Aici's ceea ce am folosi pentru a genera numere aleatoare.

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

Facem executa mare++", deoarece " Matematica.random()` generează un număr aleator între 0, (inclusiv) si 1(exclusiv) fiind excluse, înseamnă că trebuie să crească mare de unul înainte de a executa orice matematica. Avem apoi scade scăzut de mare, oferindu-ne cel mai mare număr pentru a genera - low, apoi +low, aducând mare înapoi la normal, și de a face cel mai mic număr de cel puțin scăzută. apoi ne vom întoarce numărul rezultat

aleatorie(7,3) ar putea reveni 3,4,5,6 sau 7

Comentarii (1)

Aici este un exemplu de o funcție javascript care poate genera un număr aleator de orice lungime specificată fără a utiliza Matematica.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
Nilesh Pawar
Răspuns editat 14 iunie 2019 в 10:46
Comentarii (3)



            <meta charset="utf-8" />


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

Uint8Array crea o matrice umplut cu un număr de până la 3 cifre care ar fi un maxim de 999. Acest cod este foarte scurt.

Comentarii (0)