### Solution for Programming Exercise 8.1

THIS PAGE DISCUSSES ONE POSSIBLE SOLUTION to the following exercise from this on-line Java textbook.

Exercise 8.1: An example in Section 8.2 tried to answer the question, How many random people do you have to select before you find a duplicate birthday? The source code for that program can be found in the file BirthdayProblemDemo.java. Here are some related questions:

• How many random people do you have to select before you find three people who share the same birthday? (That is, all three people were born on the same day in the same month, but not necessarily in the same year.)
• Suppose you choose 365 people at random. How many different birthdays will they have? (The number could theoretically be anywhere from 1 to 365).
• How many different people do you have to check before you've found at least one person with a birthday on each of the 365 days of the year?

Write three programs to answer these questions. Like the example program, BirthdayProblemDemo, each of your programs should simulate choosing people at random and checking their birthdays. (In each case, ignore the possibility of leap years.)

Discussion

The original program has a subroutine, birthdayProblem(), that does the simulation once. The main() routine calls this subroutine over and over, as long as the user wants to continue. The three programs can all use the same main() routine, along with a modified birthdayProblem() routine. The changes from the original program are not huge, but you need a clear understanding of arrays in order to get them right. Let's look at each of the problems in turn. I'll just look at the birthdayProblem() subroutines. The complete programs are given below.

The first question asks how many people you have to choose at random before finding three who share the same birthday. This is similar to the original program, but instead of just checking whether or not a given birthday has already been found, we need to keep track of how many people have been found with each birthday. Where the original program used an array of booleans, here we need an array of ints. We still want to count the number of people we check and output that count at the end. An algorithm for the simulation is:

```          Let count = 0
Repeat:
Select a birthday at random
If this is the third time that birthday has occurred:
break out of the loop
Add one to the number of times that birthday has been found
Output the count
```

To do the counting, we need an array "int[] numFound", where numFound[i] will be the number of times the i-th day of the year has occurred as a birthday. Since numFound[i] can be used in any way that any int variable can be used, we can add one to the number stored in numFound[i] by saying "numFound[i]++". When we create the array with the command "numFound = new int[365]", all the elements of the array are automatically initialized to zero. This is the initial value that we want. (This is an important thing to remember! In some programming languages, arrays are not automatically filled with zeros, so it would be necessary to use a for loop to store a zero into each place in the array. Even in Java, if you wrote this program differently and reused the same array rather than creating a new one for each simulation, you would have to remember to set each element of the array to zero at the beginning of the simulation.)

Given all this, we can translate the algorithm into Java as follows:

```          int[] numFound;  // numFound[i] will be the number of people
// who have been found who have a birthday
// on the i-th day of the year

int count;       // The number of people who have been checked.

numFound = new int[365];  // Initially, all entries are 0.

count = 0;

while (true) {
// Select a birthday at random, from 0 to 364.
// If the same birthday was already seen twice
// before, then quit.  Otherwise, add one to
// the corresponding entry in the numFound array
// to record that a person with that birthday
// has been found.
int birthday;  // The selected birthday.
birthday = (int)(Math.random()*365);
count++;
if ( numFound[birthday] == 2 )
break;  // It's the third time we've found this birthday.
numFound[birthday]++;
}

TextIO.putln("It took " + count +
" tries to find three people with the same birthday.");
```

The lines shown in red are the ones that differ significantly from the original program. This becomes the body of the birthdayProblem() subroutine in the first program.

.

For the second program, we know exactly how many people we want to check: 365. This calls for using a for loop. The information we need for each birthday is whether or not that birthday has occurred. For that, we can use an array of booleans. The value stored in position i of the array is true if the i-th day of the year has occurred as a birthday and is false if not. After checking 365 people, we have to go through the array and count the number of entries in the array that are true. This is the number of different birthdays that have been found. The algorithm can be expressed as:

```        Let used = new boolean[365]
Repeat 365 times:
Select a birthday at random
Store true into the corresponding location in the array, used
Let count = 0
for day = 0 to 364:
If used[day] is true:
Output the value of count.
```

This translates easily into Java code:

```        boolean used[];  // used[i] will be true if a person is found
// whose birthday is the i-th day of the year.

used = new boolean[365];  // Initially, all entries are false!

for (int i = 0; i < 365; i++) {
// Select a random birthday and record it.
int birthday;  // The selected birthday.
birthday = (int)(Math.random()*365);
used[birthday] = true;
}

int count = 0;

for (int day = 0; day < 365; day++) {
// If this day occurred as a birthday, count it.
if (used[day] == true)
count++;
}

TextIO.putln("Among 365 people, there were " + count
+ " different birthdays.");

```

It might be worth noting that the test "if (used[day] == true)" can be written more simply as "if (used[day])". Also, the three lines in the first for loop could be reduced to the single command "used[(int)(Math.random()*365)] = true;". Of course, this one-line version is harder to understand.

The third program is just a little bit trickier. We have to continue selecting people at random until we have found 365 different birthdays. We can use a counter to keep track of how many different birthdays we have found. We have to continue until this counter reaches 365. We need a second counter to keep track of how many different people we have checked. It's the second counter whose value we want to output at the end. Now, we have to be able to recognize whether a birthday we've just found is new, or whether we've encountered it previously. For this, we can again use an array of booleans. An algorithm for the simulation is:

```         Let used = new boolean[365]
Let count = 0   // The number of people checked
Let birthdaysFound = 0   // The number of different birthdays found
while birthdaysFound < 365:
Select a birthday at random
if used[birthday] is false:
Add one to birthdaysFound  // since this is a new birthday
Let used[birthday] = true   // so we don't count it again
Output the value of count
```

In Java, this algorithm becomes:

```        boolean[] used;  // For recording the possible birthdays
//   that have been seen so far.
int count;       // The number of people who have been checked.
int birthdaysFound;   // The number of different birthdays that
// have been found.

used = new boolean[365];  // Initially, all entries are false.
count = 0;
birthdaysFound = 0;

while (birthdaysFound < 365) {
// Select a birthday at random, from 0 to 364.
// If the birthday has not already been used,
int birthday;  // The selected birthday.
birthday = (int)(Math.random()*365);
count++;
if ( used[birthday] == false )
birthdaysFound++;
used[birthday] = true;
}

TextIO.putln( count + " people were checked." );

```

The Solution

Finding three people with the same birthday:

```    /*
How many random people do you have to select before you find
THREE with the same birthday (that is, three people who were born
on the same day of the same month, but not necessarily in the
same year).  This program simulates the process.  (It ignores the
possibility of people born on leap day.)
*/

public class BirthdayProblem2 {

public static void main(String[] args) {

TextIO.putln("This program simulates taking people at random");
TextIO.putln("until three have been found who were born on the");
TextIO.putln("same day of the year.\n");

do {
birthdayProblem();
TextIO.put("\nAgain? ");
} while ( TextIO.getlnBoolean() );

TextIO.putln("\n\nOK.  Goodbye.");

} // end main()

static void birthdayProblem() {
// Simulate choosing people at random and checking the
// day of the year they were born on.  If the person is
// the third who was born on that day of the year, stop,
// and output the number of people who were checked.

int[] numFound;  // numFound[i] will be the number of people
// who have been found who have a birthday
// on the i-th day of the year

int count;       // The number of people who have been checked.

numFound = new int[365];  // Initially, all entries are 0.

count = 0;

while (true) {
// Select a birthday at random, from 0 to 364.
// If the same birthday was already seen twice
// before, then quit.  Otherwise, add one to
// the corresponding entry in the numFound
// to record that a person with that birthday
// has been found.
int birthday;  // The selected birthday.
birthday = (int)(Math.random()*365);
count++;
if ( numFound[birthday] == 2 )
break;
numFound[birthday]++;
}

TextIO.putln("It took " + count +
" tries to find three people with the same birthday.");

} // end birthdayProblem()

} // end class BirthdayProblem2

```

How many different birthdays do 365 people have?

```
/*
This program simulates selecting 365 people at random and finding
how many different birthdays they have among them.
*/

public class BirthdayProblem3 {

public static void main(String[] args) {

TextIO.putln("This program simulates taking 365 people at random");
TextIO.putln("and finding out how many different birthdays they");
TextIO.putln("have among them.\n");

do {
birthdayProblem();
TextIO.put("\nAgain? ");
} while ( TextIO.getlnBoolean() );

TextIO.putln("\n\nOK.  Goodbye.");

} // end main()

static void birthdayProblem() {
// Simulate choosing people at random and checking the
// day of the year they were born on.  The number of
// different days found among 365 people is counted
// and output.

boolean used[];  // used[i] will be true if a person is found
// whose birthday is on the i-th day of the year.

used = new boolean[365];  // Initially, all entries are false.

/* Choose 365 days at random, and mark each day by
setting the corresponding entry in the array used
to true.  (If the value is already true, it doesn't
matter.  We are only interested in whether or not
the birthday occurs, not how many times it occurs.)
*/

for (int i = 0; i < 365; i++) {
int birthday;  // The selected birthday.
birthday = (int)(Math.random()*365);
used[birthday] = true;
}

/* Now, count how many entries in the used array are true.
This is how many different birthdays were found.
*/

int count = 0;

for (int day = 0; day < 365; day++) {
// If this day occurred as a birthday, count it.
if (used[day] == true)
count++;
}

TextIO.putln("Among 365 people, there were " + count
+ " different birthdays.");

} // end birthdayProblem()

} // end class BirthdayProblem3

```

Finding 365 different birthdays:

```    /*
How many random people do you have to select before you
have found someone with every possible birthday (ignoring
leap years)?  This program simulates the process.
*/

public class BirthdayProblem4 {

public static void main(String[] args) {

TextIO.putln("This program simulates taking people at random");
TextIO.putln("until someone has been found with a birthday");
TextIO.putln("on every day of the year.\n");

do {
birthdayProblem();
TextIO.put("\nAgain? ");
} while ( TextIO.getlnBoolean() );

TextIO.putln("\n\nOK.  Goodbye.");

} // end main()

static void birthdayProblem() {
// Simulate choosing people at random and checking the
// day of the year they were born on.  People are chosen
// until all 365 possible birthdays (ignoring leap years)
// have been found.  Then the number of people surveyed
// is output.

boolean[] used;  // For recording the possible birthdays
//   that have been seen so far.  A value
//   of true in used[i] means that a person
//   whose birthday is the i-th day of the
//   year has been found.

int count;       // The number of people who have been checked.

int birthdaysFound;   // The number of different birthdays that
// have been found.

used = new boolean[365];  // Initially, all entries are false.

count = 0;

birthdaysFound = 0;

while (birthdaysFound < 365) {
// Select a birthday at random, from 0 to 364.
// If the birthday has not already been used,
int birthday;  // The selected birthday.
birthday = (int)(Math.random()*365);
count++;
if ( used[birthday] == false )
birthdaysFound++;
used[birthday] = true;
}

TextIO.putln( count + " people were checked." );

} // end birthdayProblem()

} // end class BirthdayProblem4

```

[ Exercises | Chapter Index | Main Index ]