Générer le nombre dans la gamme avec la même probabilité avec des dés

Question

J'ai pensé à ceci mais n'arrive pas à le comprendre. J'ai besoin de choisir un entier aléatoire entre 1 et 50 (inclusivement) de telle sorte que chacun des nombres entiers soit également probable. Je vais devoir le faire en utilisant un dé à 8 faces et un dé à 15 faces.

J'ai lu quelque peu des questions similaires liées aux générateurs de nombres aléatoires avec des dés mais je suis encore confus. Je pense que c'est quelque part le long de la ligne de partitionner les nombres en ensembles. Ensuite, je lancerais un dé, puis, selon le résultat, déciderais quel dé à lancer à nouveau.

Quelqu'un peut-il m'aider?

Answer 1

En tant que simple - pas nécessairement la solution « optimale », rouler le 8 mourir face, puis le 15 face:

8 sided 15 sided 1..50 result 
1 or 2 1..15  1..15 
3 or 4 1..15  16..30 (add 15 to 15-sided roll) 
5 or 6 1..15  31..45 (add 30 to 15-sided roll) 
7 or 8 1..5  46..50 (add 45 to 15-sided roll) 
7 or 8 6..15  start again/reroll both dice 

Answer 2

permet de dire que vous avez deux fonctions: d8(), qui renvoie un nombre de 0 à 7 , et d15(), qui retourne un nombre de 0 à 14. Vous voulez écrire un d50() qui renvoie un nombre de 0 à 49.

De tous les moyens simples, celui-ci est probablement le plus efficace en termes de combien Dés, vous devez rouler, et quelque chose comme ça fonctionnera pour toutes les combinaisons de dés que vous avez et que vous voulez:

int d50() 
{ 
    int result; 
    do 
    { 
     result = d8()*8+d8(); //random from 0 to 63 
    } while(result >=50); 
    return result; 
} 

Si vous voulez temps vraiment constante, vous pouvez le faire:

int d50() 
{ 
    int result = d15(); 
    int result = result*15+d15(); //0 to 225 
    int result = result*8+d8(); //0 to 1799 
    return result/36; //integer division rounds down 
} 

De cette façon, combine dés jusqu'à ce que le nombre de possibilités (1800) est divisible par 50, de sorte que le même nombre de possibilités correspondre à chaque résultat. Cela fonctionne bien dans ce cas, mais ne fonctionne pas si les facteurs premiers des dés que vous avez (2, 3 et 5 dans ce cas), ne couvrent pas les facteurs du dé que vous voulez (2, 5)

Answer 3

Je pense que vous pouvez considérer chaque résultat de dés comme une subdivision d'un plus grand intervalle. Donc, en jetant un dé à 8 faces, vous en choisissez un sur l'intervalle 8 qui divise votre gamme de valeur. Lancer un dé à 15 faces signifie en sélectionner un sur le sous-intervalle 15 et ainsi de suite. Considérant que 15 = 3 * 5, 8 = 2 * 2 * 2 et 50 = 2 * 5 * 5, vous pouvez choisir 36 = 3 * 3 * 2 * 2 comme multiple utile de 50:

15 * 15 * 8 = 50 * 36 = 1800

Vous pouvez même penser à exprimer les nombres de 0 à 1799 à la base 15 et choisissez ramdomly les trois chiffres:

choix = [0-7] * 15^2 + [0-14] * 15^1 + [0-14] * 15^0

donc ma proposition, avec un test de la distribution, est (dans le langage C++):

#include <iostream> 
#include <random> 
#include <map> 

int main() { 
    std::map<int, int> hist; 
    int result; 

    std::random_device rd; 
    std::mt19937 gen(rd()); // initialiaze the random generator 
    std::uniform_int_distribution<> d8(0, 7);  // istantiate the dices 
    std::uniform_int_distribution<> d15(0, 14); 

    for (int i = 0; i < 20000; ++i) {  // make a lot of throws... 
     result = d8(gen) * 225; 
     result += d15(gen) * 15;   // add to result 
     result += d15(gen); 
     ++hist[ result/36 + 1];   // count each result 
    } 
    for (auto p : hist) {     // show the occurences of each result 
     std::cout << p.first << " : " << p.second << '\n'; 
    } 
    return 0; 
} 

La sortie devrait être quelque chose comme ceci:

1 : 387 
2 : 360 
3 : 377 
4 : 393 
5 : 402 
... 
48 : 379 
49 : 378 
50 : 420