Există mai multe exemple:

/** * Returnează un număr aleatoriu între min (inclusiv) și max (exclusiv) */ function getRandomArbitrary(min, max) ( return Math.random() * (max - min) + min; ) /** * Returnează un întreg aleatoriu între min (inclusiv) și max (inclusiv).

* Valoarea nu este mai mică decât min (sau următorul întreg mai mare decât min * dacă min nu este un întreg) și nu este mai mare decât max (sau următorul întreg * mai mic decât max dacă max nu este un întreg).

* Utilizarea Math.round() vă va oferi o distribuție neuniformă!

*/ funcția getRandomInt(min, max) ( min = Math.ceil(min); max = Math.floor(max); return Math.floor(Math.random() * (max - min + 1)) + min; )< 0) { num3 += 2147483647; } num2 = this.SeedArray; } for (var j = 1; j < 5; j++) { for (var k = 1; k < 56; k++) { this.SeedArray[k] -= this.SeedArray; 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 >Iată logica din spatele ei. Este o regulă simplă de trei:< 0) { num3 += 2147483647; } this.SeedArray = 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 количество элементов диапазона = 247 - 78 + 1 = 170; (так как обе границы включены.

Math.random() returnează un număr între 0 (inclusiv) și 1 (exclusiv). Deci avem acest interval:

Num3;

num3 = num2 - num3;< 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 >dacă (num3

= 56) ( num = 1; ) if (++num2 >= 56) ( num2 = 1; ) var num3 = this.SeedArray - this.SeedArray;

dacă (num3 == 2147483647) ( num3--; ) dacă (num3

Acest lucru înmulțește numărul aleatoriu cu 6 și apoi îi adaugă 0,5. Apoi rotunjește numărul la un întreg pozitiv, făcând:

Math.round(0,5 + (Math.random() * ((6 - 1) + 1))

Aceasta rotunjește numărul la cel mai apropiat număr întreg.

Sau pentru a fi mai clar, procedați astfel:

Valoare var = 0,5 + (Math.random() * ((6 - 1) + 1)) var rol = Math.round(valoare);

rola de retur;

În general, codul pentru aceasta folosind variabile este:

Valoare var = (Min - 0,5) + (Math.random() * ((Max - Min) + 1)) var rol = Math.round(valoare);

rola de retur;

Motivul pentru a scădea 0,5 din valoarea minimă este că utilizarea numai a valorii minime vă va permite să ajungeți cu un număr întreg care ar fi mai mare decât valoarea maximă. Prin eliminarea 0,5 din valoarea minimă, în esență împiedicați rotunjirea valorii maxime.

Sper că acest lucru ajută.

Număr întreg aleatoriu între cel mai mic și cel mai mare:

Funcția randomRange(l,h)( var range = (h-l); var random = Math.floor(Math.random()*range); if (random === 0)(random+=1;) return l+random; )

Nu cea mai elegantă soluție.. dar ceva rapid.

Funcția getRandomInt(lower, upper) ( //pentru a crea o distribuție uniformă a eșantionului returnează Math.floor(lower + (Math.random() * (sus - jos + 1))); //pentru a produce o distribuție neuniformă a eșantionului // return Math.round(lower + (Math.random() * (sus - jos)) //pentru a exclude valoarea maximă din valorile posibile ​​//return Math.floor(lower + (Math.random())); * (sus - jos)));< Number.MIN_SAFE_INTEGER) { throw new Error("Arguments must be safe integers."); } else if (range >Pentru a testa această caracteristică și variante ale acestei caracteristici, salvați HTML/JavaScript de mai jos într-un fișier și deschideți-l într-un browser. Codul va afișa un grafic care arată distribuția unui milion de apeluri de funcție. Codul va înregistra și cazuri de margine, așa că dacă funcția produce o valoare mai mare decât max sau mai mică decât min, veți.ști.despre.< 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)); ) while (generated > maxUnbiased) ); return min + (generat % posibilResultValues) (randomInteger(-8, 8)); 944450079 console.log(randomInteger(-1, 0xFFFFFFFF)); // Eroare: intervalul de la 4294967296 care acoperă -1 până la 4294967295 este > 4294967295. console.log(new Array(12). fill().dommapteger(n). (8, 12)));

Metoda Math.random() returnează un număr pseudo-aleatoriu între 0 și 1.

Numărul pseudo-aleatoriu este creat în intervalul de la 0 (inclusiv) la 1 (exclusiv), adică numărul returnat poate fi zero, dar va fi întotdeauna mai mic de unu.

Pentru a rotunji un număr cu virgulă mobilă la un număr întreg, puteți utiliza, de exemplu, metoda Math.floor().

• Un număr în virgulă mobilă care variază de la 0 (inclusiv) la 1 (exclusiv).

Metoda Math.random() este folosită în principal pentru a genera un număr pseudo-aleatoriu într-un anumit interval. De exemplu, trebuie să obținem un număr în intervalul de la 50 la 100 (inclusiv). Pentru a face acest lucru va trebui să scriem următorul cod:

Document.write(Math.floor(Math.random() * 51 + 50));

Să aruncăm o privire mai atentă la modul în care funcționează exemplul nostru și de ce este utilizată această formă de înregistrare. În primul rând, trebuie să indicăm valoarea minimă obținută din intervalul dorit, în exemplul nostru acesta este numărul 50. Acum trebuie să obținem cumva un număr aleatoriu, care, atunci când este adăugat cu numărul 50, nu va depăși totalul numărul 100. După cum știm din matematică, găsirea termenului necunoscut se face prin scăderea termenului cunoscut din sumă. 100 - 50: obținem diferența 50. Acum, pentru a verifica dacă acest număr ni se potrivește sau nu, îl înmulțim cu numărul minim și maxim posibil returnat de metoda Math.random(). Înmulțim minimul 0.004704564176082244 * 50 = 0.2... și maximul 0.999999999746223 * 50 = 49.9... Și așa vedem că atunci când înmulțim diferența cu numărul maxim posibil posibil, rezultatul ne dă o parte a numărului într-un număr. mai puțin decât este necesar. Pentru a corecta situația, trebuie doar să adăugăm o unitate la 50, adică. 50 + 1 = 51, acum dacă numărul rezultat este înmulțit cu numărul maxim posibil returnat de metodă, vom obține numărul 50,9... - asta ne trebuie, după ce adunăm numerele 50,9 + 50, obținem 100,9 . Pentru a rotunji un număr la un întreg, utilizați metoda Math.floor(). Astfel, formula pentru obținerea numărului necesar este următoarea: max - min + 1. Să rescriem exemplul de mai sus:

Var max = 100, min = 50; document.write(Math.floor(Math.random() * (max - min + 1) + min));

Această formulă este utilă în special atunci când nu se știe în prealabil în ce interval trebuie obținut numărul aleator.

Număr pseudo-aleatoriu în intervalul de la 1 la 10.

pentru(var i = 0; i
1 2 3 4 5 6 7 8 9 0
a fost obținut prin tastarea liniei de sus a tastaturii în ordine, astfel încât secvența nu poate fi considerată generată aleatoriu. Dar ce se întâmplă dacă obții aceeași secvență când scoți mingile de tenis numerotate din butoi. În acest caz, este deja o secvență generată aleatoriu. Acest exemplu arată că aleatoritatea unei secvențe depinde de modul în care a fost obținută și nu de secvența în sine.

Amintiți-vă că o secvență de numere generată de computer este deterministă: fiecare număr, cu excepția primului, depinde de numerele dinainte. Din punct de vedere tehnic, aceasta înseamnă că numai o secvență cvasialeatorie de numere poate fi generată de un computer, adică. de fapt nu sunt cu adevărat aleatorii. Cu toate acestea, acest lucru este suficient pentru majoritatea sarcinilor și, pentru simplitate, astfel de secvențe vor fi numite aleatoare. O metodă foarte interesantă a fost dezvoltată de John von Neumann; este adesea numit rădăcină pătrată medie. În această metodă, numărul aleatoriu anterior este pătrat, iar apoi cifrele din mijloc sunt extrase din rezultat. De exemplu, dacă creați numere cu trei cifre, iar numărul anterior a fost 121, atunci la pătrat dă rezultatul 14641. Izolarea celor trei cifre din mijloc dă următorul număr aleatoriu 464. Dezavantajul acestei metode este că are un perioadă scurtă de repetiție, numită ciclu. Din acest motiv, această metodă nu este folosită astăzi. Metodele moderne de generare a numerelor aleatoare sunt mult mai complexe.

PHP are două grupuri de funcții pentru a lucra cu numere aleatorii. Pur extern, ele pot fi distinse prin prefixul mt_ pentru toate funcțiile unuia dintre grupuri.

Caracteristici depreciate
funcția rand. Returnează un număr întreg între zero și valoarea lui RAND_MAX (care este 32767). Poate avea doi parametri întregi opționali - dacă sunt specificați, se generează un număr aleator de la primul parametru la al doilea.

Echo rand(); echo rand(1.100); // Dați un număr aleatoriu de la 1 la 100

Funcția srand. Specifică succesiunea de numere aleatoare produse de funcția rand. Are un parametru întreg - pentru diferite valori ale acestui parametru, rand va produce diferite secvențe de numere. Funcția srand trebuie apelată o singură dată înainte de toate apelurile la funcția rand. Exemplu de utilizare:

Srand(1288); // Inițializați generatorul de numere aleatoare pentru ($i=0; $i