Random number generator ohne Duplikate in Javascript?

Ich brauche Hilfe mit dem schreiben von code zu schaffen, der eine zufällige Zahl aus einem array von 12 zahlen und drucken Sie es 9 mal ohne dupes. Das war hart für mich zu erreichen. Irgendwelche Ideen?

Können Sie upvote die Antwort 🙂

InformationsquelleAutor Vic | 2010-09-26

javascript random

var nums = [1,2,3,4,5,6,7,8,9,10,11,12];
var gen_nums = [];

function in_array(array, el) {
   for(var i = 0 ; i < array.length; i++) 
       if(array[i] == el) return true;
   return false;
}

function get_rand(array) {
    var rand = array[Math.floor(Math.random()*array.length)];
    if(!in_array(gen_nums, rand)) {
       gen_nums.push(rand); 
       return rand;
    }
    return get_rand(array);
}

for(var i = 0; i < 9; i++) {
    document.write(get_rand(nums));
}

InformationsquelleAutor Jacob Relkin

4

Effektivste und effizienteste Weg, dies zu tun ist, zu mischen, Ihre zahlen, und drucken Sie dann die ersten neun von Ihnen. Verwenden Sie eine gute shuffle-Algorithmus.Was Thilo vorgeschlagen wird, geben Sie schlechte Ergebnisse. Siehe hier.

Bearbeiten
Hier ist eine kurze Knuth Shuffle-Algorithmus Beispiel:
```
void shuffle(vector<int> nums)
{
  for (int i = nums.size()-1; i >= 0; i--)
  {
    //this line is really shorthand, but gets the point across, I hope.
    swap(nums[i],nums[rand()%i]);
  }
}
```
Mithilfe der bewährten algorithmen, die Sie vorschlagen, scheint wie eine bessere Idee, wenn man es ernst. Ich möchte nur darauf hinweisen, dass der Algorithmus, den ich vorgeschlagen, ist nicht die, die diskutiert ungünstig in der "siehe hier".
Es ist nicht der gleiche Algorithmus, keine. Aber ich fürchte, es würde immer noch den gleichen Fehler erzeugen, wenn ich verstehe, Recht. Es gibt n^3 Ergebnisse der Algorithmus, mit dem land in einem der n! - Boxen. , Kann keine gleichmäßige Verteilung. Versuchen Sie das experiment in den Artikel mit Ihrem Algorithmus und sehen, ob es funktioniert.
In den Kommentaren zu dem blog, den Sie verlinkten, "mein" Algorithmus wird erzogen von "fabio". Er behauptet, dass es funktioniert, aber mit einer größeren Anzahl von swaps (nicht nur die array-Größe). Ich werde Lesen ein wenig mehr und sehen, ob ich nachweisen kann, es richtig oder falsch ist. Andrew Dunn ' s Vorschlag unten scheint statistisch korrekt, auch wenn es performance-Probleme.
Ich sah, dass der Kommentar, auf den Sie hingewiesen. Ich fühle immer noch, dass die Anzahl der Pfade muss teilbar durch n! passen Sie gleichmäßig in n! Ergebnisse, aber ich kann mich irren. Ich wäre daran interessiert zu sehen, was Sie finden, vergleichen Knuth ' s Algorithmus zu Ihnen Seite an Seite. Und ja, Dunn ' s Algorithmus funktionieren sollte (trotz Leistung).
Ich nehme es für die Statistiker: stats.stackexchange.com/questions/3082/...

InformationsquelleAutor JoshD

Versuchen Sie einmal dieses:

//Here o is the array;
var testArr = [6, 7, 12, 15, 17, 20, 21];
    shuffle = function(o){ //v1.0
                        for(var j, x, i = o.length; i; j = parseInt(Math.random() * i), x = o[--i], o[i] = o[j], o[j] = x);
                        return o;
                };
shuffle(testArr);

InformationsquelleAutor Sudhir Bastakoti

0

Dies ist relativ einfach zu tun, die Theorie dahinter ist, erstellen Sie ein anderes array, das hält den überblick über die Elemente des Arrays, die Sie verwendet haben.
```
var tempArray = new Array(12),i,r;
for (i=0;i<9;i++)
    {
    r = Math.floor(Math.random()*12);    //Get a random index
    if (tempArray[r] === undefined)      //If the index hasn't been used yet
        {
        document.write(numberArray[r]);  //Display it
        tempArray[r] = true;             //Flag it as have been used
        }
    else                                 //Otherwise
        {
        i--;                             //Try again
        }
    }
```
Andere Methoden umfassen das mischen der array entfernen verwendet Elemente aus dem array, oder bewegte Elemente verwendet, um das Ende des Arrays.

Nicht mit dem obigen code für den professionellen funktioniert aber, es ist ein extrem einfaches Beispiel, um zu demonstrieren, die Logik hinter dem, was Sie zu tun versuchen (Druck 9 Werte aus einem array mit 12 Werten in zufälliger Reihenfolge).
Es scheint produzieren eine unvoreingenommene Folge von zahlen, aber. Das einzige problem, das ich sehen kann, ist die Leistung, wie wird es zunehmend schwieriger zu finden, die restlichen zahlen.
Genau, während der Algorithmus genügt für kleinere Datenmengen, für größere Mengen, die Sie benötigen, um sicherzustellen, dass Kollisionen nicht auftreten, entweder durch entfernen der Daten aus dem array, oder schieben Sie es bis zum Ende.

InformationsquelleAutor Randy the Dev
0

Wenn ich Sie richtig verstehe, Sie wollen, mische dein array.

Schleife ein paar mal (Länge des Arrays), und in jeder iteration werden zwei zufällige array-Indizes und vertauschen die beiden Elemente, die es gibt. (Update: wenn es dir wirklich ernst damit ist, dies kann nicht sein, das am besten Algorithmus).

Können Sie dann drucken die ersten neun array-Elemente, die in zufälliger Reihenfolge und nicht zu wiederholen.

InformationsquelleAutor Thilo

Hier ist ein allgemeiner Weg, um Zufallszahlen zwischen min und max ohne Duplikate:

function inArray(arr, el) {
    for(var i = 0 ; i < arr.length; i++) 
            if(arr[i] == el) return true;
    return false;
}

function getRandomIntNoDuplicates(min, max, DuplicateArr) {
    var RandomInt = Math.floor(Math.random() * (max - min + 1)) + min;
    if (DuplicateArr.length > (max-min) ) return false;  //break endless recursion
    if(!inArray(DuplicateArr, RandomInt)) {
       DuplicateArr.push(RandomInt); 
       return RandomInt;
    }
    return getRandomIntNoDuplicates(min, max, DuplicateArr); //recurse
}

Anruf mit:

var duplicates  =[];
for (var i = 1; i <= 6 ; i++) { 
    console.log(getRandomIntNoDuplicates(1,10,duplicates));
}

InformationsquelleAutor cologne

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.