Générer des entiers aléatoires avec des probabilités

Je suis un peu confus sur la façon de générer des valeurs entières avec des probabilités.

Comme un exemple, j'ai quatre entiers avec leurs valeurs de probabilité: 1/0.4, 2/0.3, 3/0.2, 4/0.1

Comment puis-je générer ces quatre numéros en tenant compte de leurs probabilités?

InformationsquelleAutor Headshota | 2012-01-16
  1. 36

    Voici une astuce utile 🙂

    function randomWithProbability() {
  var notRandomNumbers = [1, 1, 1, 1, 2, 2, 2, 3, 3, 4];
  var idx = Math.floor(Math.random() * notRandomNumbers.length);
  return notRandomNumbers[idx];
}
    • Bon sens, il suffit de créer notRandomNumbers dynamiquement (compte tenu du nombre et leur poids ou de probabilité) et c'est la solution idéale à mon avis.
    • Nice! Merci. cela ressemble juste ce dont j'ai besoin.
    • oui, je l'ai fait simple pour plus de clarté 🙂
    • bien sûr, j'ai été en attente pour certains plus de solutions à choisir le meilleur 😉
    • Nope, je n'ai pas changer quoi que ce soit. J'ai seulement accepté maintenant votre réponse pour la solution plus élégante que les autres.
    • Ah, je pensais que vous l'avez accepté que précédemment. Jamais l'esprit. Ouais, ma solution est plus élégante 🙂

    InformationsquelleAutor Sergio Tulentsev
  2. 28

    Une simple approche naïve peut être:

    function getRandom(){
  var num=Math.random();
  if(num < 0.3) return 1;  //probability 0.3
  else if(num < 0.6) return 2; //probability 0.3
  else if(num < 0.9) return 3; //probability 0.3
  else return 4;  //probability 0.1
}

    • Que faire si deux nombres ont la même probabilité? 🙂
    InformationsquelleAutor bhups
  3. 14

    Solution plus flexible, basé sur @bhups réponse. Ceci utilise le tableau de valeurs de probabilité (de poids). La somme de 'poids' des éléments doit être égale à 1. 

    var weights = [0.3, 0.3, 0.3, 0.1]; //probabilities
var results = [1, 2, 3, 4]; //values to return

function getRandom () {
    var num = Math.random(),
        s = 0,
        lastIndex = weights.length - 1;

    for (var i = 0; i < lastIndex; ++i) {
        s += weights[i];
        if (num < s) {
            return results[i];
        }
    }

    return results[lastIndex];
};
    InformationsquelleAutor
  4. 4

    Je suggère d'utiliser un contrôle continu de la probabilité et le reste du nombre aléatoire.

    Cette fonction définit d'abord la valeur de retour pour le dernier indice possible et itère jusqu'à ce que le reste de la valeur aléatoire est plus petite que la probabilité réelle.

    Les probabilités ont pour somme à un.

    JS:

    function getRandomIndexByProbability(probabilities) {
    var r = Math.random(),
        index = probabilities.length - 1;

    probabilities.some(function (probability, i) {
        if (r < probability) {
            index = i;
            return true;
        }
        r -= probability;
    });
    return index;
}

var i,
    probabilities = [0.4, 0.3, 0.2, 0.09, 0.01 ],
    count = {},
    index;

probabilities.forEach(function (a) { count[a] = 0; });

for (i = 0; i < 1e6; i++) {
    index = getRandomIndexByProbability(probabilities);
    count[probabilities[index]]++
}

console.log(count);

    InformationsquelleAutor Nina Scholz
  5. 1

    C'est la solution que j'ai trouver le plus souple, de la cueillette à l'intérieur de n'importe quel ensemble d'objets avec des probabilités:

    JS:

    //set of object with probabilities:
const set = {1:0.4,2:0.3,3:0.2,4:0.1};

//get probabilities sum:
var sum = 0;
for(let j in set){
    sum += set[j];
}

//choose random integers:
console.log(pick_random());

function pick_random(){
    var pick = Math.random()*sum;
    for(let j in set){
        pick -= set[j];
        if(pick <= 0){
            return j;
        }
    }
}

    InformationsquelleAutor François Huppé