it-swarm.com.de

Zufällige ganze Zahlen in JavaScript in einem bestimmten Bereich generieren?

Wie kann ich zufällige ganze Zahlen zwischen zwei angegebenen Variablen in JavaScript erzeugen, z. x = 4 und y = 8 würden irgendeinen von 4, 5, 6, 7, 8 ausgeben?

1763
zacharyliu

Es gibt einige Beispiele auf der Seite Mozilla Developer Network :

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

Hier ist die Logik dahinter. Es ist eine einfache Dreierregel:

Math.random() gibt ein Number zwischen 0 (inklusive) und 1 (exklusiv) zurück. Wir haben also ein Intervall wie dieses:

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

Nun möchten wir eine Zahl zwischen min (inklusive) und max (exklusiv):

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

Wir können den Math.random verwenden, um den Korrespondenten im Intervall [min, max) zu erhalten. Aber zuerst sollten wir das Problem ein wenig abrechnen, indem wir min vom zweiten Intervall subtrahieren:

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

Das gibt:

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

Wir können jetzt Math.random anwenden und dann den Korrespondenten berechnen. Lass uns eine Zufallszahl auswählen:

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

Um also x zu finden, würden wir Folgendes tun:

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

Vergessen Sie nicht, min zurückzusetzen, damit wir im Intervall [min, max) eine Zahl erhalten:

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

Das war die erste Funktion von MDN. Die zweite gibt eine ganze Zahl zwischen min und max zurück, beide inklusive.

Um ganze Zahlen zu erhalten, können Sie round, ceil oder floor verwenden.

Sie können Math.round(Math.random() * (max - min)) + min verwenden, dies ergibt jedoch eine ungleichmäßige Verteilung. Sowohl min als auch max haben nur ungefähr die Hälfte der Chance zu würfeln:

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

Wenn max aus dem Intervall ausgeschlossen ist, hat es eine noch geringere Chance zu würfeln als min.

Mit Math.floor(Math.random() * (max - min +1)) + min haben Sie eine vollkommen gleichmäßige Verteilung.

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

Sie können ceil() und -1 in dieser Gleichung nicht verwenden, da max jetzt eine etwas geringere Chance hatte, zu würfeln, aber Sie können auch das (unerwünschte) min-1 -Ergebnis würfeln.

3552
Ionuț G. Stan
var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
499
Darin Dimitrov

Math.random ()

Aus der Mozilla Developer Network-Dokumentation:

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

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

Nützliche Beispiele:

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

verwendungszweck:

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

nervenzusammenbruch:

Wir geben eine Funktion zurück (aus der funktionalen Programmierung entlehnt), die beim Aufruf eine zufällige Ganzzahl zwischen den Werten bottom und top einschließlich zurückgibt. Wir sagen 'inclusive', weil wir sowohl bottom als auch top in den Bereich der zurückzugebenden Zahlen aufnehmen möchten. Auf diese Weise gibt getRandomizer( 1, 6 ) entweder 1, 2, 3, 4, 5 oder 6 zurück.

(unten ist die niedrigere Zahl, oben ist die größere Zahl)

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

Math.random() gibt ein zufälliges Double zwischen 0 und 1 zurück, und wenn wir es mit eins plus der Differenz zwischen top und bottom multiplizieren, erhalten wir irgendwo ein Double zwischen 0 und 1+b-a.

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

Math.floor rundet die Zahl auf die nächste Ganzzahl ab. Wir haben also jetzt alle ganzen Zahlen zwischen 0 und top-bottom. Die 1 sieht verwirrend aus, aber sie muss da sein, weil wir immer abrunden, damit die Top-Nummer ohne sie nie erreicht wird. Die zufällige Dezimalzahl, die wir generieren, muss im Bereich von 0 bis (1+top-bottom) liegen, damit wir abrunden und eine Ganzzahl im Bereich von 0 bis top-bottom erhalten können.

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

Der Code im vorherigen Beispiel hat uns eine Ganzzahl im Bereich 0 und top-bottom gegeben. Alles, was wir jetzt tun müssen, ist, bottom zu diesem Ergebnis hinzuzufügen, um eine Ganzzahl im Bereich bottom und top einschließlich zu erhalten. : D


ANMERKUNG: Wenn Sie zuerst einen nicht ganzzahligen Wert oder eine größere Zahl übergeben, tritt unerwünschtes Verhalten auf. Wenn jedoch niemand dies anfordert, werde ich mich nicht mit dem Argumentprüfcode befassen, da dieser eher von der Absicht der ursprünglichen Frage abweicht .

56

Gib eine Zufallszahl zwischen 1 und 10 zurück:

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

Gib eine Zufallszahl zwischen 1 und 100 zurück:

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

Alternativ können Sie nderscore.js verwenden

_.random(min, max)
29
Codler

Wenn Sie eine Variable zwischen 0 und max benötigen, können Sie Folgendes verwenden:

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

Die anderen Antworten berücksichtigen nicht die vollkommen vernünftigen Parameter von 0 und 1. Verwenden Sie stattdessen das roundstattdessen von ceil oder 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
14
Starkers

Nach dem Erzeugen einer Zufallszahl unter Verwendung eines Computerprogramms wird es immer noch als eine Zufallszahl betrachtet, wenn die ausgewählte Zahl ein Teil oder die vollständige Zahl der anfänglichen ist. Aber wenn es geändert wurde, dann Mathematiker akzeptieren es nicht als Zufallszahl und können es als voreingenommene Zahl bezeichnen. Aber wenn Sie ein Programm für eine einfache Aufgabe entwickeln, ist dies kein Fall berücksichtigen. Wenn Sie jedoch ein Programm entwickeln, um eine Zufallszahl für ein wertvolles Material wie ein Lotterieprogramm oder ein Glücksspiel zu generieren, wird Ihr Programm vom Management abgelehnt, wenn Sie den obigen Fall nicht berücksichtigen. =

Für diese Art von Leuten ist hier mein Vorschlag:

Erzeugen Sie eine Zufallszahl mit Math.random(). (Sagen Sie dies 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.

Wenn Sie wissen, wie man eine Zufallszahlentabelle liest, um eine Zufallszahl auszuwählen, wissen Sie, dass der oben beschriebene Vorgang (Multiplizieren mit 1, 10, 100 usw.) nicht gegen den eingangs erwähnten Vorgang verstößt Kommastelle.)

Studieren Sie das folgende Beispiel und entwickeln Sie es nach Ihren Wünschen.

Wenn Sie eine Probe [0,9] benötigen, ist das Stockwerk von n * 10 Ihre Antwort und wenn Sie [0,99] benötigen, ist das Stockwerk von n * 100 Ihre Antwort und so weiter.

Geben Sie nun Ihre Rolle ein:

Sie haben Nummern innerhalb eines bestimmten Bereichs abgefragt. (In diesem Fall sind Sie in diesem Bereich voreingenommen. - Wenn Sie eine Zahl von [1,6] nehmen, indem Sie einen Würfel werfen, sind Sie in [1,6] voreingenommen, aber es ist immer noch ein Zufall, wenn der Würfel unbefangen ist .)

Betrachten Sie also Ihren Bereich ==> [78, 247] Anzahl der Elemente des Bereichs = 247 - 78 + 1 = 170; (da beide Grenzen inklusiv sind.

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

Hinweis: In Methode 1 habe ich zuerst ein Array erstellt, das die benötigten Zahlen enthält, und diese dann zufällig in ein anderes Array eingefügt. Generieren Sie in Methode zwei Zahlen nach dem Zufallsprinzip und überprüfen Sie, ob diese in dem von Ihnen benötigten Bereich liegen. Dann legen Sie es in ein Array. Hier habe ich zwei Zufallszahlen generiert und insgesamt verwendet, um die Geschwindigkeit des Programms zu maximieren, indem die Fehlerrate minimiert wurde, mit der eine nützliche Zahl erhalten wurde. Das Hinzufügen von generierten Zahlen verleiht jedoch auch eine gewisse Unsicherheit. Daher würde ich meine erste Methode empfehlen, um Zufallszahlen innerhalb eines bestimmten Bereichs zu generieren.

Bei beiden Methoden zeigt Ihre Konsole das Ergebnis an. (Drücken Sie in Chrome die Taste f12, um die Konsole zu öffnen.)

11

Hier ist die MS DotNet-Implementierung der Random-Klasse 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;
}());

Verwenden Sie:

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

Versuchen Sie für eine zufällige Ganzzahl mit einem Bereich Folgendes:

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

Verwenden Sie diese Funktion, um Zufallszahlen zwischen den angegebenen Bereichen abzurufen.

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

Um eine Zufallszahl zwischen 1 und 6 zu erhalten, machen Sie zuerst Folgendes:

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

Dies multipliziert eine Zufallszahl mit 6 und addiert dann 0,5 dazu. Runden Sie die Zahl als Nächstes auf eine positive ganze Zahl, indem Sie Folgendes tun:

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

Dies rundet die Zahl auf die nächste ganze Zahl.

Oder um es verständlicher zu machen:

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

Im Allgemeinen lautet der Code für die Verwendung von Variablen:

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

Der Grund für das Entfernen von 0,5 vom Minimalwert ist, dass Sie mit dem Minimalwert allein eine Ganzzahl erhalten, die um eins höher ist als Ihr Maximalwert. Indem Sie 0,5 vom Minimalwert abziehen, verhindern Sie im Wesentlichen, dass der Maximalwert aufgerundet wird.

Hoffe das hilft.

7
Learner.js

Mit dem folgenden Code können Sie eine Reihe von Zufallszahlen in einem bestimmten Bereich generieren, ohne sie zu wiederholen.

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

Ich weiß, dass diese Frage bereits beantwortet wurde, aber meine Antwort könnte jemandem helfen.

Ich habe diese einfache Methode bei W3Schools gefunden:

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

Hoffe das würde jemandem helfen.

7
NutCracker

Zufällige ganze Zahl zwischen niedrigster und höchster:

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

Nicht die eleganteste Lösung ... aber etwas schnelles.

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

Um diese Funktion und Variationen dieser Funktion zu testen, speichern Sie das unten stehende HTML/JavaScript in einer Datei und öffnen Sie es mit einem Browser. Der Code erzeugt ein Diagramm, das die Verteilung von einer Million Funktionsaufrufen zeigt. Der Code zeichnet auch die Edge-Fälle auf. Wenn die Funktion also einen Wert erzeugt, der größer als der Maximalwert oder kleiner als der Minimalwert ist, wissen Sie.über.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>
5
Chris

Hier ist, was ich benutze, um Zufallszahlen zu generieren.

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

Wir führen high++ aus, weil Math.random() eine Zufallszahl zwischen 0 (einschließlich) und 1(exclusive) generiert. Wenn diese Zahl ausgeschlossen wird, müssen wir das High vor der Ausführung um eins erhöhen irgendeine Mathematik. Wir subtrahieren dann niedrig von hoch und geben uns die höchste zu generierende Zahl - niedrig, dann + niedrig, bringen das Hoch wieder auf den Normalwert und machen die niedrigste Zahl zumindest niedrig. dann geben wir die resultierende Zahl zurück

random(7,3) könnte 3,4,5,6, or 7 zurückgeben

5
Travis

Hier ist ein Beispiel für eine JavaScript-Funktion, die eine Zufallszahl mit einer beliebigen Länge generieren kann ohne 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;
    }
4
Nilesh Pawar
    <!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 erstellt ein Array, das mit einer bis zu 3-stelligen Zahl gefüllt ist, was maximal 999 Zeichen entspricht. Dieser Code ist sehr kurz.

4
happy

dies ist meine Einstellung zu einer Zufallszahl in einem Bereich, wie ich eine Zufallszahl in einem Bereich von Basis zu Exponent erhalten wollte. z.B. base = 10, exponent = 2, ergibt im Idealfall eine Zufallszahl von 0 bis 100 und so weiter.

wenn es dabei hilft, ist es hier:

// 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);
3
Goran B.

Sie können Sie diesen Code-Schnipsel,

let randomNumber = function(first,second){
let number = Math.floor(Math.random()*Math.floor(second));
while(number<first){

    number = Math.floor(Math.random()*Math.floor(second));
}
return number;
}
1
Achintha Isuru

Dies kann bis zu 20-stellige EINZIGARTIGE Zufallszahlen erzeugen

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

enter image description here

JsFiddle

0
Nofi

/ * Eine Funktion namens randUpTo schreiben, die eine Zahl akzeptiert und eine zufällige ganze Zahl zwischen 0 und dieser Zahl zurückgibt? * /

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

/ * Schreiben Sie eine Funktion mit dem Namen randBetween, die zwei Zahlen akzeptiert, die einen Bereich darstellen, und eine zufällige ganze Zahl zwischen diesen beiden Zahlen zurückgibt. * /

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

/ * Schreiben Sie eine Funktion mit dem Namen randFromTill, die zwei Zahlen akzeptiert, die einen Bereich darstellen, und eine Zufallszahl zwischen min (einschließlich) und max (ausschließlich) zurückgibt. * /

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

/ * Schreiben Sie eine Funktion mit dem Namen randFromTo, die zwei Zahlen akzeptiert, die einen Bereich darstellen, und eine zufällige Ganzzahl zwischen min (einschließlich) und max (einschließlich) zurückgibt * /

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

Math.random() ist schnell und für viele Zwecke geeignet, aber es ist nicht geeignet, wenn Sie kryptografisch sichere Werte benötigen (es ist nicht sicher) oder wenn Sie Ganzzahlen aus einer vollständig einheitlichen, unverfälschten Verteilung benötigen (der Multiplikationsansatz, der in anderen Antworten verwendet wird, ergibt sich bestimmte Werte etwas häufiger als andere).

In solchen Fällen können wir crypto.getRandomValues() verwenden, um sichere Ganzzahlen zu generieren und generierte Werte abzulehnen, die wir nicht einheitlich in den Zielbereich abbilden können. Dies ist langsamer, sollte aber nur dann von Bedeutung sein, wenn Sie eine extrem große Anzahl von Werten generieren.

Betrachten Sie zur Verdeutlichung des Problems der voreingenommenen Verteilung den Fall, in dem ein Wert zwischen 1 und 5 generiert werden soll, ein Zufallszahlengenerator jedoch Werte zwischen 1 und 16 (ein 4-Bit-Wert). Wir möchten, dass jedem Ausgabewert die gleiche Anzahl von generierten Werten zugeordnet wird, aber 16 wird nicht gleichmäßig durch 5 dividiert: Es verbleibt ein Rest von 1. Wir müssen also 1 der möglichen generierten Werte ablehnen und erst dann fortfahren, wenn wir den Wert erhalten einer der 15 niedrigeren Werte, die einheitlich in unserem Zielbereich abgebildet werden können. Unser Verhalten könnte wie folgt aussehen:

Generate a 4-bit integer in the range 1-16.
If we generated  1,  6, or 11 then output 1.
If we generated  2,  7, or 12 then output 2.
If we generated  3,  8, or 13 then output 3.
If we generated  4,  9, or 14 then output 4.
If we generated  5, 10, or 15 then output 5.
If we generated 16 then reject it and try again.

Der folgende Code verwendet eine ähnliche Logik, generiert jedoch stattdessen eine 32-Bit-Ganzzahl, da dies die größte gemeinsame Ganzzahlgröße ist, die vom JavaScript-Standardtyp number dargestellt werden kann. (Dies kann geändert werden, um BigInts zu verwenden, wenn Sie einen größeren Bereich benötigen.) Unabhängig vom ausgewählten Bereich liegt der Anteil der zurückgewiesenen generierten Werte immer unter 0,5, sodass die erwartete Anzahl von Zurückweisungen immer gleich ist weniger als 1,0 und normalerweise nahe 0,0; Sie brauchen sich keine Sorgen zu machen, dass es für immer eine Schleife gibt.

const randomInteger = (min, max) => {
  const range = max - min;
  const maxGeneratedValue = 0xFFFFFFFF;
  const possibleResultValues = range + 1;
  const possibleGeneratedValues = maxGeneratedValue + 1;
  const remainder = possibleGeneratedValues % possibleResultValues;
  const maxUnbiased = maxGeneratedValue - remainder;

  if (!Number.isInteger(min) || !Number.isInteger(max) ||
       max > Number.MAX_SAFE_INTEGER || min < Number.MIN_SAFE_INTEGER) {
    throw new Error('Arguments must be safe integers.');
  } else if (range > maxGeneratedValue) {
    throw new Error(`Range of ${range} (from ${min} to ${max}) > ${maxGeneratedValue}.`);
  } else if (max < 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))[0];
  } while (generated > maxUnbiased);

  return min + (generated % possibleResultValues);
};

console.log(randomInteger(-8, 8));          // -2
console.log(randomInteger(0, 0));           // 0
console.log(randomInteger(0, 0xFFFFFFFF));  // 944450079
console.log(randomInteger(-1, 0xFFFFFFFF));
// Error: Range of 4294967296 covering -1 to 4294967295 is > 4294967295.
console.log(new Array(12).fill().map(n => randomInteger(8, 12)));
// [11, 8, 8, 11, 10, 8, 8, 12, 12, 12, 9, 9]
0
Jeremy Banks

Ich habe diese Funktion erstellt, die Optionen wie "min", "max", "exclude" (eine Liste von auszuschließenden Ints) und "seed" (falls Sie einen gesetzten Zufallsgenerator wünschen) berücksichtigt.

get_random_int = function(args={})
{
    let def_args =
    {
        min: 0,
        max: 1,
        exclude: false,
        seed: Math.random
    }

    args = Object.assign(def_args, args)

    let num = Math.floor(args.seed() * (args.max - args.min + 1) + args.min)

    if(args.exclude)
    {
        let diff = args.max - args.min
        let n = num

        for(let i=0; i<diff*2; i++)
        {
            if(args.exclude.includes(n))
            {
                if(n + 1 <= args.max)
                {
                    n += 1
                }

                else
                {
                    n = args.min
                }
            }

            else
            {
                num = n
                break
            }
        }
    }

    return num
}

Es kann verwendet werden wie:

let n = get_random_int
(
    {
        min: 0,
        max: some_list.length - 1,
        exclude: [3, 6, 5],
        seed: my_seed_function
    }
)

Oder einfacher:

let n = get_random_int
(
    {
        min: 0,
        max: some_list.length - 1
    }
)

Dann können Sie tun:

let item = some_list[n]

Inhalt: https://Gist.github.com/madprops/757deb000bdec25776d5036dae58ee6e

0
madprops