Out-Lab 1--Implement the Time class
This will be a one week lab; It will be due at the beginning of lab September 19.

Using the design you wrote in the In-Lab, implement a Time class. Your Time class should implement this TimeInterface and the Comparable interface this way:
public class Time implements Comparable, TimeInterface {...}
Note that all comments have been ommited from this interface, but you should supply them.

 
public interface TimeInterface 
{      
    Time addTime(int minutes);    
    Time addTime(int hours, int minutes); 
    int compareTo(Time rhs);
    String toString();    
}

To help you test your class, and to sure you are using the compareTo and toString methods correctly, a elementary driver is included. After you get it to run correctly, you should add some I/O to the driver so you become familiar with the Scanner class. It is much easier to use than the BufferedReader class in older versions of Java.

Hand in: You will hand in the source code for the Time class, as well as the source code for the TimeUser class, and the commented interface. William will let you know anything else he wants.



Out-Lab 2--Working with Arrays
This will be a two week lab;
It will be due at the beginning of lab October 10.

• The Knight's Tour is a classic chess problem which was studied (and probably solved) over 1000 years ago. The famous mathematician, Euler, published the first rigid mathematical analysis of the problem in 1759.
• The problem is this: Can the chess peice called the knight move around an empty chessboard and touch each of the 64 squares once and only once?
• The purpose of this problem is not to find a solution (beyond the scope of this course) but to program the problem, and see how many moves the knight makes before he cannot move anymore. You can use random numbers to tell the program the next move, or enter them manually.
• How to begin
  • The kinght makes L-shaped moves; over two in one direction and then over one in a perpendicular direction.
  • Thus, from a square in the middle of an empty chessboard, the knight can make eight different moves (numbered 0 thourgh 7) as shown in the figure
    1. Draw an 8-by-8 chessboard on a sheet of paper and attempt a Knight's Tour by hand. Put a 1 in the first square you move to, a 2 in the second square, a 3 in the third, etc. Before starting the tour, estimate how far you think you will get, remembering that a full tour consists of 64 moves. how far did you get? Was this close to your estimate?
    2. I will give you some help with possible data structures to use. You are free to either use them, or to do it your own way. There are certainly other ways for you to store the data necessary to start this problem.
       • The chessboard Use a 2-D array, 8 X 8.
       • The moves since there are eight possible moves, we can describe them in terms of both their horizontal and vertical components, using a 1-D array for each.
         • For example, a move of type 0 consists of moveing two squares horizontally to the right and one square vertically upward.
         • Move 2 consists of moving one square horizontally to the left and two squares vertically upward.
         • Horizontal moves to the left and vertical moves upward are indicated with negative numbers.
       • The horizontal array stores the horizontal part of the move. The vertical array stores the vertical part of the move The subscript is the move type.
         horizontal[0] = 2         vertical[0]= -1
         horizontal[1] = 1         vertical[1]= -2
         horizontal[2] = -1        vertical[2]= -2
         horizontal[3] = -2        vertical[3]= -1
         horizontal[4] = -2        vertical[4]= 1
         horizontal[5] = -1        vertical[5]= 2
         horizontal[6] = 1         vertical[6]= 2
         horizontal[7] = 2         vertical[7]= 1
         
       • Let the variables currentRow and currentCol indicate the row and column of the knight's current psoition. To make a move of type moveNumber where moveNumber is between 0 and 7, your program uses the statements
         currentRow += vertical[moveNumber];
         currentCol += horizontal[moveNumber];
       • Keep a counter that varies from 1 to 64. Record the lastest count in each square the knight moves to.
       • Remember to test each potential move to see if the knight has already visited that square, and, of course, test every potential move to make sure the knight does not land off the chessboard.
       • You should initialize the 2-D array to zeros, then when the knight lands in a square, change the zero to the count. When the knight can no longer move, print out the 2-D array, showing the board with the moves the knight did make.

    Here is one solution, in case you are interested. I do not expect your program to find solutions and your output will not be graphical like this one. You can start the knight in any square you like.
    

Out-Lab 5--Linked Lists
This will be a two week lab;
It will be due at the beginning of lab November 7.

For this lab, you will solve the problem of storing an phone book two different ways.

1. First you will build your own linked list class.
   • This class should give all the functionality needed for a client of your class to load data from a file, enter data, change data, retrieve data, and save the data to a file.
     • This linked list class that you write should be a double linked list and written entirely from scratch. Do not use the Java library at all.
     • Call this class ScratchList, so it will not interfere with the LinkedList class in the Java Library
   • Your driver should test the linked list class you wrote.
     • It should create a linked list with each node holding an object of type Person.
     • Type Person should be a class that holds a person's name and phone number. You may want to separate first and last names, so you can search for last names.
     • This driver should be user friendly enough that someone could actually use it to keep track of their phone numbers if they wanted, and should do everything they might want.

2. For the second part of the lab, you will used the LinkedList class in the Java Library instead of your own class.
   • You can probably use a modified version of the driver you wrote for part 1, just modifying the type of the linked list

Out-Lab 6--Using Queues for Simulation
This will be a two week lab;
It will be due at the beginning of lab November 21.

Description

The people that run the Motor Vehicle Department (MVD) want to make sure that people spend enough time waiting in lines to appreciate the privilege of owning and driving an automobile. They propose the following arrangement, but would like a computer to simulate it before they actually implement it. (You should keep in mind that this situation is a little contrived, but real life situations often are so complex that you could not program a simulation in two weeks. This is just practice with a semi-complex situation.)
• When people walk in the door, they must wait in a line to sign in.
• Once the have signed in, they are told either to stand in line for registration renewal or to wait in a different line for license renewal.
• Once the have completed their desired transaction, they must go and wait in line for the cashier.
• When they finally get to the front of the cashier's line, if they expect to pay by check, they are told that all checks must get approved. To do this, it is necessary to go the the check-approver's table and then reenter the cashier's line at the end.
• They depart when they finish with the cashier.

Input
You will have an input file that will contain information about the people coming to the MVD. It will have:

• A desired transaction code (L for license renewal, R for registration renewal)
• A method-of-payment code ($ for cash, C for check)
• An arrival time(integer)
• A name (for simplicity, this will really just be a single character)

• Output the specifics of each event (time in, who, what, and so on), then display the final statistics:
• The total number of license renewals and the average time spent in MVD (arrival until completion of payment) to renew a license.
• The total number of registration renewals and the average time spent in MVD (arrival until completion of payment) to renew a registration.

Further details:   Incorporate the following details into your program:

• Define the following events: arrive, sign in, renew license, renew registration, and cope with the cashier (make a payment or find out about check approval). You should consider how you want to handle each event: a method, a class, etc.
• In the case of a tie, let the order of events be determined by the list of events just given--that is, arrivals have the highest priority.
• Assume that the various transaction take the following amounts of time

  Sign in				10 seconds
  Renew license			90 seconds
  Register automobile		60 seconds
  See cashier (payment)		30 seconds
  See cashier (check not approved)10 seconds

• For the sake of this simulation, you can assume that checks are approved instantly. Therefore, the rule for arriving at the front of the cashier's line with a check that has not been approved is to go to the back of the cashier's line with a check that has been approved.

Out-Lab 7--The Tortoise and the Hare
This lab will be due during the last week of class

Description

In this problem, you will re-create the classic race of the tortoise and the hare. You will use random-number generation to develop a simulation of the memorable event. This is more of a design problem, than a programming problem. Design carefully, and make the programming easier.

The race begins at square 1 of 70 squares. Each square represents a possible position along the race course. The finish line is at square 70. The first contender to reach or pass square 70 is rewarded with a pail of fresh carrots and lettuce. The course weaves it way up the side of a slippery mountain, so occasionally the contenders lose ground.

A clock ticks once per second. Withe each tick of the clock, your application should adjust the position of the animal according to the rules given below. Use variables to keep track of the positions of the animals. Start each animal at psotion 1. If an animal slips left before square one, move it back to square 1.

Generate the percentages below by producing a random integer i in the range 1 <= i <= 10. For the tortoise, perform a "fast plod" when 1 <= i <= 5, a " slip" when 6 <= i <= 7 or a'slow plod" when 8 <= i <= 10. Use a similar techinique to move the hare. Begin the race by displaying
BANG !!!
AND THEY'RE OFF!!!!

Then, for each tick of the clock (i.e. each repetition of a loop), display a 70-position line showing the letter T in the position of the tortoise and the letter H in the position of the hare. Occasionally, the contenders will land on the same square. In this case, the tortoise bites the hare, and your application should display OUCH! Beginning at that position. All output positions other than the T, the H, or the OUCH!!! (in case of a tie) should be blank.

After each line is displayed, test for whether either animal has reached or passed square 70. If so, display the winner and terminate the simulation. If the tortoise wins, display TORTOISE WINS!! If the hare wins, display Hare wins. If both animals win on the same tick of the clock, display It's a tie. If neither animal wins, perform the loop again to simulate the next tick of the clock.

Animal	Move type	Percent of the time	Actual Move
Tortoise	Fast plod Slip Slow plod	50% 20% 30%	3 squares to the right 6 squares to the left 1 square to the right
Hart	Sleep Big hop Big Slip Small hop Small slip	20% 20% 10% 30% 20%	No move at all 9 squares to the right 12 squares to the left 1 square to the right 2 squares to the left

Sample output This is shorter than most runs


BANG!!!!
AND THEY'RE OFF !!!!!

H  T                                                                  
H   T                                                                 
 H     T                                                              
          OUCH!!!                                                           
        H  T                                                          
        H     T                                                       
H              T                                                      
 H       T                                                            
H  T                                                                  
H   T                                                                 
H      T                                                              
         HT                                                           
       H   T                                                          
        H     T                                                       
        OUCH!!!                                                             
  T   H                                                               
     TH                                                               
    H T                                                               
       T     H                                                        
          TH                                                          
    T       H                                                         
     T       H                                                        
T             H                                                       
   T           H                                                      
      T                 H                                             
         T                       H                                    
            T                  H                                      
               T                H                                     
                T                H                                    
          T                       H                                   
           T                    H                                     
            T                 H                                       
               T                       H                              
         T                 H                                          
            T                       H                                 
               T                             H                        
                  T                           H                       
                     T                                 H              
                      T                              H                
                         T                            H               
                   T                                           H      
                      T                                      H        
                         T                                           H

Hare wins.

TIME ELAPSED = 43 seconds