vendor/rand/examples/monty-hall.rs

   1 // Copyright 2018 Developers of the Rand project.
   2 // Copyright 2013-2018 The Rust Project Developers.
   3 //
   4 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   5 // https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   6 // <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
   7 // option. This file may not be copied, modified, or distributed
   8 // except according to those terms.
   9
  10 //! ## Monty Hall Problem
  11 //!
  12 //! This is a simulation of the [Monty Hall Problem][]:
  13 //!
  14 //! > Suppose you're on a game show, and you're given the choice of three doors:
  15 //! > Behind one door is a car; behind the others, goats. You pick a door, say
  16 //! > No. 1, and the host, who knows what's behind the doors, opens another
  17 //! > door, say No. 3, which has a goat. He then says to you, "Do you want to
  18 //! > pick door No. 2?" Is it to your advantage to switch your choice?
  19 //!
  20 //! The rather unintuitive answer is that you will have a 2/3 chance of winning
  21 //! if you switch and a 1/3 chance of winning if you don't, so it's better to
  22 //! switch.
  23 //!
  24 //! This program will simulate the game show and with large enough simulation
  25 //! steps it will indeed confirm that it is better to switch.
  26 //!
  27 //! [Monty Hall Problem]: https://en.wikipedia.org/wiki/Monty_Hall_problem
  28
  29 #![cfg(feature = "std")]
  30
  31 use rand::distributions::{Distribution, Uniform};
  32 use rand::Rng;
  33
  34 struct SimulationResult {
  35     win: bool,
  36     switch: bool,
  37 }
  38
  39 // Run a single simulation of the Monty Hall problem.
  40 fn simulate<R: Rng>(random_door: &Uniform<u32>, rng: &mut R) -> SimulationResult {
  41     let car = random_door.sample(rng);
  42
  43     // This is our initial choice
  44     let mut choice = random_door.sample(rng);
  45
  46     // The game host opens a door
  47     let open = game_host_open(car, choice, rng);
  48
  49     // Shall we switch?
  50     let switch = rng.gen();
  51     if switch {
  52         choice = switch_door(choice, open);
  53     }
  54
  55     SimulationResult {
  56         win: choice == car,
  57         switch,
  58     }
  59 }
  60
  61 // Returns the door the game host opens given our choice and knowledge of
  62 // where the car is. The game host will never open the door with the car.
  63 fn game_host_open<R: Rng>(car: u32, choice: u32, rng: &mut R) -> u32 {
  64     use rand::seq::SliceRandom;
  65     *free_doors(&[car, choice]).choose(rng).unwrap()
  66 }
  67
  68 // Returns the door we switch to, given our current choice and
  69 // the open door. There will only be one valid door.
  70 fn switch_door(choice: u32, open: u32) -> u32 {
  71     free_doors(&[choice, open])[0]
  72 }
  73
  74 fn free_doors(blocked: &[u32]) -> Vec<u32> {
  75     (0..3).filter(|x| !blocked.contains(x)).collect()
  76 }
  77
  78 fn main() {
  79     // The estimation will be more accurate with more simulations
  80     let num_simulations = 10000;
  81
  82     let mut rng = rand::thread_rng();
  83     let random_door = Uniform::new(0u32, 3);
  84
  85     let (mut switch_wins, mut switch_losses) = (0, 0);
  86     let (mut keep_wins, mut keep_losses) = (0, 0);
  87
  88     println!("Running {} simulations...", num_simulations);
  89     for _ in 0..num_simulations {
  90         let result = simulate(&random_door, &mut rng);
  91
  92         match (result.win, result.switch) {
  93             (true, true) => switch_wins += 1,
  94             (true, false) => keep_wins += 1,
  95             (false, true) => switch_losses += 1,
  96             (false, false) => keep_losses += 1,
  97         }
  98     }
  99
 100     let total_switches = switch_wins + switch_losses;
 101     let total_keeps = keep_wins + keep_losses;
 102
 103     println!(
 104         "Switched door {} times with {} wins and {} losses",
 105         total_switches, switch_wins, switch_losses
 106     );
 107
 108     println!(
 109         "Kept our choice {} times with {} wins and {} losses",
 110         total_keeps, keep_wins, keep_losses
 111     );
 112
 113     // With a large number of simulations, the values should converge to
 114     // 0.667 and 0.333 respectively.
 115     println!(
 116         "Estimated chance to win if we switch: {}",
 117         switch_wins as f32 / total_switches as f32
 118     );
 119     println!(
 120         "Estimated chance to win if we don't: {}",
 121         keep_wins as f32 / total_keeps as f32
 122     );
 123 }