Programming and Computer Science in Java:

See Course Home Page.

**Due
Date: Fri, Mar 21, 2003**

For each of the following questions, anything which your
programs *compute* must be computed within a new method, and not directly
inside your main method.

**Topic: Random Numbers**

The following code demonstrates how to generate random integers or doubles in the ranges [0,hi] or [lo,hi]:

```
class RandomsDemo
{
// This method returns a random *double* in [0,hi]
public static double random(double hi)
{
return hi * Math.random();
}
```

```
// This method returns a random *integer* in [0,hi]
public static int random(int hi)
{
return ((int)((hi+1)*Math.random()) % (hi+1));
}
```

```
// This method returns a random *double* in [lo,hi]
public static double random(double lo, double hi)
{
double range = hi - lo;
return lo + random(range);
}
```

```
// This method returns a random *integer* in [lo,hi]
public static int random(int lo, int hi)
{
int range = hi - lo;
return lo + random(range);
}
```

```
// test the integer randoms
public static void testRandomIntegers()
{
int i, intLo, intHi;
System.out.println("**********************");
System.out.println("Testing Random Integers");
System.out.println();
while (true)
{
System.out.print("Enter integers for lo and hi [0's to quit]: ");
intLo = readInt();
intHi = readInt();
if ((intLo == 0) && (intHi == 0))
break;
System.out.println("Here are 20 randoms in [" + intLo + "," + intHi + "]:");
for (i=0;i<20;i++)
{
System.out.print(random(intLo,intHi) + " ");
// add a newline every third number printed out
if (i % 3 == 2)
System.out.println();
}
System.out.println();
System.out.println("Here are 20 randoms in [0," + Math.abs(intHi) + "]:");
for (i=0;i<20;i++)
{
System.out.print(random(Math.abs(intHi)) + " ");
// add a newline every third number printed out
if (i % 3 == 2)
System.out.println();
}
System.out.println();
}
}
```

```
// test the double randoms
public static void testRandomDoubles()
{
int i;
double doubleLo, doubleHi;
System.out.println("**********************");
System.out.println("Testing Random Doubles");
System.out.println();
while (true)
{
System.out.print("Enter doubles for lo and hi [0's to quit]: ");
doubleLo = readDouble();
doubleHi = readDouble();
if ((doubleLo == 0) && (doubleHi == 0))
break;
System.out.println("Here are 20 randoms in [" + doubleLo + "," + doubleHi + "]:");
for (i=0;i<20;i++)
{
System.out.print(random(doubleLo,doubleHi) + " ");
// add a newline every third number printed out
if (i % 3 == 2)
System.out.println();
}
System.out.println();
System.out.println("Here are 20 randoms in [0," + Math.abs(doubleHi) + "]:");
for (i=0;i<20;i++)
{
System.out.print(random(Math.abs(doubleHi)) + " ");
// add a newline every third number printed out
if (i % 3 == 2)
System.out.println();
}
System.out.println();
}
}
```

```
public static void main(String[] args)
{
testRandomIntegers();
testRandomDoubles();
}
// readString(), readInt(), and readDouble()
}
```

What you must understand here:

- Math.random() returns a random double in [0.0,1.0].
- We can have several methods all named
*random*but with*different signatures*-- in particular, with*different parameters*. This is called*overloading*. This is covered in the book in section 5.4 which is coincidentally on page 54 (please go read it*now*!). - You can use Math.random() to return a double in [0.0,hi].
- Returning an
*integer*in [0,hi] is more complicated, because you have to make sure that "hi" is just as likely as the other values in that range. To do this, we extend the range to "hi+1", but then we have the very tiny chance that we will in fact return "hi+1" as our result. Thus, we take*that*value mod (hi+1), thus guaranteeing a result in [0,hi]. Be sure you understand this point very clearly! - You can also use that method -- double random(double hi) -- to return a double in [lo,hi], by using a "range" variable.
- You can do the same for integers, using the integer method -- int random(int hi) -- to return an integer in [lo,hi], also by using a "range" variable.
- You now have all you need to return integers or doubles in a range [lo,hi].
- You now can attack so-called "Monte Carlo" problems, which use random numbers and approximations to solve very real and non-random problems. Wahoo!!!

**Problems: Random Numbers**

**Question 1**: Simple Coin Flips

Write a Java program which reads in a positive integer n and prints out the
result of n coin flips (as a series of H or T characters). To do this,
write a method with the following signature:

public static boolean coinFlip()

This method returns true if the flip is a heads, and false if it is a tails.

**Question 2**: Equal numbers of Heads and Tails

Write a Java program which reads in a positive integer n flips a coin n times,
counting the number of heads and tails which occur. Print out the result,
as well as the ratio of heads/tails. We would expect this ratio to be very
near 1, and the larger n is, the closer the result would be to 1.

__ Question 3: Longest runs
__Write a Java program which reads in a positive integer n and prints out the
result of each of n coin flips (as a series of H or T characters) (as in
Question 1). Here, though, print out the length of the longest runs of
heads and tails afterwards. So, if your output were HH

__ Question 4: How likely is a run 4 or more Heads?
__Write a Java program which uses Monte Carlo techniques to determine how
likely it is to have a run of 4 or more Heads when flipping a coin 20
times. To do this, you must run the whole experiment (flipping a coin 20
times) many times, say 100k times (thus, there would be 2 million total coin
flips), keeping a count of how many times the conjecture was true (that is, that
there was a run of 4 or more heads in the 20 flips). The odds, then, are
the successful experiments divided by the total number of experiments,
multiplied by 100 to give a percentage.

**Question 5**: Simple Roll of the Die

Write a Java program which reads in a positive integer n and prints out the
result of n rolls of a 6-sided die (as a series of numbers from 1 to 6).
To do this, write a method with the following signature:

public static int rollDie()

This method returns the result of rolling a 6-sided die one time.

**Question 6**: Odds of different rolls

Write a Java program which prints out the odds of different results when rolling
two dice, where the result is the sum of the two dice. To do this, run a
counter from 2 to 12 (the range of possible outcomes), and for each value, you
must run 100k experiments rolling two dice and verifying whether the outcome
equals the current value of the counter. Print a table of odds as you go
(first column is the sum of the dice, second column is the odds of getting that
sum).

*Note: it seems inefficient to require new experiments for each new
value of the counter, right? Yes! But in order to use a single
experiment for multiple values of the counter, we need to use *arrays*,
which we've not yet covered. Soon, soon....*

Good luck!

DK

See Course Home Page.