La cueillette des 2 éléments aléatoires à partir de la matrice de

Quel est le moyen le plus efficace de sélectionner 2 unique aléatoire des éléments d'un tableau (c'est à dire, assurez-vous que le même élément n'est pas sélectionné à deux reprises).

J'ai jusqu'à présent:

var elem1;
var elem2;

elem1 = elemList[Math.ceil(Math.random() * elemList.length)];
do {
  elem2 = elemList[Math.ceil(Math.random() * elemList.length)];
} while(elem1 == elem2)

Mais souvent, cela se bloque mon chargement de la page.

Une meilleure solution?

Question supplémentaire, comment puis-je étendre à n éléments

OriginalL'auteur zsquare | 2012-03-15

  1. 29

    ne PAS utiliser des boucles et des comparaisons. Au lieu de cela

    • shuffle le tableau
    • prendre deux premiers éléments
    Ce serait plus lent pour la grande entrée tableaux.
    certainement. De l'autre côté, il serait intéressant de savoir exactement comment beaucoup plus lent pour la façon dont les grandes baies. Soins à jsperf?
    Mon tableau est assez grand (+de 500 objets), comme @Dogbert dit, ne serait pas que cette approche soit moins efficace?
    En disant: "500 objets n'est pas important du tout", c'est comme dire "500 longueurs de chaîne ne sont pas très long".
    Je ne comprends pas ce que vous avez dit.

    OriginalL'auteur georg

  2. 5

    http://underscorejs.org/#sample

    _.exemple(liste [n])

    Produire un échantillon aléatoire de la liste. Passer un certain nombre de retour de n éléments aléatoires à partir de la liste. Sinon, un seul élément de hasard sera retourné.

    _.sample([1, 2, 3, 4, 5, 6]);
=> 4

_.sample([1, 2, 3, 4, 5, 6], 3);
=> [1, 6, 2]

    À la recherche à la source qu'il utilise shuffle tout comme @thg435 suggéré.

    Alternative est lodash a un sampleSize méthode

    OriginalL'auteur Michal Stefanow

  3. 4

    Votre code se bloque lorsque la liste contient un seul élément. Au lieu d'utiliser ==, je recommande d'utiliser ===, qui semble plus approprié dans ce cas.

    Aussi, l'utilisation Math.floor au lieu de Math.ceil. Le length propriété est égale à <highest index> + 1.

    var elem1;
var elem2;
var elemListLength = elemList.length;

elem1 = elemList[Math.floor(Math.random() * elemListLength)];
if (elemListLength > 1) {
    do {
      elem2 = elemList[Math.floor(Math.random() * elemListLength)];
    } while(elem1 == elem2);
}
    Mon code se bloque quand il y a plus d'un élément aussi, essayez de votre code.
    Aussi, les idées de comment l'étendre à la cueillette des n éléments aléatoires?
    Le code et l'algorithme est similaire à celui de Génération de nombres aléatoires (entiers) entre 0 'et'x'

    OriginalL'auteur Rob W

  4. 3

    Sur ce que Rob W vous l'ai dit, je vais ajouter qu'une autre solution serait de trouver un point au hasard et pour le deuxième point de trouver un décalage aléatoire du point:

    var elem1;
var elem2;
var elemListLength = elemList.length;

var ix = Math.floor(Math.random() * elemListLength);
elem1 = elemList[ix];

if (elemListLength > 1) {
    elem2 = elemList[(ix + 1 + Math.floor(Math.random() * (elemListLength - 1))) % elemListLength];
}

    Nous ajoutons 1 parce que l'élément en cours ne peut pas être resélectionnés et soustrayez 1 parce qu'un élément a déjà été sélectionné.

    Par exemple, un tableau de trois éléments (0, 1, 2). Nous choisissons au hasard de l'élément 1. Maintenant, la "bonne" valeur de décalage sont 0 et 1, avec un décalage de 0 donnant l'élément 2 et un décalage de 1 donnant l'élément 0.

    Noter que ce sera vous donner deux éléments aléatoires avec d'INDICE différent, pas avec une VALEUR différente!

    Les avantages de cette méthode par rapport à l'orignal?
    Pas de tout cycle. Il va donner un bon couple d'éléments en constante déterministe du temps. Et je considère qu'il est plus élégant 🙂 🙂 Mais, en vérité, rien de vraiment important. La vitesse n'est pas un problème dans ce cas.
    Upvotes constante déterministe en temps 🙂
    il y a une erreur, même si, (elem1 + 1 + Math.floor(Math.random() * (elemListLength - 1))) % elemListLength elem1 est un objet, vous avez besoin pour économiser de l'ancienne index au lieu
    Droit corrigé

    OriginalL'auteur xanatos

  5. 2

    Si vous souhaitez obtenir n éléments aléatoires, vous pouvez créer une mélangées version de votre liste et ensuite de retour à la première n éléments de la mélangées groupe comme une raison.

    Si j'ai un grand tableau, cette méthode encore plus rapide que la cueillette de n éléments aléatoires?
    Cela dépend de la valeur de n par rapport à la taille de votre tableau. Si ils sont presque les mêmes puis brassage sera probablement plus rapide.
    mon tableau est 500 plus, et j'ai besoin de 2 éléments 🙂

    OriginalL'auteur sietschie

  6. 2

    Il peut être fait à l'aide d'une fonctionnalité intégrée (tranche et tri),

    var n = 2
    randomItems = array.sort(() => .5 - Math.random()).slice(0, n);

    OriginalL'auteur Mehdi Dehghani

  7. 0

    Si vous shuffle le tableau et d'en réunir le nombre d'éléments que vous voulez retourner,
    la valeur de retour va contenir autant d'éléments qu'il le peut,
    si vous demandez plus d'éléments dans le tableau.
    Vous pouvez mélanger le tableau réel ou d'une copie, avec slice().

    Array.prototype.getRandom= function(num, cut){
    var A= cut? this:this.slice(0);
    A.sort(function(){
        return .5-Math.random();
    });
    return A.splice(0, num);
}
var a1= [1, 2, 3, 4, 5];
a1.getRandom(2)
>>[4, 2]

    Si vous souhaitez supprimer les éléments sélectionnés à partir du tableau d'origine,
    de sorte qu'un deuxième appel ne comprennent pas les éléments du premier appel renvoyé,
    passer un deuxième argument: getRandom(3,true);

    window.Memry=window.Memry || {};
Memry.a1= [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

Memry.a1.getRandom(3,true);
>>[5,10,7]
Memry.a1.getRandom(3,true);
>>[3,9,6]
Memry.a1.getRandom(3,true);
>>[8,4,1]
Memry.a1.getRandom(3,true);
>>[2]

    OriginalL'auteur kennebec