it-swarm-eu.dev

Erzeugen Sie eindeutige Zufallszahlen zwischen 1 und 100

Wie kann ich mit JavaScript 8 eindeutige Zufallszahlen zwischen 1 und 100 generieren?

72
dotty

var arr = []
while(arr.length < 8){
    var r = Math.floor(Math.random()*100) + 1;
    if(arr.indexOf(r) === -1) arr.Push(r);
}
document.write(arr);

119
adam0101
  1. Füllen Sie ein Array mit den Zahlen 1 bis 100.
  2. Mischen Sie es .
  3. Nehmen Sie die ersten 8 Elemente des resultierenden Arrays.
34
ЯegDwight

Generieren Sie permutation mit 100 Zahlen und wählen Sie dann seriell.

Verwenden Sie den Knuth-Shuffle-Algorithmus [alias der Fisher-Yates-Shuffle] .

JavaScript:

  function fisherYates ( myArray,stop_count ) {
  var i = myArray.length;
  if ( i == 0 ) return false;
  int c = 0;
  while ( --i ) {
     var j = Math.floor( Math.random() * ( i + 1 ) );
     var tempi = myArray[i];
     var tempj = myArray[j];
     myArray[i] = tempj;
     myArray[j] = tempi;

     // Edited thanks to Frerich Raabe
     c++;
     if(c == stop_count)return;

   }
}

CODE AUS LINK KOPIERT.

EDIT:

Verbesserter Code:

function fisherYates(myArray,nb_picks)
{
    for (i = myArray.length-1; i > 1  ; i--)
    {
        var r = Math.floor(Math.random()*i);
        var t = myArray[i];
        myArray[i] = myArray[r];
        myArray[r] = t;
    }

    return myArray.slice(0,nb_picks);
}

Potenzielles Problem:

Angenommen, wir haben ein Feld von 100 Zahlen {z. [1,2,3 ... 100]} und wir hören auf, nach 8 Swaps zu tauschen; ..Nummern hier werden gemischt ... 10}.

Weil jede Zahl mit der Wahrscheinlichkeit 1/100 getauscht wird, so Prob. die ersten 8 Zahlen zu tauschen ist 8/100, wohingegen prob. von anderen 92 zu tauschen ist 92/100.

Wenn wir jedoch den Algorithmus für das vollständige Array ausführen, sind wir (fast) sicher, dass jeder Eintrag ausgetauscht wird.

Ansonsten stehen wir vor der Frage, welche 8 Zahlen Sie wählen sollen.

13
Pratik Deoghare

Die oben genannten Techniken sind gut, wenn Sie eine Bibliothek vermeiden möchten. Abhängig davon, ob Sie mit einer Bibliothek in Ordnung wären, würde ich empfehlen, Chance zu suchen, um zufälliges Material in JavaScript zu generieren.

Um Ihre Frage zu lösen, ist die Verwendung von Chance so einfach wie folgt:

// One line!
var uniques = chance.unique(chance.natural, 8, {min: 1, max: 100});

// Print it out to the document for this snippet so we can see it in action
document.write(JSON.stringify(uniques));
<script src="http://chancejs.com/chance.min.js"></script>

Disclaimer, als Autor von Chance bin ich ein bisschen voreingenommen;)

10
Victor Quinn

Um langes und unzuverlässiges Shuffles zu vermeiden, würde ich Folgendes tun ...

  1. Generieren Sie nacheinander ein Array, das die Nummer zwischen 1 und 100 enthält.
  2. Erzeugen Sie eine Zufallszahl zwischen 1 und 100
  3. Suchen Sie die Nummer an diesem Index im Array und speichern Sie sie in Ihren Ergebnissen
  4. Entfernen Sie das Element aus dem Array, um es kürzer zu machen
  5. Wiederholen Sie den Vorgang ab Schritt 2, verwenden Sie jedoch 99 als obere Grenze der Zufallszahl
  6. Wiederholen Sie den Vorgang ab Schritt 2, verwenden Sie jedoch 98 als obere Grenze der Zufallszahl
  7. Wiederholen Sie den Vorgang ab Schritt 2, verwenden Sie jedoch 97 als obere Grenze der Zufallszahl
  8. Wiederholen Sie den Vorgang ab Schritt 2, verwenden Sie jedoch 96 als obere Grenze der Zufallszahl
  9. Wiederholen Sie den Vorgang ab Schritt 2, verwenden Sie jedoch 95 als obere Grenze der Zufallszahl
  10. Wiederholen Sie den Vorgang ab Schritt 2, verwenden Sie jedoch 94 als obere Grenze der Zufallszahl
  11. Wiederholen Sie den Vorgang ab Schritt 2, verwenden Sie jedoch 93 als obere Grenze der Zufallszahl

Voila - keine wiederholten Zahlen.

Wenn jemand interessiert ist, kann ich später Code veröffentlichen.

Edit: Es ist wahrscheinlich die Konkurrenzserie in mir, aber nachdem ich den Post von @Alsciende gesehen habe, konnte ich nicht widerstehen, den Code zu veröffentlichen, den ich versprochen hatte.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<head>
<title>8 unique random number between 1 and 100</title>
<script type="text/javascript" language="Javascript">
    function pick(n, min, max){
        var values = [], i = max;
        while(i >= min) values.Push(i--);
        var results = [];
        var maxIndex = max;
        for(i=1; i <= n; i++){
            maxIndex--;
            var index = Math.floor(maxIndex * Math.random());
            results.Push(values[index]);
            values[index] = values[maxIndex];
        }
        return results;
    }
    function go(){
        var running = true;
        do{
            if(!confirm(pick(8, 1, 100).sort(function(a,b){return a - b;}))){
                running = false;
            }
        }while(running)
    }
</script>
</head>

<body>
    <h1>8 unique random number between 1 and 100</h1>
    <p><button onclick="go()">Click me</button> to start generating numbers.</p>
    <p>When the numbers appear, click OK to generate another set, or Cancel to stop.</p>
</body>

8
belugabob

Moderne JS-Lösung mit Set (und Durchschnittsfall O (n))

const nums = new Set();
while(nums.size !== 8) {
  nums.add(Math.floor(Math.random() * 100) + 1);
}

console.log([...nums]);

4
Alister Norris

Dies ist eine sehr generische Funktion, die ich geschrieben habe, um zufällige eindeutige/nicht eindeutige Ganzzahlen für ein Array zu erzeugen. Nehmen Sie an, dass der letzte Parameter in diesem Szenario für diese Antwort wahr ist.

/* Creates an array of random integers between the range specified 
     len = length of the array you want to generate
     min = min value you require
     max = max value you require
     unique = whether you want unique or not (assume 'true' for this answer)
*/
    function _arrayRandom(len, min, max, unique) {
        var len = (len) ? len : 10,
                min = (min !== undefined) ? min : 1,
                max = (max !== undefined) ? max : 100,
                unique = (unique) ? unique : false,
                toReturn = [], tempObj = {}, i = 0;

        if(unique === true) {
            for(; i < len; i++) {
                var randomInt = Math.floor(Math.random() * ((max - min) + min));
                if(tempObj['key_'+ randomInt] === undefined) {
                    tempObj['key_'+ randomInt] = randomInt;
                    toReturn.Push(randomInt);
                } else {
                    i--;
                }
            }
        } else {
            for(; i < len; i++) {
                toReturn.Push(Math.floor(Math.random() * ((max - min) + min)));
            }
        }

        return toReturn;
    }

Hier ist das 'tempObj' ein sehr nützliches Objekt, da jede erzeugte Zufallszahl dieses TempObj direkt überprüft, wenn dieser Schlüssel bereits vorhanden ist. Wenn nicht, dann reduzieren wir das i um eins, da wir einen zusätzlichen Lauf benötigen, da die aktuelle Zufallszahl bereits vorhanden ist .

Führen Sie in Ihrem Fall Folgendes aus

_arrayRandom(8, 1, 100, true);

Das ist alles.

3
kaizer1v

Ich würde das machen:

function randomInt(min, max) {
    return Math.round(min + Math.random()*(max-min));
}
var index = {}, numbers = [];
for (var i=0; i<8; ++i) {
    var number;
    do {
        number = randomInt(1, 100);
    } while (index.hasOwnProperty("_"+number));
    index["_"+number] = true;
    numbers.Push(number);
}
delete index;
3
Gumbo

Das Mischen der Zahlen von 1 bis 100 ist die richtige Grundstrategie. Wenn Sie jedoch nur 8 gemischte Zahlen benötigen, müssen Sie nicht alle 100 Zahlen mischen.

Ich kenne Javascript nicht sehr gut, aber ich glaube, es ist einfach, schnell ein Array von 100 Nullen zu erstellen. Dann tauschen Sie für acht Runden das n-te Element des Arrays (n beginnend bei 0) mit einem zufällig ausgewählten Element von n + 1 bis 99. Natürlich bedeuten alle Elemente, die noch nicht belegt sind, dass das Element wirklich gewesen wäre der ursprüngliche Index plus 1, also ist es trivial zu berücksichtigen. Wenn Sie mit den 8 Runden fertig sind, werden die ersten 8 Elemente Ihres Arrays Ihre 8 gemischten Zahlen enthalten.

2
Randal Schwartz

für Arrays mit Löchern wie diesem [,2,,4,,6,7,,], da mein Problem darin bestand, diese Löcher zu füllen. Also habe ich es je nach Bedarf geändert :)

die folgende modifizierte Lösung hat für mich funktioniert :)

var arr = [,2,,4,,6,7,,]; //example
while(arr.length < 9){
  var randomnumber=Math.floor(Math.random()*9+1);
  var found=false;
  for(var i=0;i<arr.length;i++){
    if(arr[i]==randomnumber){found=true;break;}
  }

  if(!found)
    for(k=0;k<9;k++)
    {if(!arr[k]) //if it's empty  !!MODIFICATION
      {arr[k]=randomnumber; break;}}
}

alert(arr); //outputs on the screen
1
Pulkit C

Derselbe Permutationsalgorithmus wie The Machine Charmer, jedoch mit einer prototypischen Implementierung. Besser für eine große Anzahl von Plektren geeignet. Verwendet js 1.7 Destructuring-Zuordnung falls verfügbar.

// swaps elements at index i and j in array this
// swapping is easy on js 1.7 (feature detection)
Array.prototype.swap = (function () {
    var i=0, j=1;
    try { [i,j]=[j,i]; }
    catch (e) {}
    if(i) {
        return function(i,j) {
            [this[i],this[j]] = [this[j],this[i]];
            return this;
        }
    } else {
        return function(i,j) {
            var temp = this[i];
            this[i] = this[j];
            this[j] = temp;
            return this;
        }
    }
})();


// shuffles array this
Array.prototype.shuffle = function() {
    for(var i=this.length; i>1; i--) {
        this.swap(i-1, Math.floor(i*Math.random()));
    }
    return this;
}

// returns n unique random numbers between min and max
function pick(n, min, max) {
    var a = [], i = max;
    while(i >= min) a.Push(i--);
    return a.shuffle().slice(0,n);
}

pick(8,1,100);

Edit: Ein anderer Vorschlag, der besser für eine kleine Anzahl von Picks geeignet ist, basierend auf der Antwort von Belugabob. Um die Eindeutigkeit zu gewährleisten, entfernen wir die ausgewählten Zahlen aus dem Array.

// removes n random elements from array this
// and returns them
Array.prototype.pick = function(n) {
    if(!n || !this.length) return [];
    var i = Math.floor(this.length*Math.random());
    return this.splice(i,1).concat(this.pick(n-1));
}

// returns n unique random numbers between min and max
function pick(n, min, max) {
    var a = [], i = max;
    while(i >= min) a.Push(i--);
    return a.pick(n);
}

pick(8,1,100);
1
Alsciende

Die beste frühere Antwort ist die Antwort von sje397. Sie erhalten so gute Zufallszahlen wie möglich, so schnell wie möglich.

Meine Lösung ist seiner Lösung sehr ähnlich. Manchmal möchten Sie jedoch die Zufallszahlen in zufälliger Reihenfolge. Deshalb habe ich mich entschieden, eine Antwort zu posten. Außerdem habe ich eine allgemeine Funktion.

function selectKOutOfN(k, n) {
  if (k>n) throw "k>n";
  var selection = [];
  var sorted = [];
  for (var i = 0; i < k; i++) {
    var Rand = Math.floor(Math.random()*(n - i));
    for (var j = 0; j < i; j++) {
      if (sorted[j]<=Rand)
        Rand++;
      else
        break;
    }
    selection.Push(Rand);
    sorted.splice(j, 0, Rand);
  }
  return selection;
}

alert(selectKOutOfN(8, 100));
1
AndersTornkvist
var arr = []
while(arr.length < 8){
  var randomnumber=Math.ceil(Math.random()*100)
  if(arr.indexOf(randomnumber) === -1){arr.Push(randomnumber)}  
}
document.write(arr);

kürzer als andere Antworten, die ich gesehen habe

1
FFF

Die Verwendung einer Set ist Ihre schnellste Option. Hier ist eine generische Funktion zum Abrufen eines eindeutigen Zufalls mit einem Rückrufgenerator. Jetzt ist es schnell und wiederverwendbar .

// Get a unique 'anything'
let unique = new Set()

function getUnique(generator) {
  let number = generator()
  while (!unique.add(number)) {
    number = generator()
  }
  return number;
}

// The generator.  Return anything, not just numbers.
const between_1_100 = () => 1 + Math.floor(Math.random() * 100)

// Test it
for (var i = 0; i < 8; i++) {
  const aNumber = getUnique(between_1_100)
}
// Dump the 'stored numbers'
console.log(Array.from(unique))

0
Steven Spungin

Hinzufügen einer besseren Version desselben Codes (akzeptierte Antwort) mit der JavaScript 1.6-Funktion indexOf. Sie müssen nicht jedes Mal das gesamte Array durchlaufen, wenn Sie das Duplikat überprüfen.

var arr = []
while(arr.length < 8){
  var randomnumber=Math.ceil(Math.random()*100)
  var found=false;
    if(arr.indexOf(randomnumber) > -1){found=true;}
  if(!found)arr[arr.length]=randomnumber;
}

Ältere Javascript-Versionen können die Version oben noch verwenden

PS: Versucht, ein Update für das Wiki vorzuschlagen, aber es wurde abgelehnt. Ich denke immer noch, dass es für andere nützlich sein kann.

0

Dies ist meine persönliche Lösung:

<script>

var i, k;
var numbers = new Array();
k = Math.floor((Math.random()*8));
numbers[0]=k;
    for (var j=1;j<8;j++){
        k = Math.floor((Math.random()*8));
i=0;
while (i < numbers.length){
if (numbers[i] == k){
    k = Math.floor((Math.random()*8));
    i=0;
}else {i++;}
}
numbers[j]=k;
    }
    for (var j=0;j<8;j++){
alert (numbers[j]);
    }
</script>

Es generiert zufällig 8 eindeutige Array-Werte (zwischen 0 und 7) und zeigt sie dann mit einem Warnfeld an.

0
Adam Atlas

wenn Sie mehr eindeutige Informationen benötigen, müssen Sie ein Array (1..100) generieren.

var arr=[];
function generateRandoms(){
for(var i=1;i<=100;i++) arr.Push(i);
}
function extractUniqueRandom()
{
   if (arr.length==0) generateRandoms();
   var randIndex=Math.floor(arr.length*Math.random());
   var result=arr[randIndex];
   arr.splice(randIndex,1);
   return result;

}
function extractUniqueRandomArray(n)
{
   var resultArr=[];
   for(var i=0;i<n;i++) resultArr.Push(extractUniqueRandom());
   return resultArr;
}

der obige Code ist schneller:
extractUniqueRandomArray (50) => [2, 79, 38, 59, 63, 42, 52, 22, 78, 50, 39, 77, 1, 88, 40, 23, 48, 84, 91 49, 4, 54, 93, 36, 100, 82, 62, 41, 89, 12, 24, 31, 86, 92, 64, 75, 70, 61, 67, 98, 76, 80, 56, 90 83, 44, 43, 47, 7, 53]

0
MajidTaheri

Diese Lösung verwendet den Hash, der viel performanter ist O(1), als zu prüfen, ob der im Array liegt. Es gibt auch zusätzliche sichere Kontrollen. Ich hoffe es hilft.

function uniqueArray(minRange, maxRange, arrayLength) {
  var arrayLength = (arrayLength) ? arrayLength : 10
  var minRange = (minRange !== undefined) ? minRange : 1
  var maxRange = (maxRange !== undefined) ? maxRange : 100
  var numberOfItemsInArray = 0
  var hash = {}
  var array = []

  if ( arrayLength > (maxRange - minRange) ) throw new Error('Cannot generate unique array: Array length too high')

  while(numberOfItemsInArray < arrayLength){
    // var randomNumber = Math.floor(Math.random() * (maxRange - minRange + 1) + minRange)
    // following line used for performance benefits
    var randomNumber = (Math.random() * (maxRange - minRange + 1) + minRange) << 0

    if (!hash[randomNumber]) {
      hash[randomNumber] = true
      array.Push(randomNumber)
      numberOfItemsInArray++
    }
  }
  return array
}
document.write(uniqueArray(1, 100, 8))
0
RIdotCOM
var bombout=0;
var checkArr=[];
var arr=[];
while(arr.length < 8 && bombout<100){
  bombout++;
  var randomNumber=Math.ceil(Math.random()*100);
  if(typeof checkArr[randomNumber] == "undefined"){
    checkArr[randomNumber]=1;
    arr.Push(randomNumber);
  }
}​

// untested - hence bombout
0
CPslashM
getRandom (min, max) {
  return Math.floor(Math.random() * (max - min)) + min
}

getNRandom (min, max, n) {
  const numbers = []
  if (min > max) {
    return new Error('Max is gt min')
  }

  if (min === max) {
    return [min]
  }

  if ((max - min) >= n) {
    while (numbers.length < n) {
      let Rand = this.getRandom(min, max + 1)
      if (numbers.indexOf(Rand) === -1) {
        numbers.Push(Rand)
      }
    }
  }

  if ((max - min) < n) {
    for (let i = min; i <= max; i++) {
      numbers.Push(i)
    }
  }
  return numbers
}
0
Oscar López

Hier ist meine ES6-Version, die ich zusammengeschustert habe. Ich bin sicher, dass es ein bisschen konsolidierter sein kann.

function randomArray(i, min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  
  let arr = Array.from({length: i}, () => Math.floor(Math.random()* (max - min)) + min);
  
  return arr.sort();
 }
 
 let uniqueItems = [...new Set(randomArray(8, 0, 100))]
 console.log(uniqueItems);
0
Alex Mireles

Dies kann die Erzeugung einer bis zu 20-stelligen UNIQUE-Zufallszahl bewirken

JS

 var generatedNumbers = [];

    function generateRandomNumber(precision) { // input --> 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
function getUniqueRandomNos() {
    var indexedArrayOfRandomNo = [];
    for (var i = 0; i < 100; i++) {
        var randNo = Math.random();
        indexedArrayOfRandomNo.Push([i, randNo]);
    }
    indexedArrayOfRandomNo.sort(function (arr1, arr2) {
        return arr1[1] - arr2[1]
    });
    var uniqueRandNoArray = [];
    for (i = 0; i < 8; i++) {
        uniqueRandNoArray.Push(indexedArrayOfRandomNo[i][0]);
    }
    return uniqueRandNoArray;
}

Ich denke, diese Methode unterscheidet sich von den Methoden, die in den meisten Antworten angegeben wurden. Ich dachte, ich könnte hier eine Antwort hinzufügen (obwohl die Frage vor 4 Jahren gestellt wurde).

Wir generieren 100 Zufallszahlen und kennzeichnen jede von ihnen mit Zahlen von 1 bis 100. Anschließend sortieren wir diese markierten Zufallszahlen, und die Tags werden zufällig gemischt. Alternativ könnte man, wie in dieser Frage erforderlich, auf das Finden der Top 8 der getaggten Zufallszahlen verzichten. Das Finden der Top-8-Artikel ist billiger als das Sortieren des gesamten Arrays .

Hier ist zu beachten, dass der Sortieralgorithmus diesen Algorithmus beeinflusst. Wenn der verwendete Sortieralgorithmus stabil ist, gibt es eine geringfügige Tendenz zugunsten kleinerer Zahlen. Idealerweise möchten wir, dass der Sortieralgorithmus instabil ist und nicht auf Stabilität (oder Instabilität) ausgerichtet ist, um eine Antwort mit einer vollkommen gleichförmigen Wahrscheinlichkeitsverteilung zu erzeugen.

0
Kartik Kale

Wenn Sie dies als Generator implementieren, ist es sehr schön, damit zu arbeiten. Beachten Sie, dass diese Implementierung sich von denen unterscheidet, bei denen das gesamte Eingangsarray zuerst gemischt werden muss. 

Diese sample-Funktion arbeitet träge und gibt Ihnen pro Iteration 1 zufälliges Element bis zu N-Elementen, nach denen Sie fragen. Das ist schön, denn wenn Sie nur 3 Elemente aus einer Liste von 1000 möchten, müssen Sie nicht zuerst alle 1000 Elemente berühren.

// sample :: Integer -> [a] -> [a]
const sample = n => function* (xs) {
  let ys = xs.slice(0);
  let len = xs.length;
  while (n > 0 && len > 0) {
    let i = (Math.random() * len) >> 0;
    yield ys.splice(i,1)[0];
    n--; len--;
  }
}

// example inputs
let items = ['a', 'b', 'c', 'd', 'e', 'f', 'g'];
let numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

// get 3 random items
for (let i of sample(3) (items))
  console.log(i); // f g c

// partial application
const lotto = sample(3);
for (let i of lotto(numbers))
  console.log(i); // 3 8 7

// shuffle an array
const shuffle = xs => Array.from(sample (Infinity) (xs))
console.log(shuffle(items)) // [b c g f d e a]

Ich habe mich entschieden, sample so zu implementieren, dass das Eingabearray nicht mutiert wird, aber man könnte leicht argumentieren, dass eine mutierende Implementierung günstig ist.

Beispielsweise möchte die Funktion shuffle das ursprüngliche Eingabearray mutieren. Oder Sie möchten zu verschiedenen Zeitpunkten von derselben Eingabe abtasten und die Eingabe jedes Mal aktualisieren.

// sample :: Integer -> [a] -> [a]
const sample = n => function* (xs) {
  let len = xs.length;
  while (n > 0 && len > 0) {
    let i = (Math.random() * len) >> 0;
    yield xs.splice(i,1)[0];
    n--; len--;
  }
}

// deal :: [Card] -> [Card]
const deal = xs => Array.from(sample (2) (xs));

// setup a deck of cards (13 in this case)
// cards :: [Card]
let cards = 'A234567890JQK'.split('');

// deal 6 players 2 cards each
// players :: [[Card]]
let players = Array.from(Array(6), $=> deal(cards))

console.log(players);
// [K, J], [6, 0], [2, 8], [Q, 7], [5, 4], [9, A]

// `cards` has been mutated. only 1 card remains in the deck
console.log(cards);
// [3]

sample ist aufgrund der Array-Eingangsmutation nicht mehr eine pure - Funktion, aber unter bestimmten Umständen (oben gezeigt) ist dies möglicherweise sinnvoller.


Ein anderer Grund, warum ich einen Generator anstelle einer Funktion gewählt habe, die nur ein Array zurückgibt, ist, dass Sie mit der Abtastung bis zu einer bestimmten Bedingung fortfahren möchten.

Vielleicht möchte ich die erste Primzahl aus einer Liste von 1.000.000 Zufallszahlen.

  • "Wie viele soll ich probieren?" - Sie müssen nicht angeben
  • "Muss ich zuerst alle Primzahlen finden und dann eine zufällige Primzahl auswählen?" - Nope.

Da wir mit einem Generator arbeiten, ist diese Aufgabe trivial

const randomPrimeNumber = listOfNumbers => {
  for (let x of sample(Infinity) (listOfNumbers)) {
    if (isPrime(x))
      return x;
  }
  return NaN;
}

Dabei wird fortlaufend 1 Zufallszahl x abgetastet, überprüft, ob es eine Primzahl ist, und dann x zurückgegeben, falls dies der Fall ist. Wenn die Liste der Nummern erschöpft ist, bevor ein Prim gefunden wird, wird NaN zurückgegeben.


Hinweis:

Diese Antwort wurde ursprünglich für eine andere Frage freigegeben, die als Duplikat dieser Frage geschlossen wurde. Da es sich sehr von den anderen hier angebotenen Lösungen unterscheidet, habe ich mich entschlossen, es auch hier zu veröffentlichen

0
user633183

Ein einfacherer Ansatz besteht darin, ein Array mit 100 Elementen mit aufsteigenden Zahlen zu generieren und zufällig zu sortieren. Dies führt tatsächlich zu einem wirklich kurzen und (meiner Meinung nach) einfachen Ausschnitt.

function randomNumbers() {
  const numbers = [ ...Array(100).keys() ].map(num => num + 1);
  numbers.sort(() => Math.random() - 0.5);
  return numbers.slice(0, 8);
}
0
ngfelixl

Wie wäre es mit Objekteigenschaften als Hashtabelle ? Auf diese Weise ist es das beste Szenario, nur achtmal zufällig zu bestimmen. Dies ist nur wirksam, wenn Sie einen kleinen Teil des Zahlenbereichs benötigen. Es ist auch weniger speicherintensiv als Fisher-Yates, da Sie keinen Platz für ein Array reservieren müssen.

var ht={}, i=rands=8;
while ( i>0 || keys(ht).length<rands) ht[Math.ceil(Math.random()*100)]=i--;
alert(keys(ht));

Ich habe dann herausgefunden, dass Object.keys (obj) ein ECMAScript 5-Feature ist, daher ist das oben genannte im Internet ziemlich nutzlos. Fürchten Sie sich nicht, weil ich ECMAScript 3-kompatibel gemacht habe, indem Sie eine Tastenfunktion wie diese hinzufügen.

if (typeof keys == "undefined") 
{ 
  var keys = function(obj) 
  {
    props=[];
    for (k in ht) if (ht.hasOwnProperty(k)) props.Push(k);
    return props;
  }
}
0
Jonas Elfström