Which produces the following output

Runs  : 1000
Win   : 680  Percentage win  : 68.0
Loose : 320  Percentage Loose: 32.0

declare
  Runs  integer := 10000;
  Doors integer := 3;

  function RunMonteHaul
  (
  Runs    in  integer,
  MaxDoor in  integer,
  Swap    in  boolean
  )
  return integer
  is
    Prize     integer;
    OtherDoor integer;
    MyDoor    integer;
    Wins      integer := 0;
    i integer;
    j integer;
  begin

    for i in 1 .. Runs loop
      Prize := dbms_random.value(1,MaxDoor);
      MyDoor := dbms_random.value(1,MaxDoor);
      if Prize = MyDoor then
        if Prize = MaxDoor then
          OtherDoor := 1;
        else
          OtherDoor := MaxDoor;
        end if;
      else
        OtherDoor := Prize;
      end if;
      if Swap then
        MyDoor := OtherDoor;
      end if;
      if MyDoor = Prize then
        Wins := Wins + 1;
      end if;
    end loop;
    return Wins;
  end RunMonteHaul;
begin
    dbms_output.put_line('Runs  ' || Runs);
    dbms_output.put_line('Doors ' || Doors);
    dbms_output.put_line('Swap Wins    ' || RunMonteHaul(Runs,Doors,true));
    dbms_output.put_line('No Swap Wins ' || RunMonteHaul(Runs,Doors,false));
end;

This produces the output

Runs  10000
Doors 3
Swap Wins    6290
No Swap Wins 3725

Runs  10000
Doors 10000
Swap Wins    9999
No Swap Wins 1

Originally I was using list comprehension to generate a list of random numbers (to indicate which door the car is behind) and keeping the contestant’s choice constant (always picking door number 1), but I realized it might be slightly faster to randomize the contestant’s choice and assume the car is always located behind door number 1 – simply using the list as a looping mechanism.

import random
trials = 100000
print "Switching will win: %2.2f%% of the time" % (len(filter(lambda trial: random.randint(1, 3) != 1, xrange(trials))) / float(trials) * 100)

Lots of fun – thanks!

-Andy

#!/usr/bin/env python

# code for the monty hall problem
# written by Mark VandeWettering as a challenge on
# the programming praxis website.

import random

NTRIALS=10000

def trial(switch=False):
        # pick a random door...
        door = random.randint(1, 3)
        guess = random.randint(1, 3)
        if not switch:
            return door == guess
        else:
            # slightly clever, but the only way that you
            # lose is if you were lucky enough (or unlucky
            # enough) to guess the right door in the first
            # place.   This gives away the entire problem.
            return door != guess

cnt_noswitch = 0
cnt_switch = 0

for x in range(NTRIALS):
    if trial():
        cnt_noswitch = cnt_noswitch + 1
    if trial(switch=True):
        cnt_switch = cnt_switch + 1

print "By not switching, you won %d/%d rounds." % (cnt_noswitch, NTRIALS)
print "By switching, you won %d/%d rounds." % (cnt_switch, NTRIALS)
if cnt_switch > cnt_noswitch:
        print "It appears you should switch."
else:
        print "It appears you should not switch."

#!r6rs

(import (rnrs)
        (srfi :27))

(define (create-game) ; false = goat, true = car
  (let ((v (make-vector 3 #f)))
    (vector-set! v (random-integer 3) #t)
    v))

(define (player-choice) (random-integer 3))

(define (host-choice g p) ; host always chooses a goat
  (case p
    ((0) (if (vector-ref g 1) 2 1))
    ((1) (if (vector-ref g 0) 2 0))
    ((2) (if (vector-ref g 0) 1 0))))

(define (switch p h)
  (case (+ p h)
    ((1) 2)
    ((2) 1)
    ((3) 0)))

(define (run-test n)
  (let loop ((wins 0) (total 0))
    (if (= total n) (/ wins total)
        (let* ((g (create-game))
               (p (player-choice))
               (h (host-choice g p))
               (s (switch p h)))
          (if (vector-ref g s)
              (loop (+ wins 1) (+ total 1))
              (loop wins (+ total 1)))))))

(display (inexact (run-test 1000000)))

=> 0.66756