Programming Assignment 4

**Assigned**:- Monday Oct 18, 1998
**Due**:- Thursday Oct 28, 1998

In the television game show * Let's Make a Deal*, there are
three closed doors on the set with a prize hidden behind just one
of them. The contestant in the game selects a door to be opened,
hoping that it will be the one with the prize behind it!
On occasion, after the contestant has chosen a door, Monty Hall
(the host of the show), adds an interesting twist:
instead of opening the chosen door, Monty opens one of the
*unchosen* doors without a prize behind it.
Then Monty offers the contestant the opportunity to switch their
selection to the remaining door.
Should the contestant stay with their original choice
or switch to the other unopened door?
Does it make any difference?

One approach to answering such questions is to construct a computer simulation of the problem. To simulate a single trial of Monty's gambit, the computer must

- select a random door behind which the prize is located
- select a random door initially chosen by the contestant
- select a random door other than (1) or (2) that will be opened by Monty
- select a random door other than (2) or (3) that will be the new door chosen by a contestant if they choose to switch.

Construct a Haskell function
`monty :: Int -> Int -> Int -> IO ()`
such that `monty `*n d r* prints the percentage
of wins for each strategy in *n* simulated trials
with *d* doors on stage. Here *n* and
*d* are positive integers with *d* at least 3.
The last input *r* is a random integer to
be used in making the random selections (more on this
later).

The output of your function should look something like:

Main> monty 100 3 1234 Performing 100 trials with 3 doors... Percentage of wins with 'stick' strategy: ***% Percentage of wins with 'switch' strategy: ***%Of course your program should print real percentages rather than the stars shown here!

The correctness of your solution is, as usual, the key determinant of the program grade, but we will also be grading the clarity and simplicity of your solution. Do not consider your program finished simply because it appears to solve the problem! Review your solution carefully to see how it might be simplified and improved, just as you review and revise an essay in an English or History class.

The creation and use of random numbers requires special
attention in Haskell. First of all, a Haskell function
` random :: Int` must give the same result every
time it is used. So a function of this form can not be
very random! The best we can do is to create a
function ` randomNext :: Int -> Int ` that, given a
random number as input, generates a new random number
by applying some arithmetic operations to the input number.
Here is one possible definition
that depends on the representation of `Int` values
inside the computer. Given an input between 1 and
2147483646, the result is a (different) integer in the same
range.

randomNext:: Int -> Int randomNext rand = if newRand > 0 then newRand else newRand + 2147483647 where newRand = 16807 * lo - 2836 * hi hi = rand `div` 127773 lo = rand `rem` 127773Through repeated application, this function can be used to generate a sequence of

The function `randomNext` can be difficult to use,
because we must always "remember" the last random number generated,
in order to produce the next one. In this assignment you may wish
to define a function `runtrials` which calls a function
`trial` for each trial, supplying the random numbers needed
to perform the trial as arguments. This way only `runtrials`
need be concerned with the generation of random numbers.

-- randElem ds r: given list of items ds and a random Int r, -- return a random member of the list ds. randElem :: [a] -> Int -> a randElem ds r = ds !! (r `mod` (length ds))The expression

- Wednesday, October 27, 4-6PM in SN030
- Thursday, October 28, 4-6PM in SN030

$ Revised: Oct 16 1999 by prins@cs.unc.edu