### Programming Exercises

For Chapter 8

THIS PAGE CONTAINS programming exercises based on
material from Chapter 8 of this on-line
Java textbook. Each exercise has a link to a discussion of one possible solution of that
exercise.

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

**See the solution!**

**Exercise 8.2:**
Write a program
that will read a sequence of positive real numbers entered by the user
and will print the same numbers in sorted order from smallest to largest.
The user will input a zero to mark the end of the input. Assume
that at most 100 positive numbers will be entered.

**See the solution!**

**Exercise 8.3:**
A polygon is a geometric figure
made up of a sequence of connected line segments. The points where the
line segments meet are called the vertices
of the polygon. The `Graphics` class includes commands for
drawing and filling polygons. For these commands, the coordinates of
the vertices of the polygon are stored in arrays. If `g`
is a variable of type `Graphics` then

`g.drawPolygon(xCoords, yCoords, pointCt)`
will draw the outline of the polygon with vertices at
`(xCoords[0],yCoords[0])`, `(xCoords[1],yCoords[1])`, ...,
`(xCoords[pointCt-1],yCoords[pointCt-1])`. The third parameter,
`pointCt`, is an `int` that specifies the number of vertices
of the polygon. Its value should be 3 or greater. The first two parameters
are arrays of type `int[]`. Note that the polygon automatically
includes a line from the last point, `(xCoords[pointCt-1],yCoords[pointCt-1])`,
back to the starting point `(xCoords[0],yCoords[0])`.
`g.fillPolygon(xCoords, yCoords, pointCt)`
fills the interior of the polygon with the current drawing color. The parameters
have the same meaning as in the `drawPolygon()` method. Note that it is OK for the sides of the polygon to cross each other, but the
interior of a polygon with self-intersections might not be exactly what you
expect.

Write a little applet that lets the user draw polygons. As the user clicks
a sequence of points, count them and store their x- and y-coordinates in two
arrays. These points will be the vertices of the polygon.
Also, draw a line between each consecutive pair of points to give
the user some visual feedback. When the user clicks near the starting
point, draw the complete polygon. Draw it with a red interior and
a black border. The user should then be able to start drawing a new
polygon. When the user shift-clicks on the applet, clear it.

There is no need to store information about the contents of the applet.
The `paintComponent()` method can just draw a border around the applet.
The lines and polygons can be drawn using a graphics context, `g`,
obtained with the command "`g = getGraphics();`".

You can try my solution. Note that as the user is drawing the
polygon, lines are drawn between the points that the user clicks.
Click within two pixels of the starting point to see a filled polygon.

**See the solution!**

**Exercise 8.4:**
For this problem, you will need to use an array of objects. The
objects belong to the class `MovingBall`, which I have
already written. You can find the source code for this class
in the file MovingBall.java.
A `MovingBall` represents a circle that has an associated
color, radius, direction, and speed. It is restricted to moving
in a rectangle in the `(x,y)` plane. It will "bounce back"
when it hits one of the sides of this rectangle. A `MovingBall`
does not actually move by itself. It's just a collection of data.
You have to call instance methods to tell it to update its position
and to draw itself. The constructor for the `MovingBall` class
takes the form

new MovingBall(xmin, xmax, ymin, ymax)

where the parameters are integers that specify the limits on the
`x` and `y` coordinates of the ball. In this exercise, you
will want balls to bounce off the sides of the applet, so you will
create them with the constructor call "`new MovingBall(0, getWidth(),
0, getHeight())`". The constructor creates a ball that
initially is colored red, has a radius of 5 pixels, is located at the
center of its range, has a random speed between 4 and 12, and is headed
in a random direction. If `ball` is a variable of type `MovingBall`,
then the following methods are available:

`ball.draw(g)` -- draw the ball
in a graphics context. The parameter, `g`, must be of type `Graphics`.
(The drawing color in `g` will be changed to the color of the ball.)
`ball.travel()` -- change the
`(x,y)-`coordinates of the ball by an amount equal to its speed.
The ball has a certain direction of motion, and the ball is moved in that
direction. Ordinarily, you will call this once for each frame of
an animation, so the speed is given in terms of "pixels per frame".
Calling this routine does not move the ball on the screen. It just
changes the values of some instance variables in the object.
The next time the object's `draw()`
method is called, the ball will be drawn in the new position.
`ball.headTowards(x,y)` --
change the direction of motion of the ball so that it is headed
towards the point `(x,y)`. This does not affect the speed.

These are the methods that you will need for this exercise. There are
also methods for setting various properties of the ball, such as
`ball.setColor(color)` for
changing the color and `ball.setRadius(radius)`
for changing its size. See the source code for more information.

For this exercise, you should create an applet that shows an
animation of 25 balls bouncing around on a black background. Your
applet can be defined as a subclass of
SimpleAnimationApplet2,
which was first introduced in Section 3.7.
The `drawFrame()` method in your applet should move all the balls
and draw them.
(Alternatively, if you have read Chapter 7, you can program the
animation yourself using a `Timer`.)
Use an array of type `MovingBall[]` to hold the 25 balls.

In addition, your applet should implement the `MouseListener`
and `MouseMotionListener` interfaces. When the user presses
the mouse or drags the mouse, call each of the ball's
`headTowards()` methods to make the balls head towards the
mouse's location.

Here is my solution. Try clicking and dragging on the applet:

**See the solution!**

**Exercise 8.5:**
The game of Go Moku (also known as Pente or Five Stones) is similar
to Tic-Tac-Toe, except that it played on a much larger board
and the object is to get five squares in a row rather than three.
Players take turns placing pieces on a board. A piece can be
placed in any empty square. The first player to get five
pieces in a row -- horizontally, vertically, or diagonally -- wins.
If all squares are filled before either player wins, then the game is
a draw. Write an applet that lets two players play Go Moku against
each other.

Your applet will be simpler than the `Checkers` applet
from Section 8.5. Play alternates strictly
between the two players, and there is no need to hilite the legal
moves. You will only need two classes, a short applet class to
set up the applet and a `Board` class to draw the
board and do all the work of the game. Nevertheless, you will
probably want to look at the source code for the checkers
applet, Checkers.java,
for ideas about the general outline of the program.

The hardest part of the program is checking whether the move
that a player makes is a winning move. To do this, you have to look
in each of the four possible directions from the square where the user
has placed a piece. You have to count how many pieces that player
has in a row in that direction. If the number is five or more in any
direction, then that player wins. As a hint, here is part of the
code from my applet. This code counts the number of pieces that
the user has in a row in a specified direction. The direction
is specified by two integers, `dirX` and `dirY`. The values
of these variables are 0, 1, or -1, and at least one of them is non-zero.
For example, to look in the horizontal direction, `dirX` is 1
and `dirY` is 0.

int ct = 1; // Number of pieces in a row belonging to the player.
int r, c; // A row and column to be examined.
r = row + dirX; // Look at square in specified direction.
c = col + dirY;
while ( r >= 0 && r < 13 && c >= 0 && c < 13
&& board[r][c] == player ) {
// Square is on the board, and it
// contains one of the players's pieces.
ct++;
r += dirX; // Go on to next square in this direction.
c += dirY;
}
r = row - dirX; // Now, look in the opposite direction.
c = col - dirY;
while ( r >= 0 && r < 13 && c >= 0 && c < 13
&& board[r][c] == player ) {
ct++;
r -= dirX; // Go on to next square in this direction.
c -= dirY;
}

Here is my applet. It uses a 13-by-13 board. You can do the same
or use a normal 8-by-8 checkerboard.

**See the solution!**