Frage Generieren von zufälligen ganzen Zahlen in JavaScript in einem bestimmten Bereich?


Wie kann ich eine zufällige ganze Zahl zwischen zwei angegebenen Variablen in Javascript, z. x = 4 und y = 8 würde 4, 5, 6, 7, 8 ausgeben?


1484
2017-10-06 20:05


Ursprung


Antworten:


Es gibt einige Beispiele auf der Mozilla-Entwickler-Netzwerk Seite:

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

Hier ist die Logik dahinter. Es ist eine einfache Regel von drei:

Math.random() gibt a zurück Number zwischen 0 (inklusive) und 1 (exklusiv). Also haben wir ein Intervall wie folgt:

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

Jetzt möchten wir eine Nummer zwischen min (inklusive) und max (exklusiv):

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

Wir können das benutzen Math.random um den Korrespondenten im [min, max] Intervall zu bekommen. Aber zuerst sollten wir das Problem ein wenig abzählen, indem wir subtrahieren min ab dem zweiten Intervall:

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

Das gibt:

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

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

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

Also, um zu finden x, wir würden machen:

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

Vergiss nicht hinzuzufügen min zurück, so dass wir eine Zahl im [min, max] Intervall bekommen:

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

Das war die erste Funktion von MDN. Der zweite gibt eine Ganzzahl zwischen min und max, beide inklusive.

Jetzt können Sie ganze Zahlen verwenden round, ceil oder floor.

Du könntest benutzen Math.round(Math.random() * (max - min)) + minDies ergibt jedoch eine nicht gleichmäßige Verteilung. Beide, min und max haben nur ungefähr die Hälfte der Chance zu rollen:

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

Mit max ausgeschlossen vom Intervall hat es eine noch geringere Chance zu rollen als min.

Mit Math.floor(Math.random() * (max - min +1)) + min Sie haben eine perfekt 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 nicht verwenden ceil() und -1 in dieser Gleichung weil max hatte jetzt eine etwas geringere Chance zu rollen, aber du kannst das (unerwünschte) rollen min-1 Ergebnis auch.


3050
2017-10-06 20:08



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

463
2017-10-06 20:09



Math.random ()

Von dem Mozilla Dokumentation zum Entwickler-Netzwerk:

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

72
2018-03-25 01:58



function getRandomizer(bottom, top) {
    return function() {
        return Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom;
    }
}

Verwendung:

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 (die aus funktionaler Programmierung entlehnt wird), die beim Aufruf eine zufällige ganze Zahl zwischen den Werten zurückgibt bottom und topinklusive. Wir sagen 'inklusiv', weil wir sowohl den unteren als auch den oberen Bereich in den Zahlenbereich einschließen wollen, der zurückgegeben werden kann. Diesen Weg, getRandomizer( 1, 6 ) gibt entweder 1, 2, 3, 4, 5 oder 6 zurück.

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

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

Math.random() gibt ein zufälliges Doppel zwischen 0 und 1 zurück, und wenn wir es mit eins plus dem Unterschied zwischen multiplizieren top und bottomWir werden irgendwo ein Double bekommen 0 und 1+b-a.

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

Math.floor Rundet die Zahl auf die nächste ganze Zahl ab. Also haben wir jetzt alle ganzen Zahlen dazwischen 0 und top-bottom. Die 1 sieht verwirrend aus, aber sie muss da sein, weil wir immer abgerundet werden, so dass die obere Zahl niemals ohne sie erreicht wird. Die zufällige Dezimalzahl, die wir erzeugen, muss in dem Bereich liegen 0 zu (1+top-bottom) so können wir abrunden und einen int im bereich bekommen 0 zu top-bottom

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

Der Code im vorherigen Beispiel gab uns eine Ganzzahl im Bereich 0 und top-bottom, also müssen wir nur noch hinzufügen bottom zu diesem Ergebnis, um eine Ganzzahl im Bereich zu erhalten bottom und top inklusive. : D


HINWEIS: Wenn Sie zuerst einen nicht ganzzahligen Wert oder die größere Zahl übergeben, erhalten Sie ein unerwünschtes Verhalten, aber wenn nicht jemand es anfordert, werde ich nicht in den Code zur Überprüfung des Arguments einsteigen, da es ziemlich weit von der ursprünglichen Frage entfernt ist .


48
2017-10-06 20:08



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)

27
2018-03-28 11:31



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

Alternative, wenn Sie verwenden Underscore.js Sie können verwenden

_.random(min, max)

26
2018-02-09 19:51



Die anderen Antworten berücksichtigen nicht die vollkommen vernünftigen Parameter von 0 und 1. Stattdessen sollten Sie die verwenden round  stattdessen 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

12
2017-07-21 16:42



Nach dem Generieren einer Zufallszahl unter Verwendung eines Computerprogramms wird es immer noch als eine Zufallszahl betrachtet, wenn die ausgewählte Zahl ein Teil oder der vollständige Teil des ursprünglichen ist. Aber wenn es geändert wurde, dann Mathematiker akzeptieren es nicht als Zufallszahl und sie können es eine voreingenommene Zahl nennen. Aber wenn Sie ein Programm für eine einfache Aufgabe entwickeln, wird dies kein Einzelfall sein. Aber wenn Sie ein Programm entwickeln, um eine Zufallszahl für ein wertvolles Zeug wie Lotterie-Programm oder Glücksspiel zu generieren, dann wird Ihr Programm vom Management abgelehnt, wenn Sie über den obigen Fall nicht nachdenken.

Also für diese Art von Menschen, hier ist mein Vorschlag:

Generieren Sie eine Zufallszahl mit Math.random().(Sag das 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 Zufallszahlen - Tabelle liest, um eine Zufallszahl auszuwählen, wissen Sie, dass der obige Prozess (Multiplikation mit 1, 10, 100 usw.) nicht gegen den, den ich am Anfang erwähnt habe, steht Stelle des Dezimalpunktes.)

Studieren Sie das folgende Beispiel und entwickeln Sie es nach Ihren Bedürfnissen.

Wenn Sie eine Probe [0,9] benötigen, dann ist floor of n * 10 Ihre Antwort und wenn nötig [0,99] dann ist floor of n * 100 Ihre Antwort und so weiter.

Nun lass dich in deine Rolle ein:

Sie haben Zahlen in bestimmten Bereichen eingegeben. (In diesem Fall sind Sie in diesem Bereich voreingenommen. - Indem Sie eine Zahl von [1,6] mit würfeln nehmen, dann sind Sie in [1,6] voreingenommen, aber immer noch ist es ein Zufall, wenn und nur wenn der unparteiisch ist .)

Betrachte also deine Reichweite ==> [78, 247] Anzahl der Elemente des Bereichs = 247 - 78 + 1 = 170; (Da beide Grenzen inklusive 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 der ersten Methode habe ich zuerst ein Array erstellt, das die benötigten Zahlen enthält, und sie dann zufällig in ein anderes Array eingefügt. In Methode zwei, generieren Sie Zahlen nach dem Zufallsprinzip und überprüfen Sie, ob diese in dem Bereich sind, den Sie benötigen. Dann lege es in ein Array. Hier generierte ich zwei Zufallszahlen und nutzte die Summe von ihnen, um die Geschwindigkeit des Programms zu maximieren, indem die Fehlerrate minimiert wurde, die eine nützliche Zahl erhält. Das Hinzufügen von generierten Zahlen wird jedoch auch zu einer gewissen Voreingenommenheit führen. Also würde ich meine erste Methode empfehlen, Zufallszahlen innerhalb eines bestimmten Bereichs zu generieren.

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


9
2018-02-10 13:22



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

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

8
2017-10-25 22:15



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

Benutzen:

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

8
2017-11-15 05:38