[JAVA] Un rapide coup d'œil sur le problème de Monty Hall

introduction

Quel est le problème de Monty Hall? D'après [Wikipedia](https://ja.wikipedia.org/wiki/Monty Hall problem)

Il y a trois portes fermées devant le joueur, derrière une porte se trouve une nouvelle voiture de prix, et derrière les deux portes se trouve une chèvre, ce qui veut dire éteint. Les joueurs peuvent obtenir une nouvelle voiture en frappant la porte de la nouvelle voiture. Une fois que le joueur a sélectionné une porte, le modérateur Monty ouvre la porte restante avec la chèvre et montre la chèvre. Le joueur est maintenant informé qu'il peut remplacer la première porte qu'il choisit par la porte restante non ouverte. Le joueur devrait-il changer la porte ici?

Il semble que ce soit un problème. (* Cependant, Monty sait où aller et ouvre toujours l'endroit où se trouve la chèvre.) À première vue, il semble que la probabilité ne change pas même si la porte est changée ou non, mais en fait il semble qu'il soit avantageux pour le joueur de la changer **. Cette fois, j'aimerais beaucoup essayer cette expérience et comparer les résultats. Le langage est toujours sûr Java ~~ (autant que vous le souhaitez) ~~.

Exigences

code

Monty.java


import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Set;
import java.util.HashSet;
import java.util.List;
import java.util.Random;

public class Monty {
    public static final int NUMBER_DOORS = 4;
    public static final int TRY_TIMES = 10000;
    public static final boolean CHANGE_DOOR = true; 

    //Obtenir au hasard des portes autres que la porte spécifiée
    public static int getOtherDoor(Collection<Integer> doorIndices) {
        List<Integer> notSelectedDoors = new ArrayList<>();
        
        for (int i = 0; i < NUMBER_DOORS; i++) {
            if(!doorIndices.contains(i)){
                notSelectedDoors.add(i);
            }
        }
        Collections.shuffle(notSelectedDoors);
        return notSelectedDoors.get(0);
    }

    //Procès de Monty Hall
    public static boolean montyHoll(){
        //Le nombre de fois où Monty ouvre la porte
        final int OPEN_DORE_TIMES = NUMBER_DOORS - 2;
        
        Random r = new Random();
        int collectDoorIndex = r.nextInt(NUMBER_DOORS);
        int firstSelectDoorIndex = r.nextInt(NUMBER_DOORS);

        Set<Integer> notWillOpenDoorIndices = new HashSet<>();
        Set<Integer> openDoorIndices = new HashSet<>();

        notWillOpenDoorIndices.add(collectDoorIndex);
        notWillOpenDoorIndices.add(firstSelectDoorIndex);

        for (int i = 0; i < OPEN_DORE_TIMES; i++) {
            int otherDoor = getOtherDoor(notWillOpenDoorIndices);
            openDoorIndices.add(otherDoor);
            notWillOpenDoorIndices.add(otherDoor);
        }

        Set<Integer> notWillSelectDoorIndices = new HashSet<>(openDoorIndices);
        notWillSelectDoorIndices.add(firstSelectDoorIndex);

        int secondSelectDoorIndex = CHANGE_DOOR?getOtherDoor(notWillSelectDoorIndices):firstSelectDoorIndex;

        boolean getCar = (collectDoorIndex == secondSelectDoorIndex);
        /*System.out.printf("c:%d,fs:%d,ss:%d,g:%s\n", 
        collectDoorIndex, firstSelectDoorIndex, secondSelectDoorIndex, Boolean.toString(getCar));*/
        return getCar;
    }

    public static void main(String[] args) {
        int getCarTimes = 0;
        for (int i = 0; i < TRY_TIMES; i++) {
            if(montyHoll()){
                getCarTimes++;
            }
        }
        System.out.println((double)getCarTimes / (double)TRY_TIMES);
    }
}

résultat

«Nous avons expérimenté trois fois chacun. ――Cependant, si vous changez la porte et si vous ne la changez pas, nous le ferons séparément. (Autrement dit, la direction horizontale ne correspond pas.)

Tableau 1: Trois portes

No. Si vous changez la porte Si vous ne changez pas la porte
1 0.6687 0.3401
2 0.6683 0.3409
3 0.6631 0.3351

Tableau 2: 4 portes

No. Si vous changez la porte Si vous ne changez pas la porte
1 0.7561 0.2531
2 0.7486 0.2463
3 0.7534 0.2514

Tableau 3: Cinq portes

No. Si vous changez la porte Si vous ne changez pas la porte
1 0.8006 0.2086
2 0.8038 0.2059
3 0.8011 0.1947

Résumé

Quel que soit le nombre de portes que vous avez, changer la porte semble avoir une probabilité plus élevée. «Plus vous aurez de portes, plus il sera avantageux de les changer.

en conclusion

Jusqu'à très récemment, ce problème n'est pas passé inaperçu. Avec ça, j'ai l'impression d'avoir pu l'avaler pour le moment. Après tout, il est important de confirmer.

Recommended Posts

Un rapide coup d'œil sur le problème de Monty Hall
Retour rapide sur Java au cours des cinq dernières années
Jetez un coup d'œil à Gradle et lisez le build.gradle généré par Spring Initializr
Jetons un coup d'œil à l'écran de Quant Analyzer!
Un mémorandum du problème FizzBuzz
J'ai jeté un coup d'œil aux ressources d'Azure Container Instance
Un regard sur Jenkins, OpenJDK 8 et Java 11
Après avoir vérifié le problème de Montyhall avec Ruby, c'était une histoire que je pouvais bien comprendre et que je ne comprenais pas bien
Jetons un coup d'œil aux fonctions de la console de gestion Keycloak (édition administrateur)
[At Coder] Résolvez le problème ABC183 D avec Ruby
[At Coder] Résolvez le problème ABC182 D avec Ruby
Jetons un coup d'œil aux fonctions de la console de gestion de Keycloak (édition utilisateur), service de compte utilisateur