Do you remember that scene from the movie 21 where Kevin Spacey gave our protagonist Ben the game show host problem?

What Kevin Spacey described is known as the Monty Hall problem. It became famous as a question from a reader’s letter to Marilyn vos Savant’s “Ask Marilyn” column in Parade magazine in 1990.

Marilyn’s answer caused quite a bit of controversy at the time and whilst I don’t understand the formal mathematical proof, it’s a problem that can be easily proved through simulations.

## Simulation with F#

First, let’s set up a few types to represent the problem domain:

Pretty self-explanatory here:

- behind every
*Door*is a*Prize*; - the
*Prize*is either a*Car*or a*Goat*; - you
*Win*if you get the*Car*in the end, otherwise you*Lose*

When you start a new game you always have three doors, arranged in some random order.

After you had given your initial choice, the game show host will reveal one of the doors that has a *Goat?.*

Here we have a function that takes in the *doors *and the player’s initial *choice*; and return the index of a *door *that:

- the player didn’t choose; and
- has a goat

Putting it together, we have a function that takes in the *doors* as well as the player’s *strategy* and return whether the player *Win *or *Lose *at the end of the game.

From the code above you can guess the type signature of the *strategy *function to be ** int –> int –> int**. That is, it takes two integers – the player’s initial choice and the index of the door the host has revealed – and return the player’s final choice.

Now, given the two choices we have – to stay or to change, we can represent it with two strategies:

*strategyA*would stay with the player’s original choice;*strategyB*would change

We can now use these two functions to call *play *with.

*p.s. notice we have essentially implemented the **Strategy** pattern, but without all the boilerplates and interfaces and classes? With just functions! Isn’t that sweet?*

To be kinder to ourselves, let’s add another helper function that will take in our chosen *strategy *and run a simulation of 1000 games, and return the number of games that we have won with this strategy:

Finally, let’s run our simulations and see how the two strategies perform.

Running this simulation over and over, *strategyB *consistently outperforms *strategyA *by roughly 2-to-1, which is exactly what we expected.

You can also just run the simulation yourself on **.Net Fiddle **here, just click the **Run** button at the top.

## Improving our code

Whilst the above is sufficient for its purpose and it’s a pretty short solution, there’re couple of things that can be improved in hindsight:

- player’s choice – to
*Stay*, or*Change*– is not explicitly represented in the domain; - whilst a
*Change*can only lead to one outcome – changing to the door that isn’t revealed nor initially chosen – it is expressed implicitly by the logic in*strategyB*; - if we were to introduce another strategy (e.g. decide to stay or change randomly) then we’d have to duplicate the logic for change.

To make these improvements is really easy. We can start by adding a type to present the two choices available to the player:

Then we can update the *play *function to work with it:

So now, our strategy implementations become much simpler:

Again, you can try out this updated version on **.Net Fiddle **here. It also includes a ‘random’ strategy which chooses to *Stay* or *Change *using the *rand* function we created earlier.

There are other things we can improve still. For instance, how do we encapsulate the constraint of having only 3 doors as part of our model?

This way, we can eliminate another invalid state using the type system. I’ll leave that as a teaser to you and feel free to share your solution in the comments!