1. Sat Apr 27 I will have office hours from 2-4pm in LH016.

2. Sun Apr 28 I will have office hours 6-8pm in LH016.

1. A final exam from the past.
2. Another final exam from the past.
3. More to come soon (warmups, such as this, with solutions, from the book).

Here's the code for the game.

Here are some notes that build towards it:

1. Basic Java
2. Animation
3. Sprites
4. Interactivity
5. BitmapLoops
6. A Video Game

Here's to get us started on I/O and basic networking.

WHAT

Midterm Two Make-Up

WHEN

Tuesday April 23

WHERE

SWAIN WEST 119

WHAT TIME

7:15pm - 9:15pm

(1 + 1) * 2 + 2 * ( 1 + 1 )

So the code more or less becomes (only an if statement changes):

static boolean reducePlusesAndMinuses(Vector expr) {
    boolean done = true; 

    for (int i = 0; i < expr.size(); i++) {

        if (expr.elementAt(i).equals("+") || expr.elementAt(i).equals("-")) { 

            if (
                // value to its left
                isValue((String)expr.elementAt(i - 1)) && 
                // value to its right                 
                isValue((String)expr.elementAt(i + 1)) && 

                // and not a higher priority operator to wait on 
                ! ( ( // value on left not at end of vector 
                      (i - 2) >= 0 && 
                      // higher precedence operator waiting there 
                      ( ((String)expr.elementAt(i - 2)).equals("*") ||
                        // note there are two such operators 
                        ((String)expr.elementAt(i - 2)).equals("/")
                      ) 

                    ) // this can happen on the left 

                    || // or (it can happen on the right)

                    ( // value on right not at end of vector 
                      (i + 2) < expr.size() && 
                      // higher precedence operator waiting there 
                      ( ((String)expr.elementAt(i + 2)).equals("*") ||
                        // note there are two such operators 
                        ((String)expr.elementAt(i + 2)).equals("/")
                      )

                    )
                  ) 


               ) {

                Integer a = new Integer((String)expr.elementAt(i - 1)); 
                Integer b = new Integer((String)expr.elementAt(i + 1)); 

                // ... reduce the plus sign 

Second Midterm MAKE-UP EXAM will likely be held in

Swain West 119 on
Tue Apr 23 7:15pm-9:15pm.

(2+4)*2+3*(3+7)

import java.io.*; 
import java.util.*;

class Eval {

    /* this Hashtable must be shared between two static methods 
       (main, which creates it and process, which is using it 
       for lookup,) so it must be global enough */
    static Hashtable env = new Hashtable(); 

    // here's the main method getting away with a try/catch
    public static void main(String[] args) throws IOException {
	
        //this is why we need to acknowledge the IOException
	BufferedReader console = 
	    new BufferedReader
		(new InputStreamReader(System.in));       

        //checked after the loop, must be visible enough
	String line; 
	
	do {
            //prompt
	    System.out.print("Eval> "); 
            //... and read
	    line = console.readLine(); 
  
            //stop if you have to	    
	    if (line.equals("bye")) break; 

            //get ready to take things apart
	    StringTokenizer st = new StringTokenizer(line); 

            //prepare the storage for the resulting tokens
	    Vector v = new Vector(); 

            //and now just do it
	    while (st.hasMoreTokens()) {
		v.addElement(st.nextToken()); 
	    }
            //so now the tokens are in a Vector, v


            //could be an assignment statement
            if (v.size() > 2 && v.elementAt(1).equals("=")) { 

                //in which case you take the name at the front
		String name = (String)(v.elementAt(0)); 
                //... and keep it in the variable called 'name'

                //then remove the string and the equal sign 
		v.removeElementAt(1); 
		v.removeElementAt(0); 
                //the Vector is shrinking as you remove elements so,
                //either remove backwards or twice at index 0 (zero)!

                //now process the remaining expression and store the 
                // value in the Hashtable in the entry for the name 
                // you found in position 0 in the original Vector
		env.put(name, Eval.process(v));


            } else {// if it's not an assignment statement,
              
              // ... then you can start evaluating it
              Eval.process(v); 


            }//end of conditional processing

            // getting ready to report the result
	    System.out.print("Done: ");
            Eval.show(v); //the Vector is shown here

	} while (true);//loop if you have to (exit with break!)
	
    }// end of main

    // straghtforward procedure for showing a Vector
    static void show(Vector v) {
	for (int i = 0; i < v.size(); i++) {
	    System.out.print(" " + v.elementAt(i)); 
	}
	System.out.println(); 
    }

    // this is the heart of the evaluator
    static String process (Vector v) {// receives the Vector as a param

        // wishful thinking (see do/while test below)
	boolean finished = true; 

        // first replace identifiers by their values
	for (int i = 0; i < v.size(); i++) {
            // get the String that's there (position i)
            // this could be anything: +, -, 123, a, *
	    String element = (String) (v.elementAt(i));
            // look it up in env (nevermind how it got there)
	    Object value = env.get(element); 
            // if you find it, there's a value associated with  
	    if (value != null) {
                // replace it (index i) by the value it has
		v.setElementAt((String)value, i); 
	    }

	}// all identifiers have been replaced

        // we're ready for the real processing

	do {

            // remove parens and update your agenda
	    finished = Eval.removeParens(v); 
            // all three methods used here return true when
            // they could not find anything to work on within 
            // the expression, and they return false if they 
            // could change it in at least one aspect; therefore 
            // your hope of being finished is true only when none 
            // of the workers find anything to work on...
	    finished = finished && Eval.removeStars(v); 
	    finished = finished && Eval.removePluses(v);

            // report the current status of the Vector
            // from within the process of changing it 
	    System.out.print("Processing: "); Eval.show(v);  

	} while (! finished); // if not finished keep going...

        // return the first element in the resulting Vector
        return (String) (v.elementAt(0)); 

    }

    static boolean removeParens(Vector v) { 
        // empty procedure, reports true
	return true; 
        // this means it 'thinks' it's done...
    }

    static boolean removeStars(Vector v) { 
        // same here, you need to provide these methods... 
	return true; 
    
    }

    static boolean removePluses(Vector v) { 
        // the only one that works 
	boolean done = true;// assume nothing will have to be done 

        // look everywhere in the Vector
	for (int i = 0; i < v.size(); i++) {
 
            // if you find a plus sign 
	    if (v.elementAt(i).equals("+")) { 

                done = false; // there's work to be done 

                // expect two numbers on its sides
		int n = Integer.parseInt((String) (v.elementAt(i - 1))), 
		    m = Integer.parseInt((String) (v.elementAt(i + 1))); 

                // store the sum where the first operand was 
		v.setElementAt((n + m) + "", i - 1); 
               // carefully remove the plus and the second operand
		v.removeElementAt(i + 1);
		v.removeElementAt(i); 

                // don't skip the next token 
		i -= 1; 
                // the Vector has shrunk so it's in front 
                // of you, and the for loop will increment i by default 

	    }// end of determining if you're looking at a '+' sign

	}// end of the for loop

	return done; // report whether we're done or not 

    }// end of the removePluses method

}// end of story

Wed Apr 17

Grades for the Second Midterm have been posted this morning.

Lecture notes for the week posted.

Lecture, lab notes for today posted.

The test is WEDNESDAY APRIL 3 (THREE), in RH100, between 7-9pm.

Note that correct answers are included.

The average of practical grades was 80.82, with a standard deviation of 14.79.

import java.io.*; 

public class PracticalTest {
    public static void main(String[] args) {
        
        ConsoleReader c = new ConsoleReader(System.in); 
        System.out.print("Enter the card notation: "); 
        String hand  = c.readLine(); 
        
        String two = card(hand); 
        suit(two); 
    }
    
    
    public static String card(String card) {
        String one = card.substring(0,1);
        String two = card.substring(1,2);
	
        if      (one.equalsIgnoreCase("A"))  System.out.print("Ace of ");
        else if (one.equals("2"))            System.out.print("Two of ");
        else if (one.equals("3"))            System.out.print("Three of ");
        else if (one.equals("4"))            System.out.print("Four of ");
        else if (one.equals("5"))            System.out.print("Five of ");
        else if (one.equals("6"))            System.out.print("Six of ");
        else if (one.equals("7"))            System.out.print("Seven of ");
        else if (one.equals("8"))            System.out.print("Eight of ");
        else if (one.equals("9"))            System.out.print("Nine of ");
        else if (one.equals("1"))  {
            if (two.equals("0")) { 
                System.out.print("Ten of ");
                two = card.substring(2, 3); 
            }
        } 
        else if (one.equalsIgnoreCase("J"))  System.out.print("Jack of ");
        else if (one.equalsIgnoreCase("Q"))  System.out.print("Queen of ");
        else if (one.equalsIgnoreCase("K"))  System.out.print("King of ");
        else System.out.print("Unknown denomination of "); 
	
        return two;
    } 
    
    public static void suit (String two){
	
        if      (two.equalsIgnoreCase("D")) System.out.println("diamonds.");
        else if (two.equalsIgnoreCase("H")) System.out.println("hearts.");
        else if (two.equalsIgnoreCase("S")) System.out.println("spades.");
        else if (two.equalsIgnoreCase("C")) System.out.println("clubs.");
        else System.out.println("unknown colour."); 
    }
}

Lab Notes Nine and Lecture Notes Nineteen (for after the break) already posted.

Here's the code we developed in class yesterday.

class One {
  public static void main(String[] args) {
    ConsoleReader console = new ConsoleReader(System.in);
    int[] b; 
    System.out.print("Size> "); 
    int n = console.readInt(); 
    b = new int[n];
    Cookbook.show(b);
    Cookbook.squares(b); 
    Cookbook.show(b);

    b = Cookbook.insert(b, 3, 13); 

    Cookbook.show(b);

  }
} 

class Cookbook { 
  static void show(int[] a) {
    for (int i = 0; i < a.length; i++) 
      System.out.print(a[i] + " "); 
    System.out.println(); 
  }

  static void squares(int[] a) {
    for (int i = 0; i <= a.length - 1; i++) { 
      a[i] = (i + 1) * (i + 1); 
    }
  }

  static int[] insert(int[] x, int ind, int val) {

    int[] temp = new int[x.length + 1]; 

    for (int i = 0; i < ind; i++) 
      temp[i] = x[i]; 

    temp[ind] = val; 

    for (int i = ind; i < x.length; i++) 
      temp[i + 1] = x[i]; 

    return temp; 

  }

}

I have received a few messages asking me about this week's lab. This week we have labs as usual, except I am aware this week is a bit different, so let me explain what the difference is.

If you can't make it to the lab this week you will have to make it up the week after the break. The notes will be posted soon, in class you will be asked about the problems on the practical a week ago. That's basically it about the lab this week.

I am still working on the grades for the practical. I hope to have them posted at the end of the week at the latest. I have two more sections to grade. I'll try to post the grades for the makeup as well before the week is over.

In class we will continue to solve problems. Please keep up though with the posted notes. You have now seen most of Chapter Seven, and the notes for today summarize all known aspects. You have also seen recursion and the notes end with a neat example of using recursion to solve a difficult problem. You also should be in command of all of Chapter Three and the notes posted for the lecture two days ago go through the development of a Fraction type that should be instructive.Fractions are like BigIntegers (i.e., precise and neat).

The review session is in Rawles Hall at 7pm, we will solve problems.

For problems from chapter 6 check the notes, and list of problems posted.

(Links to chapter 5 problems are in here, as you probably already know).

Lecture notes for tomorrow posted.

Wed Feb 27 7pm Practical Exam Review

Wed Mar 6 7-9pm Midterm One Makeup Exam

Also a reminder: documentation about all of the Java classes that will be used this semester available under Useful Links (click on Hierarchy). Sun's Java tutorial is available here.

Here's the distribution of (raw) scores:

50 ***
49 ******
48 *******
47 ****
46 ********
45 ******
44 *******
43 ****
42 *****
41 *************
40 *********
39 *********
38 ********
37 ******
36 ********
35 ************ 
34 *******
33 *****
32 ****
31 *******
30 ****
29 ******
28 *******
27 ********
26 *****
25 ********
24 *****
23 ****
22 *******
21 *****
20 ****
19 **
18 *
14 **

Please bring a pencil with you for the scantrons.

Exam consists of about 52 multiple-choice questions.

Good luck and see you tonight.

Second, when you approach the Practice Quizzes and the Sample Midterm please approach them as Learning Tools, not as instruments of testing. Use them to learn something new, not to measure how much you know. You should be happy if you cannot solve any of the problems by yourself at first, but are able to understand why the right answer is as indicated. This means that you have learned something in the process, that will help you on the exam.

Remember that the exam on Wednesday is open-book, open-notes, but individual work.

Skip questions 31, 32, 38-42 (inclusive), 46, and 47.

All the others make for a very good study material for the exam on Wednesday.

Please note that correct answers are clearly indicated, for your convenience.

Also, don't forget your exam on Wednesday is open-book, and open-notes.

(This justification developed with Omar Khan during office hours).

Say we need random numbers between a, and b, where a is less than b. Let y be such a random number. Then we can calculate how far into the segment y is, as a percentage.

double p = (y - a) / (b - a); // [1]

Well, such numbers can be generated with Math.random().

So, let's turn [1] on its head, to obtain y as a function of p.

Then, we have:

y = p * (b - a) + a; 

y = (b - a) * Math.random() + a;

Please note the unusual date and time and procedure for turning in Lab Assignment Five.

Lab Notes for this week posted, contain Lab Assignment Five.

1. The intersection method in class Rectangle does not return a valid (that is, meaningful) answer when the Rectangles don't overlap. (This is what the book says too, but one needs to read even the text of the problem with care!). So what do we do when they don't overlap and how do we know that in advance? The solution is to check if they overlap before you calculate the intersection (which you should do only if they overlap!).

2. The epsilon variable is needed in Fourteen of the Problem Set One (with solutions) so we don't divide by 0 (zero). But when x is negative and much smaller than epsilon the result is incorrect. What do we do? (This is problem P2.18 page 99 in the book). The trick is to think of the problem in physical terms: if you're really using a car and if in your calculations you use an epsilon that is small enough, e.g. about 0.1in (or smaller, like 0.001 of the car's length) then

1. for negative x above this small value the formula says: "You will make it!"
2. and for all practical purposes that's correct, since you can walk that distance
3. but we need to be aware of the approximation, we definitely need to!

Other than this "negative micron" case, the formula is perfect.

But does anyone have a formula that covers even this case with accuracy?

• Strings (Section 2.6, pp. 75-81)
• Decisions (pp. 184-186)
• The boolean primitive type (pp. 207-210)
• The char primitive type (pp. 731-733)
• An Introduction to Classes (pp. 103-120, 126-130)

By the end of the week we should have covered all of Chapter Three.

Also, please let me know if you appear listed in the wrong section. If you are listed in the wrong section please send me an e-mail message so I can make the correction, and wait for a confoirmation from me before submitting your homework assignment.

Date: Mon, 21 Jan 2002 13:16:45 -0500 (EST)
From: Adrian German 
To: Undisclosed recipients:  ;
Subject: A201/A597/I210 Update


First of all if you receive this message in error please let me
know also so I can update my e-mail distribution list.

Dear A201/A597/I210 friends,

I went to the bookstore and bought a new book that comes with a
CD. On the CD there's Sun's Java 2 SDK. I just tried installing
it and it only took me a few minutes. Those who still can't get
Emacs or Sun's JDK installed from the web are welcome to borrow
this CD from me and use it to install SDK. (SDK is the new name
for JDK 1.3, so it's basically the same and with it you will be
able to run javac and java from the command line).

I also wanted to review the reading assignments from the book:

a) tomorrow in class we will do mostly 2.5, 2.6, 2.7, and solve
problem P2.19 (Problem 15 in the set posted with Lab Two Notes)
You would also do well to review some of the warmups (that have
also been posted with Lab Notes Two, with solutions). This last
set (of warmups) can be found in the book on pp. 92-94.

c) on Thursday we plan to introduce the boolean type as part of
our discussion on expressions, types, and operators. We'll talk
about this again when we study chapter 5, and I will post a set
of warmups and programming problems at that time, also.

b) to review what has been already covered, one should focus on
sections 1.7-12, 2.1-3 (including Common Error 2.1, Quality Tip
2.1, Advanced Topic 2.1-4, Common Error 2.2 and Prod. Hint 2.1)

d) next week we start Chapter 3, user-defined classes. I posted
lecture notes Seven already, which correspond to sections 3.1-4
from the book.

Hope this helps. If you have questions, or if you need any help
please let me know.

... Adrian

The Lab Assignment is due next lab (Thu-Fri) as indicated on the What's Due? page.

(Please note we use dgerman-I210 for the name of the class account).

I am also going to assemble a list of A201 tutors.

Here's an interesting problem courtesy of Wendy Clendening:

public class Math {
  public static void main(String[] args) {
    int a = 5;
    int b = 7; 
    System.out.println(Math.max(a, b)); 
  }
} 

Remember that no editor (or any Java IDE for that matter) is Java. What we mean by Java is essentially encapsulated in two programs: javac and java. The rest is ancillary material related to development. But Emacs is the superior editor!

Please check the "What's Due?" page frequently also.

One is trying to describe the nature of programming as being a field in which (like any other science) solving problems (and enjoying it) is the way to go.

The other one is trying to put into a broader perspective the rigour (or precision) with which you will be confronted in this class, and in other classes, throughout your college years.

With your permission, I hope you find them useful.

The single most significant set of notes for this semester will be Sum 2001.

Here's the link to Sun's website, as well.

Lecture notes for this week, next, lab notes for today, posted.