# Frenetic Array

## A canvas for logic and imagination.

You've seen it in the movies or read about it in the books: the Monty Hall Problem. The premise is such: you are on a game show. There's three doors, behind one is a prize. Behind the other two is nothing besides disappointment. You pick an arbitrary door. The game host, Monty Hall, opens one of the other doors and reveals that there is no prize behind it. Keeping the other two doors closed, he asks you if you would like to switch your choice or remain with your original pick. What should you do? Benc Campbell has a solution.

You're meaning to tell me that if I switch mid-game, an offer by the man who set up all the doors and the respective prizes, I would have a better chance of winning? How is this possible? Seems a bit counterintuitive. Seems almost wrong. Fortunately, we can test this with a simple program.

import Darwin // for arc4random_uniform

func random(from from: Int, to: Int, except: Array<Int>? = nil) -> Int {
let number = Int(arc4random_uniform(UInt32(to - from + 1))) + from // produce bounds, +1 to make inclusive

if except != nil && except?.indexOf(number) != nil {
return random(from: from, to: to, except: except) // recursively call until you find the a number that doesn't contain the value
}

return number
}

// returns if you won when you stayed and switched, respectively
func montyHall(doors: Int) -> (Bool, Bool) {
let originalDoor = random(from: 1, to: doors) // Your original choice
let correctDoor = random(from: 1, to: doors) // The winning choice.

let revealedDoor = random(from: 1, to: doors, except: [correctDoor, originalDoor]) // The door the judge reveals
let switchedDoor = random(from: 1, to: doors, except: [revealedDoor, originalDoor]) // Supposing you switched, you woudl

return (originalDoor == correctDoor, switchedDoor == correctDoor)
}

let testValues = [100, 1_000, 10_000, 100_000, 1_000_000, 1_000_000]
let actualNumberOfDoors = 3

for value in testValues {
var stayingCounter = 0, switchingCounter = 0

for _ in 0...value {
let (stayedWon, switchedWon) = montyHall(actualNumberOfDoors)
if stayedWon { stayingCounter += 1 }
if switchedWon { switchingCounter += 1 }
}

print("Test Case: \(value). Staying Won: \(stayingCounter), Switching Won: \(switchingCounter)")
}


There's no tricks in the code. No gimmicks. So, the results?

Input Staying Won Switching Won
100 42 58
1000 344 656
10000 3289 6711
100000 33203 66797
1000000 333178 666822
10000000 3335146 6664854

It appears that Ben1 was right. Taking the limit as the input get higher, switching won roughly 66% of the time — compared that to the original 33% you got before you were given the option to switch doors. So, how is this possible? I'll explain.

For simplicity, suppose the prize is behind door A out of doors {A, B, C}. The argument can be made for any initial door, but A makes it easier. At this point, you have $\frac{1}{3}$ chance of picking the prize no matter what you pick. If you pick door A, the door which contains the prize, the host will definitely want you to change so he will offer you either door B or C. Now suppose you choose a door without the prize, either door B or C. The host has no choice but to eliminate the door without the prize. Meaning if you switch, you have the winning door.

So, why 66%? Computationally, if you always switch and you picked the wrong door initially, your switch will win every time. There's two incorrect choices out of three, meaning $\frac{2}{3}$ of the time you will win.