Generazione di numeri interi casuali in JavaScript in un intervallo specifico?

Come posso generare un numero intero casuale tra due variabili specificate in Javascript, ad es. x = 4 y = 8 produrrebbe uno qualsiasi di 4, 5, 6, 7, 8?

Ci sono alcuni esempi sulla pagina della rete di sviluppatori 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; } 

Ecco la logica dietro. È una semplice regola di tre:

Math.random() restituisce un Number compreso tra 0 (incluso) e 1 (esclusivo). Quindi abbiamo un intervallo come questo:

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

Ora vorremmo un numero compreso tra min (inclusi) e max (esclusivi):

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

Possiamo usare Math.random per ottenere il corrispondente nell’intervallo [min, max]. Ma, per prima cosa dovremmo considerare un po ‘il problema sottraendo il min dal secondo intervallo:

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

Questo da:

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

Ora possiamo applicare Math.random e quindi calcolare il corrispondente. Scegliamo un numero casuale:

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

Quindi, per trovare x , faremmo:

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

Non dimenticare di aggiungere il valore min indietro, in modo da ottenere un numero nell’intervallo [min, max]:

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

Quella fu la prima funzione di MDN. Il secondo, restituisce un intero tra min e max , entrambi inclusi.

Ora per ottenere numeri interi, puoi usare round , ceil o floor .

È ansible utilizzare Math.round(Math.random() * (max - min)) + min , tuttavia ciò fornisce una distribuzione non uniforms. Entrambi, min e max hanno solo circa la metà delle possibilità di rollare:

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

Con il max escluso dall’intervallo, ha ancora meno possibilità di rotolare di min .

Con Math.floor(Math.random() * (max - min +1)) + min hai una distribuzione perfettamente uniforms.

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

Non puoi usare ceil() e -1 in questa equazione perché il max ora ha un po ‘meno possibilità di rotolare, ma puoi anche tirare il risultato min-1 (indesiderato).

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

Math.random ()

Dalla documentazione della Mozilla Developer Network:

 // Returns a random integer between min (include) and max (include) Math.floor(Math.random() * (max - min + 1)) + min; 

Esempi utili:

 // 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; 
 function getRandomizer(bottom, top) { return function() { return Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom; } } 

utilizzo:

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

abbattersi:

Stiamo restituendo una funzione (presa in prestito dalla programmazione funzionale) che, quando chiamata, restituirà un intero casuale tra i valori bottom e top , inclusive. Diciamo "inclusivo" perché vogliamo includere sia il minimo che il massimo nell'intervallo di numeri che è ansible restituire. In questo modo, getRandomizer( 1, 6 ) restituirà 1, 2, 3, 4, 5 o 6.

(in basso è il numero più basso, in alto c'è il numero maggiore)

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

Math.random() restituisce un doppio casuale compreso tra 0 e 1, e se lo moltiplichiamo per uno più la differenza tra l' top e il bottom , otterremo un doppio compreso tra 0 e 1+ba .

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

Math.floor arrotonda il numero al numero intero più vicino. Quindi ora abbiamo tutti gli interi tra 0 e top-bottom . L'1 sembra confuso, ma deve esserci perché stiamo sempre andando in tondo, quindi il numero più alto non sarà mai raggiunto senza di esso. Il decimale casuale che generiamo deve essere compreso tra 0 e (1+top-bottom) quindi possiamo arrotondare e ottenere un int nell'intervallo 0 in top-bottom

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

Il codice nell'esempio precedente ci ha fornito un numero intero compreso nell'intervallo 0 e top-bottom , quindi tutto ciò che dobbiamo fare ora è aggiungere in bottom a tale risultato per ottenere un numero intero nell'intervallo bottom e top inclusi. : D


NOTA: se si passa un valore non intero o il numero maggiore per primo si ottiene un comportamento indesiderato, ma a meno che qualcuno lo richieda non ho intenzione di approfondire il codice di controllo degli argomenti come piuttosto lontano dall'intento della domanda originale .

Restituisce un numero casuale compreso tra 1 e 10:

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

Restituisce un numero casuale compreso tra 1 e 100:

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

Alternativa se si utilizza Underscore.js che è ansible utilizzare

 _.random(min, max) 

Le altre risposte non tengono conto dei parametri perfettamente ragionevoli di 0 e 1 . Invece dovresti usare il round posto di 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 

Dopo aver generato un numero casuale usando un programma per computer, viene comunque considerato come un numero casuale se il numero selezionato è una parte o il numero intero di quello iniziale. Ma se è stato cambiato, allora i matematici non lo accettano come un numero casuale e possono chiamarlo un numero parziale. Ma se stai sviluppando un programma per un compito semplice, non sarà un caso da considerare. Ma se stai sviluppando un programma per generare un numero casuale per un materiale di valore come il programma della lotteria o il gioco d’azzardo, il tuo programma verrà rifiutato dalla direzione se non ti occuperai del caso precedente.

Quindi per quel tipo di persone, ecco il mio suggerimento:

Genera un numero casuale usando Math.random() . (Dì questo n )

 Now for [0,10) ==> n*10 (ie one digit) and for[10,100) ==> n*100 (ie 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. (ie get floor) - using Math.floor(), this can be done. 

Se sai come leggere la tabella dei numeri casuali per scegliere un numero casuale, sai che il processo precedente (moltiplicato per 1, 10, 100 e così via) non viola quello che ho menzionato all’inizio (perché cambia solo il luogo del punto decimale.)

Studia il seguente esempio e sviluppalo secondo i tuoi bisogni.

Se hai bisogno di un campione [0,9], il piano di n * 10 è la tua risposta e, se necessario [0,99], il piano di n * 100 è la tua risposta e così via.

Ora lascia entrare nel tuo ruolo:

Hai chiesto i numeri nell’intervallo specifico. (In questo caso sei sbilanciato in quell’intervallo. – Prendendo un numero da [1,6] tirando un dado, sei sbilanciato in [1,6] ma è ancora casuale se e solo se il dado è imparziale .)

Quindi considera il tuo intervallo ==> [78, 247] numero di elementi dell’intervallo = 247 – 78 + 1 = 170; (poiché entrambi i limiti sono comprensivi.

 /*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: nel metodo uno, per prima cosa ho creato un array che contiene i numeri necessari e quindi li inserisce in modo casuale in un altro array. Nel metodo due, genera numeri casualmente e controlla quelli che si trovano nell’intervallo di cui hai bisogno. Quindi mettilo in un array. Qui ho generato due numeri casuali e ne ho utilizzato il totale per massimizzare la velocità del programma riducendo al minimo il tasso di errore che ha ottenuto un numero utile. Tuttavia l’aggiunta di numeri generati darà anche qualche biassness. Quindi consiglierei il mio primo metodo per generare numeri casuali all’interno di un intervallo specifico.

In entrambi i metodi, la tua console mostrerà il risultato. (Premi f12 in Chrome per aprire la console)

Per un numero intero casuale con un intervallo, prova:

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

Ecco l’implementazione MS DotNet della class Random in 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; }()); 

Uso:

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

Per fare in modo che un numero casuale dica tra 1 e 6, prima fai:

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

Questo moltiplica un numero casuale per 6 e poi ne aggiunge 0.5. Quindi arrotondare il numero a un intero positivo eseguendo:

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

Questo arrotonda il numero al numero intero più vicino.

O per renderlo più comprensibile fai questo:

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

In generale il codice per fare questo usando le variabili è:

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

La ragione per rimuovere 0,5 dal valore minimo è perché l’utilizzo del solo valore minimo consentirebbe di ottenere un numero intero superiore al valore massimo. Togliendo 0,5 dal valore minimo, stai essenzialmente impedendo che venga arrotondato il valore massimo.

Spero possa aiutare.

Usando il seguente codice è ansible generare una serie di numeri casuali, senza ripetere, in un determinato intervallo.

 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. ie 4 // max(inclusive) : maximun value of a range. it must be any positive integer. ie 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; } 

Se hai bisogno di una variabile tra 0 e max puoi usare:

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

Numero intero casuale tra il più basso e il più alto:

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

Non la soluzione più elegante … ma qualcosa di veloce.

So che questa domanda ha già una risposta, ma la mia risposta potrebbe aiutare qualcuno.

Ho trovato questo semplice metodo su W3Schools:

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

Spero che questo possa aiutare qualcuno.

Ecco cosa uso per generare numeri casuali.

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

Eseguiamo high++ perché Math.random() genera un numero casuale compreso tra 0, (incluso) e 1 (esclusivo). L’essere escluso significa che dobbiamo aumentare il massimo di uno prima di eseguire qualsiasi calcolo matematico. Sottraiamo quindi il valore da basso ad alto, dandoci il numero più alto da generare – basso, poi + basso, riportando il loto in alto alla normalità e rendendo il numero più basso al minimo. quindi restituiamo il numero risultante

random(7,3) potrebbe restituire 3,4,5,6, or 7

           

Uint8Array crea un array riempito con un numero fino a 3 cifre che può essere un massimo di 999. Questo codice è molto breve.

questa è la mia opinione su un numero casuale in un intervallo, in quanto volevo ottenere un numero casuale all’interno di un intervallo di base da esponente. es. base = 10, esponente = 2, dà un numero casuale da 0 a 100, idealmente, e così via.

se aiuta a usarlo, eccolo qui:

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

Hey Ragazzi, ho creato una funzione javascript identica a Math.random (), utilizzando la quale possiamo generare un numero casuale di qualsiasi lunghezza specificata . Senza utilizzare alcuna funzione Math.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 <= max; i++) { //Empty Loop } const t2 = new Date().getMilliseconds(); console.log(t2); result = ((max - min)*t1)/t2; console.log(result); return result; } 
 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))); } 

Per testare questa funzione e le variazioni di questa funzione, salvare il seguente HTML / JavaScript in un file e aprirlo con un browser. Il codice produrrà un grafico che mostra la distribuzione di un milione di chiamate di funzione. Il codice registrerà anche i casi limite, quindi se la funzione produce un valore superiore al massimo, o inferiore al minimo, you.will.know.about.it.

        
 function rnd(min,max){ return Math.floor(Math.random()*(max-min+1)+min ); } 

Questo può gestire la generazione di un numero casuale UNICO di 20 cifre

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

inserisci la descrizione dell'immagine qui

JsFiddle

/ * Scrivi una funzione chiamata randUpTo che accetta un numero e restituisce un numero intero casuale compreso tra 0 e quel numero? * /

 var randUpTo = function(num) { return Math.floor(Math.random() * (num - 1) + 0); }; 

/ * Scrivi una funzione chiamata randBetween che accetta due numeri che rappresentano un intervallo e restituisce un numero intero casuale tra questi due numeri. * /

 var randBetween = function (min, max) { return Math.floor(Math.random() * (max - min - 1)) + min; }; 

/ * Scrivi una funzione chiamata randFromTill che accetta due numeri che rappresentano un intervallo e restituisce un numero casuale compreso tra min (compreso) e max (esclusivo). * /

 var randFromTill = function (min, max) { return Math.random() * (max - min) + min; }; 

/ * Scrivi una funzione chiamata randFromTo che accetta due numeri che rappresentano un intervallo e restituisce un numero intero casuale compreso tra min (inclusi) e max (inclusi) * /

 var randFromTo = function (min, max) { return Math.floor(Math.random() * (max - min + 1)) + min; }; 

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

Mi sono chiesto come sarebbe stata la distribuzione dopo un numero sufficiente di esecuzioni per tale funzione di randomizzazione.

E anche per verificare se quella distribuzione sarebbe più o meno la stessa nei vari browser.

Quindi ecco un frammento per correre. I numeri possono essere cambiati prima di premere il pulsante.

 function getRandomNumberInRange(Min, Max) { return Math.floor(Math.random() * (Max - Min + 1)) + Min; } function printDictAsTable(dict){ let htmlstr = ""; let sortedKeys = Object.keys(dict).sort(function(a,b){return ab}); for (let i=0; i"; } htmlstr += "
NumberCount
" + dict[key] + "
"; 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();
 

Min :

Max :

Loops: