Monty Hall problem: Difference between revisions
→{{header|IS-BASIC}}
m (dead link -> full ref) |
|||
| (96 intermediate revisions by 38 users not shown) | |||
Line 1:
{{task|Discrete math}}
[[Category:Games]]
[[Category:Probability and statistics]]
[[File:Monte_Hall_problem.jpg|600px||right]]
Suppose you're on a game show and you're given the choice of three doors.
Behind one door is a car; behind the others, goats.
The car and the goats were placed randomly behind the doors before the show.
;Rules of the game:
After you have chosen a door, the door remains closed for the time being.
The game show host, Monty Hall, who knows what is behind the doors, now has to open one of the two remaining doors, and the door he opens must have a goat behind it.
If both remaining doors have goats behind them, he chooses one randomly.
After Monty Hall opens a door with a goat, he will ask you to decide whether you want to stay with your first choice or to switch to the last remaining door.
Imagine that you chose Door 1 and the host opens Door 3, which has a goat.
He then asks you "Do you want to switch to Door Number 2?"
;The question:
Is it to your advantage to change your choice?
;Note:
The player may initially choose any of the three doors (not just Door 1), that the host opens a different door revealing a goat (not necessarily Door 3), and that he gives the player a second choice between the two remaining unopened doors.
;Task:
Run random simulations of the [[wp:Monty_Hall_problem|Monty Hall]] game. Show the effects of a strategy of the contestant always keeping his first guess so it can be contrasted with the strategy of the contestant always switching his guess.
Simulate at least a thousand games using three doors for each strategy <u>and show the results</u> in such a way as to make it easy to compare the effects of each strategy.
;References:
:* Stefan Krauss, X. T. Wang, "The psychology of the Monty Hall problem: Discovering psychological mechanisms for solving a tenacious brain teaser.", Journal of Experimental Psychology: General, Vol 132(1), Mar 2003, 3-22 [https://doi.org/10.1037/0096-3445.132.1.3 DOI: 10.1037/0096-3445.132.1.3]
:* A YouTube video: [https://www.youtube.com/watch?v=4Lb-6rxZxx0 Monty Hall Problem - Numberphile].
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">V stay = 0
V sw = 0
L 1000
V lst = [1, 0, 0]
random:shuffle(&lst)
V ran = random:(3)
V user = lst[ran]
lst.pop(ran)
V huh = 0
L(i) lst
I i == 0
lst.pop(huh)
L.break
huh++
I user == 1
stay++
I lst[0] == 1
sw++
print(‘Stay = ’stay)
print(‘Switch = ’sw)</syntaxhighlight>
=={{header|8086 Assembly}}==
<syntaxhighlight lang="asm">time: equ 2Ch ; MS-DOS syscall to get current time
puts: equ 9 ; MS-DOS syscall to print a string
cpu 8086
bits 16
org 100h
section .text
;;; Initialize the RNG with the current time
mov ah,time
int 21h
mov di,cx ; RNG state is kept in DI and BP
mov bp,dx
mov dx,sw ; While switching doors,
mov bl,1
call simrsl ; run simulations,
mov dx,nsw ; While not switching doors,
xor bl,bl ; run simulations.
;;; Print string in DX, run 65536 simulations (according to BL),
;;; then print the amount of cars won.
simrsl: mov ah,puts ; Print the string
int 21h
xor cx,cx ; Run 65536 simulations
call simul
mov ax,si ; Print amount of cars
mov bx,number ; String pointer
mov cx,10 ; Divisor
.dgt: xor dx,dx ; Divide AX by ten
div cx
add dl,'0' ; Add ASCII '0' to the remainder
dec bx ; Move string pointer backwards
mov [bx],dl ; Store digit in string
test ax,ax ; If quotient not zero,
jnz .dgt ; calculate next digit.
mov dx,bx ; Print string starting at first digit
mov ah,puts
int 21h
ret
;;; Run CX simulations.
;;; If BL = 0, don't switch doors, otherwise, always switch
simul: xor si,si ; SI is the amount of cars won
.loop: call door ; Behind which door is the car?
xchg dl,al ; DL = car door
call door ; Which door does the contestant choose?
xchg ah,al ; AH = contestant door
.monty: call door ; Which door does Monty open?
cmp al,dl ; It can't be the door with the car,
je .monty
cmp al,ah ; or the door the contestant picked.
je .monty
test bl,bl ; Will the contestant switch doors?
jz .nosw
xor ah,al ; If so, he switches
.nosw: cmp ah,dl ; Did he get the car?
jne .next
inc si ; If so, add a car
.next: loop .loop
ret
;;; Generate a pseudorandom byte in AL using "X ABC" method
;;; Use it to select a door (1,2,3).
door: xchg bx,bp ; Load RNG state into byte-addressable
xchg cx,di ; registers.
.loop: inc bl ; X++
xor bh,ch ; A ^= C
xor bh,bl ; A ^= X
add cl,bh ; B += A
mov al,cl ; C' = B
shr al,1 ; C' >>= 1
add al,ch ; C' += C
xor al,bh ; C' ^= A
mov ch,al ; C = C'
and al,3 ; ...but we only want the last two bits,
jz .loop ; and if it was 0, get a new random number.
xchg bx,bp ; Restore the registers
xchg cx,di
ret
section .data
sw: db 'When switching doors: $'
nsw: db 'When not switching doors: $'
db '*****'
number: db 13,10,'$'</syntaxhighlight>
{{out}}
<pre>When switching doors: 42841
When not switching doors: 22395</pre>
=={{header|ActionScript}}==
<
import flash.display.Sprite;
Line 49 ⟶ 192:
}
}
}</
Output:
<pre>Switching wins 18788 times. (62.626666666666665%)
Line 55 ⟶ 198:
=={{header|Ada}}==
<
with Ada.Text_Io; use Ada.Text_Io;
Line 130 ⟶ 273:
Put_Line("%");
end Monty_Stats;</
Results
<pre>Stay : count 34308 = 34.31%
Line 141 ⟶ 284:
{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}
{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}
<
PROC brand = (INT n)INT: 1 + ENTIER (n * random);
Line 194 ⟶ 337:
print(("Changing: ", percent(change winning), new line ));
print(("New random choice: ", percent(random winning), new line ))
)</
Sample output:
<pre>
Line 201 ⟶ 344:
New random choice: 50.17%
</pre>
=={{header|APL}}==
<
[1] ⍝0: Monthy Hall problem
[2] ⍝1: http://rosettacode.org/wiki/Monty_Hall_problem
Line 216 ⟶ 360:
[12] ⎕←'Swap: ',(2⍕100×(swap÷runs)),'% it''s a car'
[13] ⎕←'Stay: ',(2⍕100×(stay÷runs)),'% it''s a car'
∇</
<pre>
Run 100000
Line 222 ⟶ 366:
Stay: 33.46% it's a car
</pre>
=={{header|Arturo}}==
{{trans|Nim}}
<syntaxhighlight lang="rebol">stay: 0
swit: 0
loop 1..1000 'i [
lst: shuffle new [1 0 0]
rand: random 0 2
user: lst\[rand]
remove 'lst rand
huh: 0
loop lst 'i [
if zero? i [
remove 'lst huh
break
]
huh: huh + 1
]
if user=1 -> stay: stay+1
if and? [0 < size lst] [1 = first lst] -> swit: swit+1
]
print ["Stay:" stay]
print ["Switch:" swit]</syntaxhighlight>
{{out}}
<pre>Stay: 297
Switch: 549</pre>
=={{header|AutoHotkey}}==
<
Iterations = 1000
Loop, %Iterations%
Line 257 ⟶ 435:
Mode := Mode = 2 ? 2*rand - 1: Mode
Return, Mode = 1 ? 6 - guess - show = actual : guess = actual
}</
Sample output:
<pre>
Line 270 ⟶ 448:
=={{header|AWK}}==
<
# Monty Hall problem
Line 326 ⟶ 504:
simulate(RAND)
}</
Sample output:
<
Monty Hall problem simulation:
Line 336 ⟶ 514:
Algorithm switch: prize count = 6655, = 66.55%
Algorithm random: prize count = 4991, = 49.91%
bash$</
=={{header|BASIC}}==
==={{header|ANSI BASIC}}===
{{trans|XPL0}}
{{works with|Decimal BASIC}}
<syntaxhighlight lang="basic">
100 PROGRAM MontyHallProblem
110 DEF NGames = 10000
120 RANDOMIZE
130 LET NWins = 0
140 FOR Game = 0 TO NGames
150 IF IsGameWon(0) <> 0 THEN LET NWins = NWins + 1
160 NEXT Game
170 PRINT "NOT switching doors wins car in ";
180 PRINT USING "##.#": NWins / NGames * 100;
190 PRINT "% of games."
200 LET NWins = 0
210 FOR Game = 0 TO NGames
220 IF IsGameWon(1) <> 0 THEN LET NWins = NWins + 1
230 NEXT Game
240 PRINT "But switching doors wins car in ";
250 PRINT USING "##.#": NWins / NGames * 100;
260 PRINT "% of games."
270 END
280 REM ***
290 EXTERNAL FUNCTION IsGameWon(Sw)
300 REM Play one game.
310 REM Switching if and only if Sw <> 0.
320 REM Returns 1 if the game is won, 0 otherwise.
330 LET Car = INT(RND * 3) ! Randomly place car behind a door.
340 LET Player0 = INT(RND * 3) ! Player randomly chooses a door.
350 DO
360 LET Monty = INT(RND * 3) ! Monty opens door revealing a goat.
370 LOOP UNTIL (Monty <> Car) AND (Monty <> Player0)
380 IF Sw <> 0 THEN ! Player switches TO remaining door.
390 DO
400 LET Player = INT(RND * 3)
410 LOOP UNTIL (Player <> Player0) AND (Player <> Monty)
420 ELSE
430 LET Player = Player0 ! Player sticks with original door.
440 END IF
450 IF Player = Car THEN
460 LET IsGameWon = 1
470 ELSE
480 LET IsGameWon = 0
490 END IF
500 END FUNCTION
</syntaxhighlight>
{{out}}(example)
<pre>
NOT switching doors wins car in 32.3% of games.
But switching doors wins car in 67.3% of games.
</pre>
==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">
numTiradas = 1000000
permanece = 0
cambia = 0
for i = 1 to numTiradas
pta_coche = int(rand * 3) + 1
pta_elegida = int(rand * 3) + 1
if pta_coche <> pta_elegida then
pta_montys = 6 - pta_coche - pta_elegida
else
do
pta_montys = int(Rand * 3) + 1
until pta_montys <> pta_coche
end if
# manteenr elección
if pta_coche = pta_elegida then permanece += 1
# cambiar elección
if pta_coche = 6 - pta_montys - pta_elegida then cambia +=1
next i
print "Si mantiene su elección, tiene un "; permanece / numTiradas * 100 ;"% de probabilidades de ganar."
print "Si cambia, tiene un "; cambia / numTiradas * 100; "% de probabilidades de ganar."
end
</syntaxhighlight>
==={{header|BBC BASIC}}===
<syntaxhighlight lang="bbcbasic"> total% = 10000
FOR trial% = 1 TO total%
prize_door% = RND(3) : REM. The prize is behind this door
guess_door% = RND(3) : REM. The contestant guesses this door
IF prize_door% = guess_door% THEN
REM. The contestant guessed right, reveal either of the others
reveal_door% = RND(2)
IF prize_door% = 1 reveal_door% += 1
IF prize_door% = 2 AND reveal_door% = 2 reveal_door% = 3
ELSE
REM. The contestant guessed wrong, so reveal the non-prize door
reveal_door% = prize_door% EOR guess_door%
ENDIF
stick_door% = guess_door% : REM. The sticker doesn't change his mind
swap_door% = guess_door% EOR reveal_door% : REM. but the swapper does
IF stick_door% = prize_door% sticker% += 1
IF swap_door% = prize_door% swapper% += 1
NEXT trial%
PRINT "After a total of ";total%;" trials,"
PRINT "The 'sticker' won ";sticker%;" times (";INT(sticker%/total%*100);"%)"
PRINT "The 'swapper' won ";swapper%;" times (";INT(swapper%/total%*100);"%)"</syntaxhighlight>
Output:
<pre>
After a total of 10000 trials,
The 'sticker' won 3379 times (33%)
The 'swapper' won 6621 times (66%)
</pre>
==={{header|Euphoria}}===
<syntaxhighlight lang="euphoria">integer switchWins, stayWins
switchWins = 0
stayWins = 0
integer winner, choice, shown
for plays = 1 to 10000 do
winner = rand(3)
choice = rand(3)
while 1 do
shown = rand(3)
if shown != winner and shown != choice then
exit
end if
end while
stayWins += choice = winner
switchWins += 6-choice-shown = winner
end for
printf(1, "Switching wins %d times.\n", switchWins)
printf(1, "Staying wins %d times.\n", stayWins)
</syntaxhighlight>
{{out}} (sample)
<pre>
Switching wins 6697 times.
Staying wins 3303 times.
</pre>
==={{header|FreeBASIC}}===
<syntaxhighlight lang="freebasic">
' version 19-01-2019
' compile with: fbc -s console
Const As Integer max = 1000000
Randomize Timer
Dim As UInteger i, car_door, chosen_door, montys_door, stay, switch
For i = 1 To max
car_door = Fix(Rnd * 3) + 1
chosen_door = Fix(Rnd * 3) + 1
If car_door <> chosen_door Then
montys_door = 6 - car_door - chosen_door
Else
Do
montys_door = Fix(Rnd * 3) + 1
Loop Until montys_door <> car_door
End If
'Print car_door,chosen_door,montys_door
' stay
If car_door = chosen_door Then stay += 1
' switch
If car_door = 6 - montys_door - chosen_door Then switch +=1
Next
Print Using "If you stick to your choice, you have a ##.## percent" _
+ " chance to win"; stay / max * 100
Print Using "If you switched, you have a ##.## percent chance to win"; _
switch / max * 100
' empty keyboard buffer
While InKey <> "" : Wend
Print : Print "hit any key to end program"
Sleep
End
</syntaxhighlight>
{{out}}
<pre>
If you stick to your choice, you have a 33.32 percent chance to win
If you switched, you have a 66.68 percent chance to win
</pre>
=={{header|FutureBasic}}==
Translated from ANSI BASIC
<syntaxhighlight lang="futurebasic">
// Monty Hall problem
// May 2024 - Rich Love
local fn IsGameWon(Sw as int) as bool
REM Play one game.
REM Switching if and only if Sw <> 0.
REM Returns 1 if the game is won, 0 otherwise.
short Car = INT(RND(3)) //Randomly place car behind a door.
short Player0 = INT(RND(3)) // Player randomly chooses a door.
short Monty
short IsGameWon
short Player
DO
Monty = INT(RND(3)) // Monty opens door revealing a goat.
UNTIL (Monty <> Car) AND (Monty <> Player0)
380
IF Sw <> 0 // Player switches TO remaining door.
DO
Player = INT(RND(3))
UNTIL (Player <> Player0) AND (Player <> Monty)
Monty = INT(RND(3))
ELSE
Player = Player0 // Player sticks with original door.
END IF
IF Player = Car
IsGameWon = 1
ELSE
IsGameWon = 0
END IF
END fn = IsgameWon
_NGames = 10000
float NWins = 0
short Game
FOR Game = 0 TO _NGames
IF fn IsGameWon(0) <> 0 THEN NWins = NWins + 1
NEXT Game
PRINT "NOT switching doors wins car in ";
PRINT USING "##.##" ; NWins / 100 ;
PRINT " % of games."
NWins = 0
FOR Game = 0 TO _NGames
IF fn IsGameWon(1) <> 0 THEN NWins = NWins + 1
NEXT Game
PRINT "But switching doors wins car in ";
PRINT USING "##.##" ; NWins / _NGames * 100;
PRINT " % of games."
handleevents
</syntaxhighlight>
{{output}}
<pre>
NOT switching doors wins car in 33.48% of games.
But switching doors wins car in 67.15% of games.
</pre>
==={{header|IS-BASIC}}===
<syntaxhighlight lang="is-basic">100 PROGRAM "MontyH.bas"
110 RANDOMIZE
120 LET NUMGAMES=1000
130 LET CHANGING,NOTCHANGING=0
140 FOR I=0 TO NUMGAMES-1
150 LET PRIZEDOOR=RND(3)+1:LET CHOSENDOOR=RND(3)+1
160 IF CHOSENDOOR=PRIZEDOOR THEN
170 LET NOTCHANGING=NOTCHANGING+1
180 ELSE
190 LET CHANGING=CHANGING+1
200 END IF
210 NEXT
220 PRINT "Num of games:";NUMGAMES
230 PRINT "Wins not changing doors:";NOTCHANGING,NOTCHANGING/NUMGAMES*100;"% of total."
240 PRINT "Wins changing doors:",CHANGING,CHANGING/NUMGAMES*100;"% of total."</syntaxhighlight>
==={{header|Liberty BASIC}}===
{{trans|Quick BASIC}}
{{works with|Just BASIC}}
<syntaxhighlight lang="lb">
DIM doors(3) '0 is a goat, 1 is a car
total = 10000 'set desired number of iterations
switchWins = 0
stayWins = 0
FOR plays = 1 TO total
winner = INT(RND(1) * 3) + 1
doors(winner) = 1'put a winner in a random door
choice = INT(RND(1) * 3) + 1'pick a door, any door
DO
shown = INT(RND(1) * 3) + 1
'don't show the winner or the choice
LOOP WHILE doors(shown) = 1 OR shown = choice
if doors(choice) = 1 then
stayWins = stayWins + 1 'if you won by staying, count it
else
switchWins = switchWins + 1'could have switched to win
end if
doors(winner) = 0 'clear the doors for the next test
NEXT
PRINT "Result for ";total;" games."
PRINT "Switching wins "; switchWins; " times."
PRINT "Staying wins "; stayWins; " times."
</syntaxhighlight>
{{out}} (example)
<pre>
Result for 10000 games.
Switching wins 6634 times.
Staying wins 3366 times.</pre>
==={{header|Minimal BASIC}}===
{{trans|ANSI BASIC}}
{{works with|BASICA}}
<syntaxhighlight lang="basic">
10 REM Monty Hall problem
20 LET N = 10000
30 RANDOMIZE
40 LET W = 0
50 FOR G = 0 TO N
60 LET S = 0
70 GOSUB 230
80 IF V = 0 THEN 100
90 LET W = W+1
100 NEXT G
110 PRINT "NOT switching doors wins car in";
120 PRINT W/N*100; "per cent of games."
130 LET W = 0
140 FOR G = 0 TO N
150 LET S = 1
160 GOSUB 230
170 IF V = 0 THEN 190
180 LET W = W+1
190 NEXT G
200 PRINT "But switching doors wins car in";
210 PRINT W/N*100; "per cent of games."
220 END
230 REM ** Is game won?
240 REM Play one game.
250 REM Switching if and only if S <> 0.
260 REM Randomly place car behind a door.
270 LET C = INT(RND*3)
280 REM Player randomly chooses a door.
290 LET P0 = INT(RND*3)
300 REM Monty opens door revealing a goat.
310 LET M = INT(RND*3)
320 IF M = C THEN 310
330 IF M = P0 THEN 310
340 IF S = 0 THEN 410
350 REM Player switches to remaining door.
360 LET P = INT(RND*3)
370 IF P = P0 THEN 360
380 IF P = M THEN 360
390 GOTO 430
400 REM Player sticks with original door.
410 LET P = P0
420 REM Victory?
430 IF P <> C THEN 460
440 LET V = 1
450 RETURN
460 LET V = 0
470 RETURN
</syntaxhighlight>
==={{header|PureBasic}}===
<syntaxhighlight lang="purebasic">Structure wins
stay.i
redecide.i
EndStructure
#goat = 0
#car = 1
Procedure MontyHall(*results.wins)
Dim Doors(2)
Doors(Random(2)) = #car
player = Random(2)
Select Doors(player)
Case #car
*results\redecide + #goat
*results\stay + #car
Case #goat
*results\redecide + #car
*results\stay + #goat
EndSelect
EndProcedure
OpenConsole()
#Tries = 1000000
Define results.wins
For i = 1 To #Tries
MontyHall(@results)
Next
PrintN("Trial runs for each option: " + Str(#Tries))
PrintN("Wins when redeciding: " + Str(results\redecide) + " (" + StrD(results\redecide / #Tries * 100, 2) + "% chance)")
PrintN("Wins when sticking: " + Str(results\stay) + " (" + StrD(results\stay / #Tries * 100, 2) + "% chance)")
Input()</syntaxhighlight>
Output:<pre>Trial runs for each option: 1000000
Wins when redeciding: 666459 (66.65% chance)
Wins when sticking: 333541 (33.35% chance)</pre>
==={{header|QuickBASIC}}===
{{works with|QuickBasic|4.5}}
{{trans|Java}}
<
DIM doors(3) '0 is a goat, 1 is a car
CLS
Line 359 ⟶ 935:
NEXT plays
PRINT "Switching wins"; switchWins; "times."
PRINT "Staying wins"; stayWins; "times."</
Output:
<pre>Switching wins 21805 times.
Staying wins 10963 times.</pre>
==={{header|Run BASIC}}===
{{trans|Quick BASIC}}
{{works with|Just BASIC}}
<syntaxhighlight lang="runbasic">
input "Number of tries;";tries ' gimme the number of iterations
FOR plays = 1 TO tries
winner = INT(RND(1) * 3) + 1
doors(winner) = 1 'put a winner in a random door
choice = INT(RND(1) * 3) + 1 'pick a door please
[DO] shown = INT(RND(1) * 3) + 1
' ------------------------------------------
' don't show the winner or the choice
if doors(shown) = 1 then goto [DO]
if shown = choice then goto [DO]
if doors(choice) = 1 then
stayWins = stayWins + 1 ' if you won by staying, count it
else
switchWins = switchWins + 1 ' could have switched to win
end if
doors(winner) = 0 'clear the doors for the next test
NEXT
PRINT " Result for ";tries;" games."
PRINT "Switching wins ";switchWins; " times."
PRINT " Staying wins ";stayWins; " times."</syntaxhighlight>
==={{header|Sinclair ZX81 BASIC}}===
Line 373 ⟶ 974:
switcher wins;</pre>
but I take it that the point is to demonstrate the outcome to people who may <i>not</i> see that that's what is going on. I have therefore written the program in a deliberately naïve style, not assuming anything.
<
20 PRINT "STICK","SWITCH"
30 LET STICK=0
Line 386 ⟶ 987:
120 IF GUESS=CAR THEN LET STICK=STICK+1
130 IF NEWGUESS=CAR THEN LET SWITCH=SWITCH+1
140 NEXT I
150 PRINT AT 2,0;STICK,SWITCH</syntaxhighlight>
{{out}}
<pre> WINS IF YOU
Line 393 ⟶ 994:
341 659</pre>
==={{header|
<syntaxhighlight lang="qbasic">OPTION BASE 0
DIM puertas(3)
LET numTiradas = 1000000
FOR i = 0 TO numTiradas
LET pta_coche = INT(RND * 3) + 1
LET puertas(pta_coche) = 1
LET pta_elegida = INT(RND * 3) + 1
DO
LET pta_montys = INT(RND * 3) + 1
LOOP WHILE puertas(pta_montys) = 1 OR pta_montys = pta_elegida
IF puertas(pta_elegida) = 1 THEN
LET cambia = cambia + 1
ELSE
LET permanece = permanece + 1
END IF
LET puertas(pta_coche) = 0
NEXT i
PRINT "Cambiar gana el"; permanece / numTiradas * 100; "% de las veces."
PRINT "Mantenerse gana el"; cambia / numTiradas * 100; "% de las veces."
END</syntaxhighlight>
==={{header|Yabasic}}===
<syntaxhighlight lang="yabasic">
numTiradas = 1000000
for i = 1 to numTiradas
pta_coche = int(ran(3)) + 1
pta_elegida = int(ran(3)) + 1
if pta_coche <> pta_elegida then
pta_montys = 6 - pta_coche - pta_elegida
else
repeat
pta_montys = int(ran(3)) + 1
until pta_montys <> pta_coche
end if
// manteenr elección
if pta_coche = pta_elegida then permanece = permanece + 1 : fi
// cambiar elección
if pta_coche = 6 - pta_montys - pta_elegida then cambia = cambia + 1 : fi
next i
print "Si mantiene su eleccion, tiene un ", permanece / numTiradas * 100, "% de probabilidades de ganar."
print "Si cambia, tiene un ", cambia / numTiradas * 100, "% de probabilidades de ganar."
end
</syntaxhighlight>
=={{header|C}}==
<syntaxhighlight lang="c">//Evidence of the Monty Hall solution of marquinho1986 in C [github.com/marquinho1986]
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <math.h>
#define NumSim 1000000000 // one billion of simulations! using the Law of large numbers concept [https://en.wikipedia.org/wiki/Law_of_large_numbers]
void main() {
unsigned long int i,stay=0;
int ChosenDoor,WinningDoor;
bool door[3]={0,0,0};
srand(time(NULL)); //initialize random seed.
for(i=0;i<=NumSim;i++){
WinningDoor=rand() % 3; // choosing winning door.
ChosenDoor=rand() % 3; // selected door.
if(door[WinningDoor]=true,door[ChosenDoor])stay++;
door[WinningDoor]=false;
}
printf("\nAfter %lu games, I won %u by staying. That is %f%%. and I won by switching %lu That is %f%%",NumSim, stay, (float)stay*100.0/(float)i,abs(NumSim-stay),100-(float)stay*100.0/(float)i);
}
</syntaxhighlight>
Output of one run:
<pre>After
=={{header|C sharp|C#}}==
{{trans|Java}}
<
class Program
Line 490 ⟶ 1,119:
Console.Out.WriteLine("Switching wins " + switchWins + " times.");
}
}</
Sample output:
<pre>
Line 498 ⟶ 1,127:
=={{header|C++}}==
<
#include <cstdlib>
#include <ctime>
Line 554 ⟶ 1,183:
int wins_change = check(games, true);
std::cout << "staying: " << 100.0*wins_stay/games << "%, changing: " << 100.0*wins_change/games << "%\n";
}</
Sample output:
staying: 33.73%, changing: 66.9%
=={{header|Chapel}}==
'''Version 1''' : using task parallelism.
<syntaxhighlight lang="chapel">
use Random;
param doors: int = 3;
Line 611 ⟶ 1,243:
writeln( "Both methods are equal." );
}
</syntaxhighlight>
Sample output:
<pre>
Line 619 ⟶ 1,252:
</pre>
'''Version 2''' : using data parallelism.
<syntaxhighlight lang="chapel">
use Random;
config const numGames = 100_000_000;
var switch, stick: uint;
// have a separate RNG for each task; add together the results at the end
forall i in 1..numGames
with (var rand = new RandomStream(uint, parSafe = false), + reduce stick)
{
var chosen_door = rand.getNext() % 3;
var winner_door = rand.getNext() % 3;
if chosen_door == winner_door then
stick += 1;
}
// if you lost by sticking it means you would have won by switching
switch = numGames - stick;
writeln("Over ", numGames, " games:\n - switching wins ",
100.0*switch / numGames, "% of the time and\n - sticking wins ",
100.0*stick / numGames, "% of the time");
</syntaxhighlight>
Sample output:
<pre>
Over 1000000 games:
- switching wins 66.6937% of the time and
- sticking wins 33.3063% of the time
</pre>
=={{header|Clojure}}==
<
(:use [clojure.contrib.seq :only (shuffle)]))
Line 636 ⟶ 1,302:
(range times))]
(str "wins " wins " times out of " times)))
</syntaxhighlight>
<
staying: wins 337 times out of 1000
nil
Line 643 ⟶ 1,309:
switching: wins 638 times out of 1000
nil
</syntaxhighlight>
=={{header|COBOL}}==
{{works with|OpenCOBOL}}
<
PROGRAM-ID. monty-hall.
Line 735 ⟶ 1,401:
END PROGRAM get-rand-int.
END PROGRAM monty-hall.</
{{out}}
Line 744 ⟶ 1,410:
=={{header|ColdFusion}}==
<
function runmontyhall(num_tests) {
// number of wins when player switches after original selection
Line 785 ⟶ 1,451:
}
runmontyhall(10000);
</cfscript></
Output:
<pre>
Line 792 ⟶ 1,458:
=={{header|Common Lisp}}==
<
(let ((array (make-array 3
:element-type 'bit
Line 806 ⟶ 1,472:
(defun won? (array i)
(= 1 (bit array i)))</
<
for round = (make-round)
for initial = (random 3)
Line 824 ⟶ 1,490:
#1# 1/100))))))
Stay: 33.2716%
Switch: 66.6593%</
<
;Find out how often we win if we always switch
(defun rand-elt (s)
Line 841 ⟶ 1,507:
(defun monty-trials (n)
(count t (loop for x from 1 to n collect (monty))))
</syntaxhighlight>
=={{header|D}}==
<
void main() {
Line 874 ⟶ 1,540:
writefln("Switching/Staying wins: %d %d", switchWins, stayWins);
}</
{{out}}
<pre>Switching/Staying wins: 66609 33391</pre>
Line 880 ⟶ 1,546:
=={{header|Dart}}==
The class Game attempts to hide the implementation as much as possible, the play() function does not use any specifics of the implementation.
<
class Game {
Line 962 ⟶ 1,628:
play(10000,false);
play(10000,true);
}</
<pre>playing without switching won 33.32%
playing with switching won 67.63%</pre>
=={{header|Delphi}}==
{{trans|C#}}
{{works with|Delphi|XE10}}
{{libheader| System.SysUtils}}
<syntaxhighlight lang="delphi">program MontyHall;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils;
const
numGames = 1000000; // Number of games to run
var
switchWins, stayWins, plays: Int64;
doors: array[0..2] of Integer;
i, winner, choice, shown: Integer;
begin
switchWins := 0;
stayWins := 0;
for plays := 1 to numGames do
begin
//0 is a goat, 1 is a car
for i := 0 to 2 do
doors[i] := 0;
//put a winner in a random door
winner := Random(3);
doors[winner] := 1;
//pick a door, any door
choice := Random(3);
//don't show the winner or the choice
repeat
shown := Random(3);
until (doors[shown] <> 1) and (shown <> choice);
//if you won by staying, count it
stayWins := stayWins + doors[choice];
//the switched (last remaining) door is (3 - choice - shown), because 0+1+2=3
switchWins := switchWins + doors[3 - choice - shown];
end;
WriteLn('Staying wins ' + IntToStr(stayWins) + ' times.');
WriteLn('Switching wins ' + IntToStr(switchWins) + ' times.');
end.
</syntaxhighlight>
{{out}}
<pre>Staying wins 333253 times.
Switching wins 666747 times.</pre>
=={{header|Dyalect}}==
{{trans|C#}}
<syntaxhighlight lang="dyalect">var switchWins = 0
var stayWins = 0
for plays in 0..1000000 {
var doors = [0 ,0, 0]
var winner = rnd(max: 3)
doors[winner] = 1
var choice = rnd(max: 3)
var shown = rnd(max: 3)
while doors[shown] == 1 || shown == choice {
shown = rnd(max: 3)
}
stayWins += doors[choice]
switchWins += doors[3 - choice - shown]
}
print("Staying wins \(stayWins) times.")
print("Switching wins \(switchWins) times.")</syntaxhighlight>
{{out}}
<pre>Staying wins 286889 times.
Switching wins 713112 times.</pre>
=={{header|EasyLang}}==
{{trans|FreeBASIC}}
<syntaxhighlight>
max = 1000000
for i = 1 to max
car_door = randint 3
chosen_door = randint 3
if car_door <> chosen_door
montys_door = 6 - car_door - chosen_door
else
repeat
montys_door = randint 3
until montys_door <> car_door
.
.
if car_door = chosen_door
stay += 1
.
if car_door = 6 - montys_door - chosen_door
switch += 1
.
.
print "If you stick to your choice, you have a " & stay / max * 100 & " percent chance to win"
print "If you switched, you have a " & switch / max * 100 & " percent chance to win"
</syntaxhighlight>
{{out}}
<pre>
If you stick to your choice, you have a 33.36 percent chance to win
If you switched, you have a 66.64 percent chance to win
</pre>
=={{header|Eiffel}}==
<
note
description: "[
Line 1,281 ⟶ 2,066:
end
</syntaxhighlight>
{{out}}
<pre>
Line 1,301 ⟶ 2,086:
=={{header|Elixir}}==
<
def simulate(n) do
{stay, switch} = simulate(n, 0, 0)
Line 1,323 ⟶ 2,108:
end
MontyHall.simulate(10000)</
{{out}}
Line 1,333 ⟶ 2,118:
=={{header|Emacs Lisp}}==
{{trans|Picolisp}}
<syntaxhighlight lang="lisp">(defun montyhall (keep)
(let ((prize (random 3))
(choice (random 3)))
(if keep (= prize choice)
(/= prize choice))))
(let ((cnt 0))
(dotimes (i 10000)
(and (montyhall t) (setq cnt (1+ cnt))))
(
(let ((cnt 0))
(dotimes (i 10000)
(and (montyhall nil) (setq cnt (1+ cnt))))
(
{{out}}
Strategy keep: 34.410%
Strategy switch: 66.430%
=={{header|EMal}}==
<syntaxhighlight lang="emal">
type Prize
enum do int GOAT, CAR end
type Door
model
int id
Prize prize
new by int =id, Prize =prize do end
fun asText = text by block do return "(id:" + me.id + ", prize:" + me.prize.value + ")" end
end
type Player
model
Door choice
fun choose = void by List doors
me.choice = doors[random(3)]
end
end
type Monty
model
fun setPrize = void by List doors, Prize prize
doors[random(3)].prize = prize
end
end
type MontyHallProblem
int ITERATIONS = 1000000
Map counter = text%int[ "keep" => 0, "switch" => 0 ]
writeLine("Simulating " + ITERATIONS + " games:")
for int i = 0; i < ITERATIONS; i++
if i % 100000 == 0 do write(".") end
^|three numbered doors with no cars for now|^
List doors = Door[Door(1, Prize.GOAT), Door(2, Prize.GOAT), Door(3, Prize.GOAT)]
Monty monty = Monty() # set up Monty
monty.setPrize(doors, Prize.CAR) # Monty randomly sets the car behind one door
Player player = Player() # set up the player
player.choose(doors) # the player makes a choice
^|here Monty opens a door with a goat;
|behind the ones that are still closed there is a car and a goat,
|so that the player *always* wins by keeping or switching.
|^
counter[when(player.choice.prize == Prize.CAR, "keep", "switch")]++
end
writeLine()
writeLine(counter)
</syntaxhighlight>
{{out}}
<pre>
Simulating 1000000 games:
..........
[keep:332376,switch:667624]
</pre>
=={{header|Erlang}}==
<
-export([main/0]).
Line 1,388 ⟶ 2,219:
false -> OpenDoor
end.
</syntaxhighlight>
Sample Output:
<pre>Switching wins 66595 times.
Staying wins 33405 times.</pre>
=={{header|F_Sharp|F#}}==
I don't bother with having Monty "pick" a door, since you only win if you initially pick a loser in the switch strategy and you only win if you initially pick a winner in the stay strategy so there doesn't seem to be much sense in playing around the background having Monty "pick" doors. Makes it pretty simple to see why it's always good to switch.
<
let monty nSims =
let rnd = new Random()
Line 1,433 ⟶ 2,238:
let Wins (f:unit -> int) = seq {for i in [1..nSims] -> f()} |> Seq.sum
printfn "Stay: %d wins out of %d - Switch: %d wins out of %d" (Wins StayGame) nSims (Wins SwitchGame) nSims</
Sample Output:
<pre>Stay: 332874 wins out of 1000000 - Switch: 667369 wins out of 1000000</pre>
I had a very polite suggestion that I simulate Monty's "pick" so I'm putting in a version that does that. I compare the outcome with my original outcome and, unsurprisingly, show that this is essentially a noop that has no bearing on the output, but I (kind of) get where the request is coming from so here's that version...
<
let rnd = new Random()
let MontyPick winner pick =
Line 1,469 ⟶ 2,274:
let Wins (f:unit -> int) = seq {for i in [1..nSims] -> f()} |> Seq.sum
printfn "Stay: %d wins out of %d - Switch: %d wins out of %d" (Wins StayGame) nSims (Wins SwitchGame) nSims</
=={{header|Forth}}==
===version 1===
<syntaxhighlight lang="forth">include random.fs
variable stay-wins
Line 1,488 ⟶ 2,295:
cr switch-wins @ . [char] / emit . ." switching wins" ;
1000 trials</
or in iForth:
<
0 value switch-wins
Line 1,505 ⟶ 2,312:
dup 0 ?DO trial LOOP
CR stay-wins DEC. ." / " dup DEC. ." staying wins,"
CR switch-wins DEC. ." / " DEC. ." switching wins." ;</
With output:
Line 1,512 ⟶ 2,319:
33336877 / 100000000 staying wins,
66663123 / 100000000 switching wins. ok</pre>
===version 2===
{{works with|GNU Forth}}
While Forthers are known (and regarded) for always simplifying the problem, I think version 1 is missing the point here. The optimization can only be done if one already understands the game. For what it's worth, here is a simulation that takes all the turns of the game.
<syntaxhighlight lang="forth">require random.fs
here seed !
1000000 constant rounds
variable wins
variable car
variable firstPick
variable revealed
defer applyStrategy
: isCar ( u - f ) car @ = ;
: remaining ( u u - u ) 3 swap - swap - ;
: setup 3 random car ! ;
: choose 3 random firstPick ! ;
: otherGoat ( - u ) car @ firstPick @ remaining ;
: randomGoat ( - u ) car @ 1+ 2 random + 3 mod ;
: reveal firstPick @ isCar IF randomGoat ELSE otherGoat THEN revealed ! ;
: keep ( - u ) firstPick @ ;
: switch ( - u ) firstPick @ revealed @ remaining ;
: open ( u - f ) isCar ;
: play ( - f ) setup choose reveal applyStrategy open ;
: record ( f ) 1 and wins +! ;
: run 0 wins ! rounds 0 ?DO play record LOOP ;
: result wins @ 0 d>f rounds 0 d>f f/ 100e f* ;
: .result result f. '%' emit ;
' keep IS applyStrategy run ." Keep door => " .result cr
' switch IS applyStrategy run ." Switch door => " .result cr
bye</syntaxhighlight>
{{out}}
<pre>
Keep door => 33.2922 %
Switch door => 66.7207 %
</pre>
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<
IMPLICIT NONE
Line 1,560 ⟶ 2,406:
WRITE(*, "(A,F6.2,A)") "Chance of winning by switching is", real(switchcount)/trials*100, "%"
END PROGRAM MONTYHALL</
Sample Output
Chance of winning by not switching is 32.82%
Chance of winning by switching is 67.18%
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Monty_Hall_problem}}
'''Solution'''
The following program makes a given number of simulations. On each, three options are evaluated:
* If the player keeps his/her selection
* If the player randomly chooses between hs/her selection and the other (closed) door.
* If the player switches his/her selection
Finally, it shows the number of wins for each case.
[[File:Fōrmulæ - Monty Hall problem 01.png]]
[[File:Fōrmulæ - Monty Hall problem 02.png]]
[[File:Fōrmulæ - Monty Hall problem 03.png]]
It can be seen that:
* If the player keeps his/her selection, he/she wins around 1/3 of times
* If the player randomly chooses between his/her selection and the other (closed) door, he/she wins around 1/2 of times
* If the player switches his/her selection, he/she wins around 2/3 of times
The following variation shows the evolution of the probabilities for each case:
[[File:Fōrmulæ - Monty Hall problem 04.png]]
[[File:Fōrmulæ - Monty Hall problem 05.png]]
[[File:Fōrmulæ - Monty Hall problem 06.png]]
=={{header|Go}}==
<
import (
Line 1,591 ⟶ 2,471:
fmt.Printf("Keeper Wins: %d (%3.2f%%)",
keeperWins, (float32(keeperWins) / floatGames * 100))
}</
Output:
<pre>
Line 1,599 ⟶ 2,479:
=={{header|Haskell}}==
<
trials :: Int
Line 1,632 ⟶ 2,512:
percent n ++ "% of the time."
percent n = show $ round $
100 * (fromIntegral n) / (fromIntegral trials)</
{{libheader|mtl}}
With a <tt>State</tt> monad, we can avoid having to explicitly pass around the <tt>StdGen</tt> so often. <tt>play</tt> and <tt>cars</tt> can be rewritten as follows:
<
play :: Bool -> State StdGen Door
Line 1,657 ⟶ 2,537:
cars n switch g = (numcars, new_g)
where numcars = length $ filter (== Car) prize_list
(prize_list, new_g) = runState (replicateM n (play switch)) g</
Sample output (for either implementation):
<
The stay strategy succeeds 34% of the time.</
=={{header|HicEst}}==
<
DLG(NameEdit = plays, DNum=1, Button='Go')
Line 1,695 ⟶ 2,575:
WRITE(ClipBoard, Name) plays, switchWins, stayWins
END</
<
! plays=1E4; switchWins=6673; stayWins=3327;
! plays=1E5; switchWins=66811; stayWins=33189;
! plays=1E6; switchWins=667167; stayWins=332833;</
=={{header|Icon}} and {{header|Unicon}}==
<
rounds := integer(arglist[1]) | 10000
Line 1,720 ⟶ 2,600:
write("Strategy 2 'Switching' won ", real(strategy2) / rounds )
end</
Sample Output:<pre>Monty Hall simulation for 10000 rounds.
Line 1,727 ⟶ 2,607:
=={{header|Io}}==
<
switchWins := 0
doors := 3
Line 1,749 ⟶ 2,629:
.. "Keeping the same door won #{keepWins} times.\n"\
.. "Game played #{times} times with #{doors} doors.") interpolate println
</syntaxhighlight>
Sample output:<pre>Switching to the other door won 66935 times.
Keeping the same door won 33065 times.
Line 1,758 ⟶ 2,638:
The core of this simulation is picking a random item from a set
<
And, of course, we will be picking one door from three doors
<
But note that the simulation code should work just as well with more doors.
Line 1,768 ⟶ 2,648:
Anyways the scenario where the contestant's switch or stay strategy makes a difference is where Monty has picked from the doors which are neither the user's door nor the car's door.
<
(Here, I have decided that the result will be a list of three door numbers. The first number in that list is the number Monty picks, the second number represents the door the user picked, and the third number represents the door where the car is hidden.)
Line 1,774 ⟶ 2,654:
Once we have our simulation test results for the scenario, we need to test if staying would win. In other words we need to test if the user's first choice matches where the car was hidden:
<
In other words: drop the first element from the list representing our test results -- this leaves us with the user's choice and the door where the car was hidden -- and then insert the verb <code>=</code> between those two values.
Line 1,780 ⟶ 2,660:
We also need to test if switching would win. In other words, we need to test if the user would pick the car from the doors other than the one Monty picked and the one the user originally picked:
<
In other words, start with our list of all doors and then remove the door the monty picked and the door the user picked, and then pick one of the remaining doors at random (the pick at random part is only significant if there were originally more than 3 doors) and see if that matches the door where the car is.
Line 1,786 ⟶ 2,666:
Finally, we need to run the simulation a thousand times and count how many times each strategy wins:
<
320 680</
Or, we could bundle this all up as a defined word. Here, the (optional) left argument "names" the doors and the right argument says how many simulations to run:
<
1 2 3 simulate y
:
Line 1,801 ⟶ 2,681:
labels=. ];.2 'limit stay switch '
smoutput labels,.":"0 y,+/r
)</
Example use:
<
limit 1000
stay 304
switch 696 </
Or, with more doors (and assuming this does not require new rules about how Monty behaves or how the player behaves):
<
limit 1000
stay 233
switch 388 </
=={{header|Java}}==
<
public class Monty{
public static void main(String[] args){
Line 1,842 ⟶ 2,722:
System.out.println("Staying wins " + stayWins + " times.");
}
}</
Output:
<pre>Switching wins 21924 times.
Line 1,851 ⟶ 2,731:
===Extensive Solution===
This solution can test with n doors, the difference in probability for switching is shown to diminish as the number of doors increases*.
<
function montyhall(tests, doors) {
'use strict';
Line 1,892 ⟶ 2,772:
};
}
</syntaxhighlight>
{{out}}
<
montyhall(1000, 3)
Object {stayWins: "349 34.9%", switchWins: "651 65.1%"}
Line 1,902 ⟶ 2,782:
montyhall(1000, 5)
Object {stayWins: "202 20.2%", switchWins: "265 26.5%"}
</syntaxhighlight>
In the above code/problem version with n doors, only one "losing" door is opened/shown by the show host before the possibility of switch. There is a generalization to the problem in which the show host progressively opens losing doors one by one until two remains. In this case, the win probability of switching increases as the number of door increases. This has been discussed in a [https://www.researchgate.net/publication/262373808_A_generalization_of_the_Monty_Hall_Problem] 2009 article.
Slight modification of the script above for modularity inside of HTML.
<syntaxhighlight lang="javascript"><html>
<body>
<input id="userInputMH" value="1000">
<input id="userInputDoor" value="3">
<br>
<button onclick="montyhall()">Calculate</button>
<p id="firstPickWins"></p>
<p id="switchPickWins"></p>
</body>
</html>
<script>
function montyhall() {
var tests = document.getElementById("userInputMH").value;
var doors = document.getElementById("userInputDoor").value;
var prizeDoor, chosenDoor, shownDoor, switchDoor, chosenWins = 0,switchWins = 0;
function pick(excludeA, excludeB) {
var door;
do {
door = Math.floor(Math.random() * doors);
} while (door === excludeA || door === excludeB);
return door;
}
for (var i = 0; i < tests; i++) {
prizeDoor = pick();
chosenDoor = pick();
shownDoor = pick(prizeDoor, chosenDoor);
switchDoor = pick(chosenDoor, shownDoor);
if (chosenDoor === prizeDoor) {
chosenWins++;
} else if (switchDoor === prizeDoor) {
switchWins++;
}
}
document.getElementById("firstPickWins").innerHTML = 'First Door Wins: ' + chosenWins + ' | ' + (100 * chosenWins / tests) + '%';
document.getElementById("switchPickWins").innerHTML = 'Switched Door Wins: ' + switchWins + ' | ' + (100 * switchWins / tests) + '%';
}
</script></syntaxhighlight>
'''Output:'''
<syntaxhighlight lang="javascript">(1000, 3)
First Door Wins: 346 | 34.6%
Switching Door Wins: 654 | 65.4%</syntaxhighlight>
===Basic Solution===
<!-- http://blog.dreasgrech.com/2011/09/simulating-monty-hall-problem.html -->
<
var totalGames = 10000,
selectDoor = function () {
Line 1,952 ⟶ 2,889:
console.log("Wins when not switching door", play(false));
console.log("Wins when switching door", play(true));
</syntaxhighlight>
{{out}}
<
Playing 10000 games
Wins when not switching door 3326
Wins when switching door 6630
</syntaxhighlight>
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
Neither the C nor the Go implementations of jq currently provides a PRN generator,
so this entry uses /dev/urandom as an external source of entropy as
follows:
<pre>
cat /dev/urandom | tr -cd '0-9' | fold -w 1 | jq -nrf monty-hall.jq
</pre>
where monty-hall.jq contains one of the following jq programs.
====Basic solution====
This solution is based on the observation: {{quote|If I initially guessed the winning door and didn't switch, or if I initially guessed a losing door but then switched, I've won.}}
<syntaxhighlight lang="jq">def rand:
input as $r
| if $r < . then $r else rand end;
def logical_montyHall:
. as $games
| {switchWins: 0, stayWins: 0}
| reduce range (0; $games) as $_ (.;
(3|rand) as $car # put car in a random door
| (3|rand) as $choice # choose a door at random
| if $choice == $car then .stayWins += 1
else .switchWins += 1
end )
| "Simulating \($games) games:",
"Staying wins \(.stayWins) times",
"Switching wins \(.switchWins) times\n" ;
1e3, 1e6 | logical_montyHall</syntaxhighlight>
====Simulation====
{{trans|Kotlin}}
<syntaxhighlight lang="jq">def rand:
input as $r
| if $r < . then $r else rand end;
def montyHall:
. as $games
| [range(0;3) | 0 ] as $doors0
| {switchWins: 0, stayWins: 0}
| reduce range (0; $games) as $_ (.;
($doors0 | .[3|rand] = 1) as $doors # put car in a random door
| (3|rand) as $choice # choose a door at random
| .stop = false
| until (.stop;
.shown = (3|rand) # the shown door
| if ($doors[.shown] != 1 and .shown != $choice)
then .stop=true
else .
end)
| .stayWins += $doors[$choice]
| .switchWins += $doors[3 - $choice - .shown]
)
| "Simulating \($games) games:",
"Staying wins \(.stayWins) times",
"Switching wins \(.switchWins) times\n" ;
1e3, 1e6 | montyHall</syntaxhighlight>
{{out}}
<pre>
Simulating 1000 games:
Staying wins 325 times
Switching wins 675 times
Simulating 1000000 games:
Staying wins 333253 times
Switching wins 666747 times
</pre>
=={{header|Julia}}==
Line 1,967 ⟶ 2,979:
'''The Literal Simulation Function'''
<syntaxhighlight lang="julia">using Printf
function play_mh_literal{T<:Integer}(ncur::T=3, ncar::T=1)
ncar < ncur || throw(DomainError())
Line 1,988 ⟶ 3,001:
return (isstickwin, isswitchwin)
end
</syntaxhighlight>
'''The Clean Simulation Function'''
<syntaxhighlight lang="julia">
function play_mh_clean{T<:Integer}(ncur::T=3, ncar::T=1)
ncar < ncur || throw(DomainError())
Line 2,003 ⟶ 3,016:
return (isstickwin, isswitchwin)
end
</syntaxhighlight>
'''Supporting Functions'''
<syntaxhighlight lang="julia">
function mh_results{T<:Integer}(ncur::T, ncar::T,
nruns::T, play_mh::Function)
Line 2,051 ⟶ 3,064:
return nothing
end
</syntaxhighlight>
'''Main'''
<syntaxhighlight lang="julia">
for i in 3:5, j in 1:(i-2)
show_simulation(i, j, 10^5)
end
</syntaxhighlight>
This code shows, for a variety of configurations, the results for 3 solutions: literal simulation, clean simulation, analytic. Stick is the percentage of times that the player wins a car by sticking to an initial choice. Switch is the winning percentage the comes with switching one's selection following the goat reveal. Improvement is the ratio of switch to stick.
Line 2,123 ⟶ 3,136:
(0.33241,0.66759)
</pre>
=={{header|K}}==
<syntaxhighlight lang="k">
montyhall:{t:,/ 1_ x {`prng@`t[];ch:1?3;pr:1?3;sw:1?2;$[sw;a:ch=pr;a:~(ch=pr)];a}\0N;("KEEP %";(+/t)%x;"SWAP %";(+/~t)%x)}
montyhall 100000
</syntaxhighlight>
=={{header|Kotlin}}==
{{trans|Java}}
<
import java.util.Random
Line 2,153 ⟶ 3,172:
fun main(args: Array<String>) {
montyHall(1_000_000)
}</
Sample output:
{{out}}
Line 2,161 ⟶ 3,180:
Switching wins 666330 times
</pre>
=={{header|Lua}}==
<
local car = math.random(3)
local pchoice = player.choice()
Line 2,213 ⟶ 3,198:
for i = 1, 20000 do playgame(player) end
print(player.wins)
end</
=={{header|Lua/Torch}}==
<
local car = torch.LongTensor(n):random(3) -- door with car
local choice = torch.LongTensor(n):random(3) -- player's choice
Line 2,242 ⟶ 3,227:
end
montyStats(1e7)</
Output for 10 million samples:
Line 2,249 ⟶ 3,234:
win 33.3008% 66.6487%
win not 66.6992% 33.3513%</pre>
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module CheckIt {
Enum Strat {Stay, Random, Switch}
Line 2,295 ⟶ 3,281:
}
CheckIt
</syntaxhighlight>
{{out}}
<pre>
Line 2,303 ⟶ 3,289:
</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica"> montyHall[nGames_] :=
Module[{r, winningDoors, firstChoices, nStayWins, nSwitchWins, s},
r := RandomInteger[{1, 3}, nGames];
Line 2,314 ⟶ 3,299:
Grid[{{"Strategy", "Wins", "Win %"}, {"Stay", Row[{nStayWins, "/", nGames}], s=N[100 nStayWins/nGames]},
{"Switch", Row[{nSwitchWins, "/", nGames}], 100 - s}}, Frame -> All]]</
;Usage:
<syntaxhighlight lang
[[File:MontyHall.jpg]]
=={{header|MATLAB}}==
<syntaxhighlight lang="matlab">
wins = ceil(3*rand(1e8,1)) - ceil(3*rand(1e8,1))
mprintf('chance to win for staying: %1.6f %%\nchance to win for changing: %1.6f %%', 100*length(wins(wins==0))/length(wins), 100*length(wins(wins<>0))/length(wins))
</syntaxhighlight>
OUTPUT:
<syntaxhighlight lang="matlab">
chance to win for staying: 33.334694 %
chance to win for changing: 66.665306 %
</syntaxhighlight>
<syntaxhighlight lang="matlab">
function montyHall(numDoors,numSimulations)
assert(numDoors > 2);
Line 2,379 ⟶ 3,376:
disp(sprintf('Switch win percentage: %f%%\nStay win percentage: %f%%\n', [switchedDoors(1)/sum(switchedDoors),stayed(1)/sum(stayed)] * 100));
end</
Output:
<
Switch win percentage: 66.705972%
Stay win percentage: 33.420062%</
=={{header|MAXScript}}==
<
(
doors = #(false, false, false)
Line 2,412 ⟶ 3,408:
iterations = 10000
format ("Stay strategy:%\%\n") (iterate iterations false)
format ("Switch strategy:%\%\n") (iterate iterations true)</
Output:
<
Switch strategy:66.84%</
=={{header|Modula-2}}==
{{trans|XPL0|<code>CARDINAL</code> (unsigned integer) used instead of integer.}}
{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}
<syntaxhighlight lang="modula2">
MODULE MontyHallProblem;
FROM STextIO IMPORT
WriteLn, WriteString;
FROM RandomNumbers IMPORT
Randomize, Rnd;
FROM SRealIO IMPORT
WriteFixed;
CONST
NGames = 10000; (* number of games simulated *)
VAR
NWins, Game: CARDINAL;
PROCEDURE IsGameWon(Sw: BOOLEAN): BOOLEAN;
(* Play one game. *)
VAR
Car, Player, Player0, Monty: CARDINAL;
BEGIN
Car := Rnd(3); (* Randomly place car behind a door. *)
Player0 := Rnd(3); (* Player randomly chooses a door. *)
REPEAT
Monty := Rnd(3); (* Monty opens door revealing a goat. *)
UNTIL (Monty <> Car) AND (Monty <> Player0);
IF Sw THEN
(* Player switches to remaining door. *)
REPEAT
Player := Rnd(3);
UNTIL (Player <> Player0) AND (Player <> Monty)
ELSE
Player := Player0 (* Player sticks with original door. *)
END;
RETURN (Player = Car);
END IsGameWon;
BEGIN
Randomize(0);
NWins := 0;
FOR Game := 0 TO NGames DO
IF IsGameWon(FALSE) THEN
NWins := NWins + 1
END
END;
WriteString('NOT switching doors wins car in ');
WriteFixed(FLOAT(NWins) / FLOAT(NGames) * 100.0, 1, 4);
WriteString('% of games.');
WriteLn;
NWins := 0;
FOR Game := 0 TO NGames DO
IF IsGameWon(TRUE) THEN
NWins := NWins + 1
END
END;
WriteString('But switching doors wins car in ');
WriteFixed(FLOAT(NWins) / FLOAT(NGames) * 100.0, 1, 4);
WriteString('% of games.');
WriteLn;
END MontyHallProblem.
</syntaxhighlight>
{{out}}(example)
<pre>
NOT switching doors wins car in 33.4% of games.
But switching doors wins car in 66.5% of games.
</pre>
=={{header|NetRexx}}==
Line 2,421 ⟶ 3,487:
{{trans|REXX}}
{{trans|PL/I}}
<
* 30.08.2013 Walter Pachl translated from Java/REXX/PL/I
**********************************************************************/
Line 2,455 ⟶ 3,521:
method r3 static
rand=random()
return rand.nextInt(3) + 1</
Output
<pre>
Line 2,464 ⟶ 3,530:
=={{header|Nim}}==
{{trans|Python}}
<
randomize()
proc shuffle[T](x: var seq[T]) =
for i in countdown(x.high, 0):
let j =
swap(x[i], x[j])
Line 2,482 ⟶ 3,549:
var lst = @[1,0,0] # one car and two goats
shuffle(lst) # shuffles the list randomly
let ran =
let user = lst[ran] # storing the random guess
del lst, ran # deleting the random guess
Line 2,500 ⟶ 3,567:
echo "Stay = ",stay
echo "Switch = ",switch</
Output:
<pre>Stay = 337
Line 2,506 ⟶ 3,573:
=={{header|OCaml}}==
<
type door = Car | Goat
Line 2,534 ⟶ 3,601:
strat (100. *. (float n /. float trials)) in
msg "switch" switch;
msg "stay" stay</
=={{header|PARI/GP}}==
<
my(stay=0,change=0);
for(i=1,trials,
Line 2,549 ⟶ 3,616:
};
test(1e4)</
Output:
Line 2,557 ⟶ 3,624:
=={{header|Pascal}}==
<
uses
Line 2,607 ⟶ 3,674:
end.
</syntaxhighlight>
Output:
Line 2,616 ⟶ 3,683:
=={{header|Perl}}==
<
use strict;
my $trials = 10000;
Line 2,642 ⟶ 3,709:
print "Stay win ratio " . (100.0 * $stay/$trials) . "\n";
print "Switch win ratio " . (100.0 * $switch/$trials) . "\n";</
=={{header|Phix}}==
Modified copy of [[Monty_Hall_problem#Euphoria|Euphoria]]
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">swapWins</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">stayWins</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">winner</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">choice</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">reveal</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">other</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">game</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">1_000_000</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">winner</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">rand</span><span style="color: #0000FF;">(</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">choice</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">rand</span><span style="color: #0000FF;">(</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">while</span> <span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">reveal</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">rand</span><span style="color: #0000FF;">(</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">reveal</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">winner</span> <span style="color: #008080;">and</span> <span style="color: #000000;">reveal</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">choice</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #000000;">stayWins</span> <span style="color: #0000FF;">+=</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">choice</span><span style="color: #0000FF;">==</span><span style="color: #000000;">winner</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">other</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">6</span><span style="color: #0000FF;">-</span><span style="color: #000000;">choice</span><span style="color: #0000FF;">-</span><span style="color: #000000;">reveal</span> <span style="color: #000080;font-style:italic;">-- (as 1+2+3=6, and reveal!=choice)</span>
<span style="color: #000000;">swapWins</span> <span style="color: #0000FF;">+=</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">other</span><span style="color: #0000FF;">==</span><span style="color: #000000;">winner</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Stay: %,d\nSwap: %,d\nTime: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">stayWins</span><span style="color: #0000FF;">,</span><span style="color: #000000;">swapWins</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Stay: 333,292
Swap: 666,708
Time: 0.
</pre>
=={{header|PHP}}==
<
function montyhall($iterations){
$switch_win = 0;
Line 2,746 ⟶ 3,765:
montyhall(10000);
?></
Output:
<pre>Iterations: 10000 - Stayed wins: 3331 (33.31%) - Switched wins: 6669 (66.69%)</pre>
=={{header|Picat}}==
<syntaxhighlight lang="picat">go =>
_ = random2(), % different seed
member(Rounds,[1000,10_000,100_000,1_000_000,10_000_000]),
println(rounds=Rounds),
SwitchWins = 0,
StayWins = 0,
NumDoors = 3,
foreach(_ in 1..Rounds)
Winner = choice(NumDoors),
Choice = choice(NumDoors),
% Shown is not needed for the simulation
% Shown = pick([Door : Door in 1..NumDoors, Door != Winner, Door != Choice]),
if Choice == Winner then
StayWins := StayWins + 1
else
SwitchWins := SwitchWins + 1
end
end,
printf("Switch win ratio %0.5f%%\n", 100.0 * SwitchWins/Rounds),
printf("Stay win ratio %0.5f%%\n", 100.0 * StayWins/Rounds),
nl,
fail,
nl.
% pick a number from 1..N
choice(N) = random(1,N).
pick(L) = L[random(1,L.len)].</syntaxhighlight>
{{out}}
<pre>rounds = 1000
Switch win ratio 68.80000%
Stay win ratio 31.20000%
rounds = 10000
Switch win ratio 67.25000%
Stay win ratio 32.75000%
rounds = 100000
Switch win ratio 66.69700%
Stay win ratio 33.30300%
rounds = 1000000
Switch win ratio 66.65520%
Stay win ratio 33.34480%
rounds = 10000000
Switch win ratio 66.66641%
Stay win ratio 33.33359%</pre>
=={{header|PicoLisp}}==
<
(let (Prize (rand 1 3) Choice (rand 1 3))
(if Keep # Keeping the first choice?
Line 2,769 ⟶ 3,840:
(do 10000 (and (montyHall NIL) (inc 'Cnt)))
(format Cnt 2) )
" %" )</
Output:
<pre>Strategy KEEP -> 33.01 %
Line 2,776 ⟶ 3,847:
=={{header|PL/I}}==
{{trans|Java}}
<
ziegen: Proc Options(main);
/* REXX ***************************************************************
Line 2,813 ⟶ 3,884:
Return(res);
End;
End;</
Output:
<pre>
Line 2,823 ⟶ 3,894:
Use ghostscript or print this to a postscript printer
<syntaxhighlight lang="postscript">%!PS
/Courier % name the desired font
20 selectfont % choose the size in points and establish
Line 2,858 ⟶ 3,929:
showpage % print all on the page</
Sample output:
Line 2,867 ⟶ 3,938:
=={{header|PowerShell}}==
<
$intIterations = 10000
$intKept = 0
Line 2,920 ⟶ 3,991:
Write-Host "Keep : $intKept ($($intKept/$intIterations*100)%)"
Write-Host "Switch: $intSwitched ($($intSwitched/$intIterations*100)%)"
Write-Host ""</
Output:
<pre>Results through 10000 iterations:
Line 2,926 ⟶ 3,997:
Switch: 6664 (66.64%)</pre>
=={{header|
{{works with|GNU Prolog}}
<syntaxhighlight lang="prolog">
:- initialization(main).
% Simulate a play.
play(Switch, Won) :-
% Random prize door
random(1, 4, C),
% Random reveal door, not prize or contestant door
repeat,
random(1, 4, R),
R \= P,
R \= C,
!,
% Final door
(
Switch, between(1, 3, F), F \= C, F \= R, !;
\+ Switch, F = C
),
% Check result.
(F = P -> Won = true ; Won = false).
% Count wins.
win_count(0, _, Total, Total).
win_count(I, Switch, A, Total) :-
I > 0,
I1 is I - 1,
play(Switch, Won),
(Won, A1 is A + 1;
\+ Won, A1 is A),
win_count(I1, Switch, A1, Total).
main :-
randomize,
win_count(1000, true, 0, SwitchTotal),
format('Switching wins ~d out of 1000.\n', [SwitchTotal]),
win_count(1000, false, 0, StayTotal),
format('Staying wins ~d out of 1000.\n', [StayTotal]).
</syntaxhighlight>
{{out}}
<pre>
Switching wins 667 out of 1000.
Staying wins 332 out of 1000.
</pre>
=={{header|Python}}==
<
I could understand the explanation of the Monty Hall problem
but needed some more evidence
Line 3,012 ⟶ 4,095:
print sum(monty_hall(randrange(3), switch=True)
for x in range(iterations)),
print "out of", iterations, "times.\n"</
Sample output:
<pre>Monty Hall problem simulation:
Line 3,024 ⟶ 4,107:
===Python 3 version: ===
Another (simpler in my opinion), way to do this is below, also in python 3:
<
#1 represents a car
#0 represent a goat
Line 3,056 ⟶ 4,139:
print("Stay =",stay)
print("Switch = ",switch)
#Done by Sam Witton 09/04/2014</
=={{header|
<syntaxhighlight lang="quackery"> [ $ "bigrat.qky" loadfile ] now!
[ 0 ( number of cars when not changing choice )
0 ( number of cars when changing choice )
rot times
[ 3 random ( door with goat )
3 random ( contestant's choice )
= ( If the two numbers are equal then the contestant
wins a car if they change their mind, and they win
a goat if they don't change their mind. The wins
are reversed if the numbers are not equal. )
if dip 1+ ] ( increment the relevant count )
say "Strategy A is that the contestant changes their mind." cr
say "Strategy B is that the contestant does not their mind." cr
say "Approximate ratio of car wins with strategy A over strategy B: "
swap 100 round
vulgar$ echo$ cr ] is trials ( n --> )</syntaxhighlight>
{{out}}
Running the simulation in the Quackery shell.
<pre>/O> 1000 trials
...
Strategy A is that the contestant changes their mind.
Strategy B is that the contestant does not their mind.
Approximate ratio of car wins with strategy A over strategy B: 15/8
Stack empty.
/O> 1000000 trials
...
Strategy A is that the contestant changes their mind.
Strategy B is that the contestant does not their mind.
Approximate ratio of car wins with strategy A over strategy B: 2/1
Stack empty.
</pre>
From this we can conclude that strategy B is preferable, as goats are the GOAT!
=={{header|R}}==
<syntaxhighlight lang="rsplus">set.seed(19771025) # set the seed to set the same results as this code
N <- 10000 # trials
true_answers <- sample(1:3, N, replace=TRUE)
Line 3,121 ⟶ 4,242:
change <- runif(N) >= .5
random_switch[change] <- other_door[change]
summary(random_switch == true_answers)</
Line 3,187 ⟶ 4,308:
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
Line 3,224 ⟶ 4,345:
(for-each test-strategy (list keep-choice change-choice))
</syntaxhighlight>
Sample Output:
Line 3,231 ⟶ 4,352:
change-choice: 66.67613%
</pre>
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|2018.09}}
This implementation is parametric over the number of doors. [[wp:Monty_Hall_problem#Increasing_the_number_of_doors|Increasing the number of doors in play makes the superiority of the switch strategy even more obvious]].
<syntaxhighlight lang="raku" line>enum Prize <Car Goat>;
enum Strategy <Stay Switch>;
sub play (Strategy $strategy, Int :$doors = 3) returns Prize {
# Call the door with a car behind it door 0. Number the
# remaining doors starting from 1.
my Prize @doors = flat Car, Goat xx $doors - 1;
# The player chooses a door.
my Prize $initial_pick = @doors.splice(@doors.keys.pick,1)[0];
# Of the n doors remaining, the host chooses n - 1 that have
# goats behind them and opens them, removing them from play.
while @doors > 1 {
@doors.splice($_,1)
when Goat
given @doors.keys.pick;
}
# If the player stays, they get their initial pick. Otherwise,
# they get whatever's behind the remaining door.
return $strategy === Stay ?? $initial_pick !! @doors[0];
}
constant TRIALS = 10_000;
for 3, 10 -> $doors {
my atomicint @wins[2];
say "With $doors doors: ";
for Stay, 'Staying', Switch, 'Switching' -> $s, $name {
(^TRIALS).race.map: {
@wins[$s]⚛++ if play($s, doors => $doors) == Car;
}
say " $name wins ",
round(100*@wins[$s] / TRIALS),
'% of the time.'
}
}</syntaxhighlight>
{{out}}
<pre>With 3 doors:
Staying wins 34% of the time.
Switching wins 66% of the time.
With 10 doors:
Staying wins 10% of the time.
Switching wins 90% of the time.</pre>
=={{header|REXX}}==
===version 1===
{{trans|Java}}
<
* 30.08.2013 Walter Pachl derived from Java
**********************************************************************/
Line 3,265 ⟶ 4,438:
Say 'NetRexx:' time('E') 'seconds'
Exit
r3: Return random(2)+1</
Output for 1000000 samples:
<pre>
Line 3,289 ⟶ 4,462:
===version 2===
parse arg # seed . /*obtain the optional args from the CL.*/
if
car=
wins._ = wins._ +
end /*#*/
/* [↑] door values: 0≡goat 1≡car */
say 'switching wins ' format(wins.0 / # * 100, , 1)"% of the time."
say ' staying wins ' format(wins.1 / # * 100, , 1)"% of the time." ; say
say 'performed ' # " times with
<pre>
switching wins 66.
staying wins 33.
performed 1000000 times with 3 doors.
</pre>
=={{header|Ring}}==
<
total = 10000
swapper = 0
Line 3,357 ⟶ 4,508:
see "the 'sticker' won " + sticker + " times (" + floor(sticker/total*100) + "%)" + nl
see "the 'swapper' won " + swapper + " times (" + floor(swapper/total*100) + "%)" + nl
</syntaxhighlight>
Output:
<pre>
Line 3,367 ⟶ 4,518:
=={{header|Ruby}}==
<
stay = switch = 0 #sum of each strategy's wins
Line 3,393 ⟶ 4,544:
puts "Staying wins %.2f%% of the time." % (100.0 * stay / n)
puts "Switching wins %.2f%% of the time." % (100.0 * switch / n)</
Sample Output:
<pre>Staying wins 33.84% of the time.
Switching wins 66.16% of the time.</pre>
=={{header|Rust}}==
{{libheader|rand}}
<
use rand::Rng;
use rand::seq::SliceRandom;
#[derive(Clone, Copy, PartialEq)]
Line 3,437 ⟶ 4,565:
for _ in 0..GAMES {
let mut doors = [Prize::Goat; 3];
*
// You only lose by switching if you pick the car the first time
if
switch_wins += 1;
}
Line 3,449 ⟶ 4,577:
percent = switch_wins as f64 / GAMES as f64 * 100.0
);
}</
=={{header|Scala}}==
<
object MontyHallSimulation {
Line 3,483 ⟶ 4,612:
switchStrategyWins, percent(switchStrategyWins)))
}
}</
Sample:
Line 3,494 ⟶ 4,623:
=={{header|Scheme}}==
<
(define (random-permutation list)
(if (null? list)
Line 3,563 ⟶ 4,692:
;; > (compare-strategies 1000000)
;; (stay-strategy won with probability 33.3638 %
;; and switch-strategy won with probability 66.716 %)</
=={{header|Scilab}}==
{{incorrect|scilab|Several syntax and logical errors: switch is a keyword, the variable a is never used, and in the result the sum does not yield 100000 (which is logical since both result are taken from different random samples, but they should not). Also some useless complexity: the nested if can be simplified with logical operators.}}
<syntaxhighlight lang="text">// How it works:
// MontyHall() is a function with argument switch:
// it will be called 100000 times with switch=%T,
Line 3,603 ⟶ 4,734:
end
disp("Switching, one wins"+ascii(10)+string(wins_switch)+" games out of "+string(games))
disp("Staying, one wins"+ascii(10)+string(wins_stay)+" games out of "+string(games))</
Output:
Line 3,616 ⟶ 4,747:
=={{header|Seed7}}==
<
const proc: main is func
Line 3,638 ⟶ 4,769:
writeln("Switching wins " <& switchWins <& " times");
writeln("Staying wins " <& stayWins <& " times");
end func;</
Output:
Line 3,645 ⟶ 4,776:
Staying wins 3346 times
</pre>
=={{header|SETL}}==
<syntaxhighlight lang="setl">program monty_hall;
setrandom(0);
n_simulations := 100000;
print('Chance to win:');
print('When switching doors:', win_chance(true, n_simulations) * 100, '%');
print('When not switching doors:', win_chance(false, n_simulations) * 100, '%');
proc win_chance(switch, n_simulations);
wins := 0;
loop for i in [1..n_simulations] do
wins +:= if simulate(switch) then 1 else 0 end;
end loop;
return wins / n_simulations;
end proc;
proc simulate(switch);
doors := {1, 2, 3};
car := random doors;
goats := doors less car;
choice := random doors;
opened := random (goats less choice);
if switch then
choice := arb (doors less choice less opened);
end if;
return choice = car;
end proc;
end program;</syntaxhighlight>
{{out}}
<pre>Chance to win:
When switching doors: 66.584 %
When not switching doors: 33.093 %</pre>
=={{header|Sidef}}==
<
var switchWins = (var stayWins = 0) # sum of each strategy's wins
Line 3,667 ⟶ 4,833:
say ("Staying wins %.2f%% of the time." % (100.0 * stayWins / n))
say ("Switching wins %.2f%% of the time." % (100.0 * switchWins / n))</
{{out}}
<pre>
Line 3,676 ⟶ 4,842:
=={{header|SPAD}}==
{{works with|FriCAS, OpenAxiom, Axiom}}
<syntaxhighlight lang="spad">
montyHall(n) ==
wd:=[1+random(3) for j in 1..n]
Line 3,683 ⟶ 4,849:
p:=(st/n)::DoubleFloat
FORMAT(nil,"stay: ~A, switch: ~A",p,1-p)$Lisp
</syntaxhighlight>
Domain:[http://fricas.github.io/api/Integer.html?highlight=random Integer]
Line 3,702 ⟶ 4,868:
(3) stay: 0.33526, switch: 0.66474
Type: SExpression
</pre>
=={{header|SparForte}}==
As a structured script.
<syntaxhighlight lang="ada">#!/usr/local/bin/spar
pragma annotate( summary, "monty" )
@( description, "Run random simulations of the Monty Hall game. Show the" )
@( description, "effects of a strategy of the contestant always keeping" )
@( description, "his first guess so it can be contrasted with the" )
@( description, "strategy of the contestant always switching his guess." )
@( description, "Simulate at least a thousand games using three doors" )
@( description, "for each strategy and show the results in such a way as" )
@( description, "to make it easy to compare the effects of each strategy." )
@( see_also, "http://rosettacode.org/wiki/Monty_Hall_problem" )
@( author, "Ken O. Burtch" );
pragma license( unrestricted );
pragma restriction( no_external_commands );
procedure monty is
num_iterations : constant positive := 100_000;
type action_type is (stay, switch);
type prize_type is (goat, pig, car);
doors : array(1..3) of prize_type;
type door_index is new positive;
-- place the prizes behind random doors
procedure set_prizes is
begin
doors( 1 ) := goat;
doors( 2 ) := pig;
doors( 3 ) := car;
arrays.shuffle( doors );
end set_prizes;
-- determine if the prize was chosen based on strategy
function play( action : action_type ) return prize_type is
chosen : door_index := door_index( numerics.rnd(3) );
monty : door_index;
begin
set_prizes;
for i in arrays.first(doors)..arrays.last(doors) loop
if i /= chosen and doors(i) /= car then
monty := i;
end if;
end loop;
if action = switch then
for i in arrays.first(doors)..arrays.last(doors) loop
if i /= monty and i /= chosen then
chosen := i;
exit;
end if;
end loop;
end if;
return doors( chosen );
end play;
winners : natural; -- times won
pct : float; -- percentage won
begin
winners := 0;
for i in 1..num_iterations loop
if play( stay ) = car then
winners := @+1;
end if;
end loop;
pct := float( winners * 100 ) / float( num_iterations );
put( "Stay: count" ) @ ( winners ) @ ( " = " ) @ ( pct ) @ ( "%" );
new_line;
winners := 0;
for i in 1..num_iterations loop
if play( switch ) = car then
winners := @+1;
end if;
end loop;
pct := float( winners * 100 ) / float( num_iterations );
put( "Switch: count" ) @ ( winners ) @ ( " = " ) @ ( pct ) @ ( "%" );
new_line;
end monty;</syntaxhighlight>
=={{header|Standard ML}}==
Works with SML/NJ or with MLton using the SML/NJ Util library.
<syntaxhighlight lang="standard ml">
val pidint = Word64.toInt(Posix.Process.pidToWord(Posix.ProcEnv.getpid()));
val rand = Random.rand(LargeInt.toInt(Time.toSeconds(Time.now())), pidint);
fun stick_win 0 wins = wins
| stick_win trial wins =
let
val winner_door = (Random.randNat rand) mod 3;
val chosen_door = (Random.randNat rand) mod 3;
in
if winner_door = chosen_door then
stick_win (trial-1) (wins+1)
else
stick_win (trial-1) wins
end
val trials = 1000000;
val sticks = stick_win trials 0;
val stick_winrate = 100.0 * Real.fromInt(sticks) / Real.fromInt(trials);
(* if you lost by sticking you would have won by swapping *)
val swap_winrate = 100.0 - stick_winrate;
(print ("sticking = " ^ Real.toString(stick_winrate) ^ "% win rate\n");
print ("swapping = " ^ Real.toString(swap_winrate) ^ "% win rate\n"));
</syntaxhighlight>
'''Output'''
<pre>
sticking = 33.3449% win rate
swapping = 66.6551% win rate
</pre>
=={{header|Stata}}==
<
set obs 1000000
gen
gen choice1=runiformint(1,3)
gen succ1=
gen shown=cond(succ1,runiformint(1,2),6-
replace shown=shown+1 if succ1 &
gen choice2=6-shown-choice1
gen succ2=
tabstat succ1 succ2, s(mean)</
'''Output'''
Line 3,727 ⟶ 5,008:
=={{header|Swift}}==
<
func montyHall(doors: Int = 3, guess: Int, switch: Bool) -> Bool {
Line 3,749 ⟶ 5,030:
print("Switching would've won \((Double(switchWins) / Double(switchResults.count)) * 100)% of games")
print("Not switching would've won \(((Double(switchResults.count - switchWins)) / Double(switchResults.count)) * 100)% of games")</
{{out}}
Line 3,757 ⟶ 5,038:
=={{header|Tcl}}==
A simple way of dealing with this one, based on knowledge of the underlying probabilistic system, is to use code like this:
<
for {set i 0} {$i<$total} {incr i} {
if {int(rand()*3) == int(rand()*3)} {
Line 3,766 ⟶ 5,047:
}
puts "Estimate: $stay/$total wins for staying strategy"
puts "Estimate: $change/$total wins for changing strategy"</
But that's not really the point of this challenge; it should add the concealing factors too so that we're simulating not just the solution to the game, but also the game itself. (Note that we are using Tcl's lists here to simulate sets.)
We include a third strategy that is proposed by some people (who haven't thought much about it) for this game: just picking at random between all the doors offered by Monty the second time round.
<
# Utility: pick a random item from a list
Line 3,835 ⟶ 5,116:
puts "Estimate: $stay/$total wins for 'staying' strategy"
puts "Estimate: $change/$total wins for 'changing' strategy"
puts "Estimate: $anew/$total wins for 'picking anew' strategy"</
This might then produce output like
Estimate: 3340/10000 wins for 'staying' strategy
Line 3,844 ⟶ 5,125:
=={{header|Transact SQL}}==
T-SQL for general case:
<syntaxhighlight lang="transact sql">
---- BEGIN ------------
create table MONTY_HALL(
Line 3,886 ⟶ 5,167:
from MONTY_HALL
---- END ------------
</syntaxhighlight>
<pre>
% OF WINS FOR KEEP % OF WINS FOR CHANGE % OF WINS FOR RANDOM
Line 3,895 ⟶ 5,176:
=={{header|UNIX Shell}}==
{{works with|bash|2.x| and most bash-compatible unix shells}}
<
# Simulates the "monty hall" probability paradox and shows results.
# http://en.wikipedia.org/wiki/Monty_Hall_problem
Line 3,966 ⟶ 5,247:
echo "Wins (switch to remaining door): $num_win"
echo "Losses (first guess was correct): $num_lose"
exit 0</
Output of a few runs:
<pre>
Line 4,020 ⟶ 5,301:
for the switching strategy.
<
#import nat
#import flo
Line 4,036 ⟶ 5,317:
#show+
main = ~&plrTS/<'stay: ','switch: '> format* <staying_wins,switching_wins></
Output will vary slightly for each run due to randomness.
<pre>
Line 4,044 ⟶ 5,325:
=={{header|Vedit macro language}}==
{{trans|
Vedit macro language does not have random number generator, so one is implemented in subroutine RANDOM (the algorithm was taken from ANSI C library).
<
#91 = 3 // random numbers in range 0 to 2
#1 = 0 // wins for "always stay" strategy
Line 4,080 ⟶ 5,361:
#93 = 0x7fffffff % 48271
#90 = (48271 * (#90 % #92) - #93 * (#90 / #92)) & 0x7fffffff
return ((#90 & 0xffff) * #91 / 0x10000)</
Sample output:
Line 4,086 ⟶ 5,367:
Staying winns: 3354
Switching winns: 6646
</pre>
=={{header|V (Vlang)}}==
{{trans|Java}}
<syntaxhighlight lang="v (vlang)">
import rand
fn main() {
games := 1_000_000
mut doors := [3]int{}
mut switch_wins, mut stay_wins, mut shown, mut guess := 0, 0, 0, 0
for _ in 1..games + 1 {
doors[rand.int_in_range(0, 3) or {exit(1)}] = 1 // Set which one has the car
guess = rand.int_in_range(0, 3) or {exit(1)} // Choose a door
for doors[shown] == 1 || shown == guess {
shown = rand.int_in_range(0, 3) or {exit(1)} // Shown door
}
stay_wins += doors[guess]
switch_wins += doors[3 - guess - shown]
for clear in 0..3 {if doors[clear] != 0 {doors[clear] = 0}}
}
println("Simulating ${games} games:")
println("Staying wins ${stay_wins} times at ${(f32(stay_wins) / f32(games) * 100):.2}% of games")
println("Switching wins ${switch_wins} times at ${(f32(switch_wins) / f32(games) * 100):.2}% of games")
}
</syntaxhighlight>
{{out}}
<pre>
Simulating 1000000 games:
Staying wins 332518 times at 33.25% of games
Switching wins 667482 times at 66.75% of games
</pre>
=={{header|Wren}}==
{{trans|Kotlin}}
<syntaxhighlight lang="wren">import "random" for Random
var montyHall = Fn.new { |games|
var rand = Random.new()
var switchWins = 0
var stayWins = 0
for (i in 1..games) {
var doors = [0] * 3 // all zero (goats) by default
doors[rand.int(3)] = 1 // put car in a random door
var choice = rand.int(3) // choose a door at random
var shown = 0
while (true) {
shown = rand.int(3) // the shown door
if (doors[shown] != 1 && shown != choice) break
}
stayWins = stayWins + doors[choice]
switchWins = switchWins + doors[3-choice-shown]
}
System.print("Simulating %(games) games:")
System.print("Staying wins %(stayWins) times")
System.print("Switching wins %(switchWins) times")
}
montyHall.call(1e6)</syntaxhighlight>
{{out}}
Sample output:
<pre>
Simulating 1000000 games:
Staying wins 333970 times
Switching wins 666030 times
</pre>
=={{header|X++}}==
<
int changeWins = 0;
Line 4,122 ⟶ 5,470:
print strFmt("Staying wins %1 times.", noChangeWins);
pause;
</syntaxhighlight>
Output:
Line 4,129 ⟶ 5,477:
=={{header|XPL0}}==
<
int Game,
include c:\cxpl\codes;
int Switch;
int Car, Player, Player0, Monty;
Line 4,144 ⟶ 5,492:
until Player # Player0 and Player # Monty
else Player:= Player0; \player sticks with original door
];
[Format(2,1);
NWins:= 0;
for Game:= 0 to NGames-1 do
if IsGameWon(false) then NWins:= NWins+1;
Text(0, "NOT switching doors wins car in ");
RlOut(0, float(NWins)/float(NGames)*100.0);
Text(0, "% of games.^M^J");
NWins:= 0;
for Game:= 0 to NGames-1 do
if IsGameWon(true) then NWins:= NWins+1;
Text(0, "But switching doors wins car in ");
RlOut(0, float(NWins)/float(NGames)*100.0);
Text(0, "% of games.^M^J");
]</
Example output:
<pre>
But switching doors wins car in 66.7% of games.
</pre>
=={{header|Zig}}==
<syntaxhighlight lang="zig">const std = @import("std");
const number_of_simulations: u32 = 10_000_000;
pub fn main() !void {
var stick_wins: u32 = 0;
var switch_wins: u32 = 0;
var doors = [3]bool{ true, false, false };
var t = std.rand.DefaultPrng.init(42);
const r = t.random();
var guess: u8 = undefined;
var door_shown: u8 = undefined;
for (0..number_of_simulations) |_| {
std.rand.Random.shuffle(r, bool, &doors);
guess = r.intRangeAtMost(u8, 0, 2);
door_shown = r.intRangeAtMost(u8, 0, 2);
while (!doors[door_shown] and door_shown != guess) door_shown = r.intRangeAtMost(u8, 0, 2);
if (doors[guess]) {
stick_wins += 1;
} else {
switch_wins += 1;
}
}
std.debug.print("After {} simulations:\nStick wins: {}\nSwitch wins: {}\n", .{ number_of_simulations, stick_wins, switch_wins });
}</syntaxhighlight>
=={{header|zkl}}==
{{trans|Go}}
<
reg switcherWins=0, keeperWins=0, shown=0;
Line 4,185 ⟶ 5,567:
switcherWins, switcherWins.toFloat() / games * 100).println();
"Keeper Wins: %,d (%3.2f%%)".fmt(
keeperWins, keeperWins.toFloat() / games * 100).println();</
{{out}}
<pre>
| |||