Monty Hall problem: Difference between revisions

{{trans|Python}}

 

V sw = 0

 

 

print(‘Stay = ’stay)

 

=={{header|8086 Assembly}}==

 

puts: equ 9 ; MS-DOS syscall to print a string

cpu 8086

nsw: db 'When not switching doors: $'

db '*****'

 

{{out}}

 

=={{header|ActionScript}}==

import flash.display.Sprite;

 

}

}

Output:

<pre>Switching wins 18788 times. (62.626666666666665%)

 

=={{header|Ada}}==

 

with Ada.Text_Io; use Ada.Text_Io;

Put_Line("%");

 

Results

<pre>Stay : count 34308 = 34.31%

{{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);

print(("Changing: ", percent(change winning), new line ));

print(("New random choice: ", percent(random winning), new line ))

Sample output:

<pre>

 

=={{header|APL}}==

[1] ⍝0: Monthy Hall problem

[2] ⍝1: http://rosettacode.org/wiki/Monty_Hall_problem

[12] ⎕←'Swap: ',(2⍕100×(swap÷runs)),'% it''s a car'

[13] ⎕←'Stay: ',(2⍕100×(stay÷runs)),'% it''s a car'

<pre>

Run 100000

{{trans|Nim}}

 

swit: 0

 

 

print ["Stay:" stay]

 

{{out}}

 

=={{header|AutoHotkey}}==

Iterations = 1000

Loop, %Iterations%

Mode := Mode = 2 ? 2*rand - 1: Mode

Return, Mode = 1 ? 6 - guess - show = actual : guess = actual

Sample output:

<pre>

 

=={{header|AWK}}==

 

# Monty Hall problem

simulate(RAND)

Sample output:

 

Monty Hall problem simulation:

Algorithm switch: prize count = 6655, = 66.55%

Algorithm random: prize count = 4991, = 49.91%

 

=={{header|BASIC}}==

 

==={{header|BASIC256}}===

numTiradas = 1000000

permanece = 0

print "Si cambia, tiene un "; cambia / numTiradas * 100; "% de probabilidades de ganar."

end

 

==={{header|IS-BASIC}}===

110 RANDOMIZE

120 LET NUMGAMES=1000

220 PRINT "Num of games:";NUMGAMES

230 PRINT "Wins not changing doors:";NOTCHANGING,NOTCHANGING/NUMGAMES*100;"% of total."

 

==={{header|Sinclair ZX81 BASIC}}===

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

130 IF NEWGUESS=CAR THEN LET SWITCH=SWITCH+1

140 NEXT I

{{out}}

<pre> WINS IF YOU

341 659</pre>

 

 

LET numTiradas = 1000000

 

LET pta_coche = INT(RND * 3) + 1

LET pta_elegida = INT(RND * 3) + 1

ELSE

END IF

NEXT i

 

PRINT "Cambiar gana el"; permanece / numTiradas * 100; "% de las veces."

PRINT "Mantenerse gana el"; cambia / numTiradas * 100; "% de las veces."

 

 

 

=={{header|C}}==

 

#include <stdlib.h>

#include <time.h>

 

 

Output of one run:

 

 

=={{header|C sharp|C#}}==

{{trans|Java}}

 

class Program

Console.Out.WriteLine("Switching wins " + switchWins + " times.");

}

Sample output:

<pre>

 

=={{header|C++}}==

#include <cstdlib>

#include <ctime>

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}}==

 

param doors: int = 3;

writeln( "Both methods are equal." );

}

Sample output:

<pre>

Wins by switching: 646 or 64.6%

Switching is the superior method.

</pre>

 

=={{header|Clojure}}==

(:use [clojure.contrib.seq :only (shuffle)]))

 

(range times))]

(str "wins " wins " times out of " times)))

staying: wins 337 times out of 1000

nil

switching: wins 638 times out of 1000

nil

 

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

PROGRAM-ID. monty-hall.

 

END PROGRAM get-rand-int.

 

 

{{out}}

 

=={{header|ColdFusion}}==

function runmontyhall(num_tests) {

// number of wins when player switches after original selection

}

runmontyhall(10000);

Output:

<pre>

 

=={{header|Common Lisp}}==

(let ((array (make-array 3

:element-type 'bit

 

(defun won? (array i)

for round = (make-round)

for initial = (random 3)

#1# 1/100))))))

Stay: 33.2716%

 

;Find out how often we win if we always switch

(defun rand-elt (s)

(defun monty-trials (n)

(count t (loop for x from 1 to n collect (monty))))

 

=={{header|D}}==

 

void main() {

 

writefln("Switching/Staying wins: %d %d", switchWins, stayWins);

{{out}}

<pre>Switching/Staying wins: 66609 33391</pre>

=={{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 {

play(10000,false);

play(10000,true);

<pre>playing without switching won 33.32%

playing with switching won 67.63%</pre>

{{works with|Delphi|XE10}}

{{libheader| System.SysUtils}}

 

{$APPTYPE CONSOLE}

WriteLn('Switching wins ' + IntToStr(switchWins) + ' times.');

end.

{{out}}

<pre>Staying wins 333253 times.

{{trans|C#}}

 

var stayWins = 0

print("Staying wins \(stayWins) times.")

 

{{out}}

<pre>Staying wins 286889 times.

Switching wins 713112 times.</pre>

 

=={{header|Eiffel}}==

note

description: "[

 

end

{{out}}

<pre>

 

=={{header|Elixir}}==

def simulate(n) do

{stay, switch} = simulate(n, 0, 0)

end

 

 

{{out}}

=={{header|Emacs Lisp}}==

{{trans|Picolisp}}

(let ((prize (random 3))

(choice (random 3)))

(dotimes (i 10000)

(and (montyhall nil) (setq cnt (1+ cnt))))

 

{{out}}

Strategy keep: 34.410%

Strategy switch: 66.430%

 

=={{header|Erlang}}==

 

-export([main/0]).

false -> OpenDoor

end.

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()

 

let Wins (f:unit -> int) = seq {for i in [1..nSims] -> f()} |> Seq.sum

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 =

 

let Wins (f:unit -> int) = seq {for i in [1..nSims] -> f()} |> Seq.sum

 

=={{header|Forth}}==

 

===version 1===

 

variable stay-wins

cr switch-wins @ . [char] / emit . ." switching wins" ;

 

 

or in iForth:

 

0 value switch-wins

 

dup 0 ?DO trial LOOP

CR stay-wins DEC. ." / " dup DEC. ." staying wins,"

 

With output:

{{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.

here seed !

 

' keep IS applyStrategy run ." Keep door => " .result cr

' switch IS applyStrategy run ." Switch door => " .result cr

 

{{out}}

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

IMPLICIT NONE

WRITE(*, "(A,F6.2,A)") "Chance of winning by switching is", real(switchcount)/trials*100, "%"

 

Sample Output

Chance of winning by not switching is 32.82%

Chance of winning by switching is 67.18%

 

 

 

 

 

 

 

 

 

 

 

=={{header|Go}}==

 

import (

fmt.Printf("Keeper Wins: %d (%3.2f%%)",

keeperWins, (float32(keeperWins) / floatGames * 100))

Output:

<pre>

 

=={{header|Haskell}}==

 

trials :: Int

percent n ++ "% of the time."

percent n = show $ round $

 

{{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

cars n switch g = (numcars, new_g)

where numcars = length $ filter (== Car) prize_list

 

Sample output (for either implementation):

 

=={{header|HicEst}}==

 

DLG(NameEdit = plays, DNum=1, Button='Go')

WRITE(ClipBoard, Name) plays, switchWins, stayWins

 

! plays=1E4; switchWins=6673; stayWins=3327;

! plays=1E5; switchWins=66811; stayWins=33189;

 

=={{header|Icon}} and {{header|Unicon}}==

 

rounds := integer(arglist[1]) | 10000

write("Strategy 2 'Switching' won ", real(strategy2) / rounds )

 

 

Sample Output:<pre>Monty Hall simulation for 10000 rounds.

 

=={{header|Io}}==

switchWins := 0

doors := 3

.. "Keeping the same door won #{keepWins} times.\n"\

.. "Game played #{times} times with #{doors} doors.") interpolate println

Sample output:<pre>Switching to the other door won 66935 times.

Keeping the same door won 33065 times.

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.

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.)

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.

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.

Finally, we need to run the simulation a thousand times and count how many times each strategy wins:

 

 

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

:

labels=. ];.2 'limit stay switch '

smoutput labels,.":"0 y,+/r

 

Example use:

 

limit 1000

stay 304

 

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

 

=={{header|Java}}==

public class Monty{

public static void main(String[] args){

System.out.println("Staying wins " + stayWins + " times.");

}

Output:

<pre>Switching wins 21924 times.

===Extensive Solution===

 

 

function montyhall(tests, doors) {

'use strict';

};

}

 

{{out}}

montyhall(1000, 3)

Object {stayWins: "349 34.9%", switchWins: "651 65.1%"}

montyhall(1000, 5)

Object {stayWins: "202 20.2%", switchWins: "265 26.5%"}

 

Slight modification of the script above for modularity inside of HTML.

 

<body>

}

 

'''Output:'''

First Door Wins: 346 | 34.6%

 

===Basic Solution===

 

<!-- http://blog.dreasgrech.com/2011/09/simulating-monty-hall-problem.html -->

var totalGames = 10000,

selectDoor = function () {

console.log("Wins when not switching door", play(false));

console.log("Wins when switching door", play(true));

 

{{out}}

Playing 10000 games

Wins when not switching door 3326

Wins when switching door 6630

 

=={{header|jq}}==

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.}}

 

input as $r

| if $r < . then $r else rand end;

"Switching wins \(.switchWins) times\n" ;

 

 

====Simulation====

{{trans|Kotlin}}

input as $r

| if $r < . then $r else rand end;

"Switching wins \(.switchWins) times\n" ;

{{out}}

<pre>

 

'''The Literal Simulation Function'''

 

function play_mh_literal{T<:Integer}(ncur::T=3, ncar::T=1)

return (isstickwin, isswitchwin)

end

 

'''The Clean Simulation Function'''

function play_mh_clean{T<:Integer}(ncur::T=3, ncar::T=1)

ncar < ncur || throw(DomainError())

return (isstickwin, isswitchwin)

end

 

'''Supporting Functions'''

function mh_results{T<:Integer}(ncur::T, ncar::T,

nruns::T, play_mh::Function)

return nothing

end

 

'''Main'''

for i in 3:5, j in 1:(i-2)

show_simulation(i, j, 10^5)

end

 

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.

(0.33241,0.66759)

</pre>

 

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.util.Random

fun main(args: Array<String>) {

montyHall(1_000_000)

Sample output:

{{out}}

Switching wins 666330 times

</pre>

 

=={{header|Lua}}==

local car = math.random(3)

local pchoice = player.choice()

for i = 1, 20000 do playgame(player) end

print(player.wins)

 

=={{header|Lua/Torch}}==

local car = torch.LongTensor(n):random(3) -- door with car

local choice = torch.LongTensor(n):random(3) -- player's choice

end

 

 

Output for 10 million samples:

 

=={{header|M2000 Interpreter}}==

Module CheckIt {

Enum Strat {Stay, Random, Switch}

}

CheckIt

{{out}}

<pre>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Module[{r, winningDoors, firstChoices, nStayWins, nSwitchWins, s},

r := RandomInteger[{1, 3}, nGames];

Grid[{{"Strategy", "Wins", "Win %"}, {"Stay", Row[{nStayWins, "/", nGames}], s=N[100 nStayWins/nGames]},

 

;Usage:

 

[[File:MontyHall.jpg]]

 

=={{header|MATLAB}}==

 

assert(numDoors > 2);

disp(sprintf('Switch win percentage: %f%%\nStay win percentage: %f%%\n', [switchedDoors(1)/sum(switchedDoors),stayed(1)/sum(stayed)] * 100));

 

Output:

Switch win percentage: 66.705972%

 

=={{header|MAXScript}}==

(

doors = #(false, false, false)

iterations = 10000

format ("Stay strategy:%\%\n") (iterate iterations false)

Output:

 

=={{header|NetRexx}}==

{{trans|REXX}}

{{trans|PL/I}}

* 30.08.2013 Walter Pachl translated from Java/REXX/PL/I

**********************************************************************/

method r3 static

rand=random()

Output

<pre>

=={{header|Nim}}==

{{trans|Python}}

 

randomize()

 

echo "Stay = ",stay

Output:

<pre>Stay = 337

 

=={{header|OCaml}}==

 

type door = Car | Goat

strat (100. *. (float n /. float trials)) in

msg "switch" switch;

 

=={{header|PARI/GP}}==

my(stay=0,change=0);

for(i=1,trials,

};

 

 

Output:

 

=={{header|Pascal}}==

 

uses

 

end.

 

Output:

=={{header|Perl}}==

 

use strict;

my $trials = 10000;

 

print "Stay win ratio " . (100.0 * $stay/$trials) . "\n";

 

=={{header|Phix}}==

Modified copy of [[Monty_Hall_problem#Euphoria|Euphoria]]

<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: #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>

{{out}}

<pre>

 

=={{header|PHP}}==

function montyhall($iterations){

$switch_win = 0;

montyhall(10000);

Output:

<pre>Iterations: 10000 - Stayed wins: 3331 (33.31%) - Switched wins: 6669 (66.69%)</pre>

 

=={{header|Picat}}==

_ = random2(), % different seed

member(Rounds,[1000,10_000,100_000,1_000_000,10_000_000]),

choice(N) = random(1,N).

 

 

{{out}}

 

=={{header|PicoLisp}}==

(let (Prize (rand 1 3) Choice (rand 1 3))

(if Keep # Keeping the first choice?

(do 10000 (and (montyHall NIL) (inc 'Cnt)))

(format Cnt 2) )

Output:

<pre>Strategy KEEP -> 33.01 %

=={{header|PL/I}}==

{{trans|Java}}

ziegen: Proc Options(main);

/* REXX ***************************************************************

Return(res);

End;

Output:

<pre>

Use ghostscript or print this to a postscript printer

 

/Courier % name the desired font

20 selectfont % choose the size in points and establish

 

 

 

Sample output:

 

=={{header|PowerShell}}==

$intIterations = 10000

$intKept = 0

Write-Host "Keep : $intKept ($($intKept/$intIterations*100)%)"

Write-Host "Switch: $intSwitched ($($intSwitched/$intIterations*100)%)"

Output:

<pre>Results through 10000 iterations:

=={{header|Prolog}}==

{{works with|GNU Prolog}}

:- initialization(main).

 

win_count(1000, false, 0, StayTotal),

format('Staying wins ~d out of 1000.\n', [StayTotal]).

{{out}}

<pre>

Staying wins 332 out of 1000.

</pre>

 

=={{header|Python}}==

I could understand the explanation of the Monty Hall problem

but needed some more evidence

print sum(monty_hall(randrange(3), switch=True)

for x in range(iterations)),

Sample output:

<pre>Monty Hall problem simulation:

===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

print("Stay =",stay)

print("Switch = ",switch)

 

=={{header|Quackery}}==

 

[ 0 ( number of cars when not changing choice )

say "Approximate ratio of car wins with strategy A over strategy B: "

swap 100 round

 

{{out}}

=={{header|R}}==

 

N <- 10000 # trials

true_answers <- sample(1:3, N, replace=TRUE)

change <- runif(N) >= .5

random_switch[change] <- other_door[change]

 

 

=={{header|Racket}}==

 

#lang racket

 

 

(for-each test-strategy (list keep-choice change-choice))

 

Sample Output:

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]].

 

enum Strategy <Stay Switch>;

'% of the time.'

}

{{out}}

<pre>With 3 doors:

===version 1===

{{trans|Java}}

* 30.08.2013 Walter Pachl derived from Java

**********************************************************************/

Say 'NetRexx:' time('E') 'seconds'

Exit

Output for 1000000 samples:

<pre>

 

===version 2===

parse arg # seed . /*obtain the optional args from the CL.*/

if #=='' | #=="," then #= 1000000 /*Not specified? Then 1 million trials*/

say 'switching wins ' format(wins.0 / # * 100, , 1)"% of the time."

say ' staying wins ' format(wins.1 / # * 100, , 1)"% of the time." ; say

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

total = 10000

swapper = 0

see "the 'sticker' won " + sticker + " times (" + floor(sticker/total*100) + "%)" + nl

see "the 'swapper' won " + swapper + " times (" + floor(swapper/total*100) + "%)" + nl

Output:

<pre>

=={{header|Ruby}}==

 

 

stay = switch = 0 #sum of each strategy's wins

 

puts "Staying wins %.2f%% of the time." % (100.0 * stay / 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;

percent = switch_wins as f64 / GAMES as f64 * 100.0

);

 

=={{header|Scala}}==

 

object MontyHallSimulation {

switchStrategyWins, percent(switchStrategyWins)))

}

 

Sample:

 

=={{header|Scheme}}==

(define (random-permutation list)

(if (null? list)

;; > (compare-strategies 1000000)

;; (stay-strategy won with probability 33.3638 %

 

=={{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.}}

 

// MontyHall() is a function with argument switch:

// it will be called 100000 times with switch=%T,

end

disp("Switching, one wins"+ascii(10)+string(wins_switch)+" games out of "+string(games))

 

Output:

 

=={{header|Seed7}}==

 

const proc: main is func

writeln("Switching wins " <& switchWins <& " times");

writeln("Staying wins " <& stayWins <& " times");

 

Output:

Staying wins 3346 times

</pre>

 

=={{header|Sidef}}==

var switchWins = (var stayWins = 0) # sum of each strategy's wins

 

 

say ("Staying wins %.2f%% of the time." % (100.0 * stayWins / n))

{{out}}

<pre>

=={{header|SPAD}}==

{{works with|FriCAS, OpenAxiom, Axiom}}

montyHall(n) ==

wd:=[1+random(3) for j in 1..n]

p:=(st/n)::DoubleFloat

FORMAT(nil,"stay: ~A, switch: ~A",p,1-p)$Lisp

Domain:[http://fricas.github.io/api/Integer.html?highlight=random Integer]

 

(3) stay: 0.33526, switch: 0.66474

Type: SExpression

</pre>

 

=={{header|Stata}}==

 

set obs 1000000

gen car=runiformint(1,3)

gen choice2=6-shown-choice1

gen succ2=car==choice2

 

'''Output'''

=={{header|Swift}}==

 

 

func montyHall(doors: Int = 3, guess: Int, switch: Bool) -> Bool {

 

print("Switching would've won \((Double(switchWins) / Double(switchResults.count)) * 100)% of games")

 

{{out}}

=={{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)} {

}

puts "Estimate: $stay/$total wins for staying 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

puts "Estimate: $stay/$total wins for 'staying' strategy"

puts "Estimate: $change/$total wins for 'changing' strategy"

This might then produce output like

Estimate: 3340/10000 wins for 'staying' strategy

=={{header|Transact SQL}}==

T-SQL for general case:

---- BEGIN ------------

create table MONTY_HALL(

from MONTY_HALL

---- END ------------

<pre>

% OF WINS FOR KEEP % OF WINS FOR CHANGE % OF WINS FOR RANDOM

=={{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

echo "Wins (switch to remaining door): $num_win"

echo "Losses (first guess was correct): $num_lose"

Output of a few runs:

<pre>

for the switching strategy.

 

#import nat

#import flo

#show+

 

Output will vary slightly for each run due to randomness.

<pre>

 

=={{header|Vedit macro language}}==

 

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

#93 = 0x7fffffff % 48271

#90 = (48271 * (#90 % #92) - #93 * (#90 / #92)) & 0x7fffffff

 

Sample output:

Staying winns: 3354

Switching winns: 6646

</pre>

 

=={{header|Wren}}==

{{trans|Kotlin}}

 

var montyHall = Fn.new { |games|

}

 

 

{{out}}

 

=={{header|X++}}==

 

int changeWins = 0;

print strFmt("Staying wins %1 times.", noChangeWins);

pause;

 

Output:

 

=={{header|XPL0}}==

include c:\cxpl\codes;

 

int Switch;

int Car, Player, Player0, Monty;

until Player # Player0 and Player # Monty

else Player:= Player0; \player sticks with original door

];

 

[Format(2,1);

Text(0, "% of games.^M^J");

 

Text(0, "But switching doors wins car in ");

Text(0, "% of games.^M^J");

 

Example output:

<pre>

But switching doors wins car in 66.7% of games.

</pre>

 

 

 

 

 

 

=={{header|zkl}}==

{{trans|Go}}

 

reg switcherWins=0, keeperWins=0, shown=0;

switcherWins, switcherWins.toFloat() / games * 100).println();

"Keeper Wins: %,d (%3.2f%%)".fmt(

{{out}}

<pre>