Final Review-Spring 2007

1. If you don't post, neither will we. We will not be posting official solutions to these problems at all! If one of you gets it right, terrific!
2. We will try to always point out if an answer is wrong. We won't always point out when the answer is right.
3. We are glad to work with you toward the right answer. We will give hints, and I'm glad to respond to partial guesses.

Definition Time (Sorry this is a data structures course after all)

Writing methods on the Picture class

The following is the clearBlue() method of the class Picture.
/*** Method to clear the blue from the picture (set
 *the blue to 0 for all pixels*/
public void clearBlue()
{
  Pixel[] pixels = this.getPixels();
  Pixel pixel = null;
  int index = 0;

  while(index < pixels.length)
  {
    pixel = pixels[index];
    pixel.setBlue(0);
    index++;
  }
}

Public void vertical_stripes()
{

}

Draw the Tree

    public void setUp2() {
    FileChooser.setMediaPath("D:/cs1316/MediaSources/");
    Sound clap = new Sound(FileChooser.getMediaPath("clap-q.wav"));
    Sound chirp = new Sound(FileChooser.getMediaPath("chirp-2.wav"));
    Sound rest = new Sound(FileChooser.getMediaPath("rest-1.wav"));
    Sound snap = new Sound(FileChooser.getMediaPath("snap-tenth.wav"));
    Sound clink = new Sound(FileChooser.getMediaPath("clink-tenth.wav"));
    Sound clave = new Sound(FileChooser.getMediaPath("clave-twentieth.wav"));
    Sound gong = new Sound(FileChooser.getMediaPath("gongb-2.wav"));
    Sound guzdial = new Sound(FileChooser.getMediaPath("guzdial.wav"));
    Sound is = new Sound(FileChooser.getMediaPath("is.wav"));
   
    root = new SoundBranch();
    SoundNode sn;
    
    SoundBranch branch1 = new SoundBranch();
    sn = new SoundNode(guzdial.append(is).append(snap));
    branch1.addChild(sn);
    sn = new SoundNode(clink.append(snap).append(clave));
    branch1.addChild(sn);
    sn = new SoundNode(guzdial.append(is).append(is));
    branch1.addChild(sn);
    root.addChild(branch1);
 
    scaledBranch = new ScaleBranch(2.0);
    sn = new SoundNode(clink.append(clave).append(gong));
    scaledBranch.addChild(sn);
    sn = new SoundNode(rest.append(chirp).append(clap));
    scaledBranch.addChild(sn);
    root.addChild(scaledBranch);
    
    scaledBranch = new ScaleBranch(0.5);
    sn = new SoundNode(guzdial.append(is).append(gong));
    scaledBranch.addChild(sn);
    root.addChild(scaledBranch);

    SoundBranch branch2 = new SoundBranch();
    sn = new SoundNode(clap.append(clap).append(clave));
    branch2.addChild(sn);
    sn = new SoundNode(snap.append(snap).append(clave));
    branch2.addChild(sn);
    sn = new SoundNode(snap.append(snap).append(clave));
    branch2.addChild(sn);
    root.addChild(branch2);
    
    root.playFromMeOn();
  }

Draw a Wolf Tree

  public void setUp(){
    FileChooser.setMediaPath("D:/cs1316/mediasources/");
    Picture wolf = new Picture(FileChooser.getMediaPath("dog-blue.jpg"));
    Picture house = new Picture(FileChooser.getMediaPath("house-blue.jpg"));
    Picture tree = new Picture(FileChooser.getMediaPath("tree-blue.jpg"));
    Picture monster = new Picture(FileChooser.getMediaPath("monster-face3.jpg"));

    //Make the forest
    MoveBranch forest = new MoveBranch(10,400); // forest on the bottom
    HBranch trees = new HBranch(50); // Spaced out 50 pixels between
    BlueScreenNode treenode;
    for (int i=0; i < 8; i++) // insert 8 trees
    {treenode = new BlueScreenNode(tree.scale(0.5));
      trees.addChild(treenode);}
    forest.addChild(trees);
    
    // Make the cluster of attacking "wolves"
    wolfentry = new MoveBranch(10,50); // starting position
    VBranch wolves = new VBranch(20); // space out by 20 pixels between
    BlueScreenNode wolf1 = new BlueScreenNode(wolf.scale(0.5));
    BlueScreenNode wolf2 = new BlueScreenNode(wolf.scale(0.5));
    BlueScreenNode wolf3 = new BlueScreenNode(wolf.scale(0.5));
    wolves.addChild(wolf1);wolves.addChild(wolf2);wolves.addChild(wolf3);
    wolfentry.addChild(wolves);
    
    // Make the cluster of retreating "wolves"
    wolfretreat = new MoveBranch(400,50); // starting position
    wolves = new VBranch(20); // space them out by 20 pixels between
    wolf1 = new BlueScreenNode(wolf.scale(0.5).flip());
    wolf2 = new BlueScreenNode(wolf.scale(0.5).flip());
    wolf3 = new BlueScreenNode(wolf.scale(0.5).flip());
    wolves.addChild(wolf1);wolves.addChild(wolf2);wolves.addChild(wolf3);
    wolfretreat.addChild(wolves);
    
    // Make the village
    MoveBranch village = new MoveBranch(300,450); // Village on bottom
    HBranch hhouses = new HBranch(40); // Houses are 40 pixels apart across
    BlueScreenNode house1 = new BlueScreenNode(house.scale(0.25));
    BlueScreenNode house2 = new BlueScreenNode(house.scale(0.25));
    BlueScreenNode house3 = new BlueScreenNode(house.scale(0.25));
    VBranch vhouses = new VBranch(-50); // Houses move UP, 50 pixels apart
    BlueScreenNode house4 = new BlueScreenNode(house.scale(0.25));
    BlueScreenNode house5 = new BlueScreenNode(house.scale(0.25));
    BlueScreenNode house6 = new BlueScreenNode(house.scale(0.25));
    vhouses.addChild(house4); vhouses.addChild(house5); vhouses.addChild(house6);
    hhouses.addChild(house1); hhouses.addChild(house2); hhouses.addChild(house3);
    hhouses.addChild(vhouses); // Yes, a VBranch can be a child of an HBranch!
    village.addChild(hhouses);
    
    // Make the monster
    hero = new MoveBranch(400,300);
    BlueScreenNode heronode = new BlueScreenNode(monster.scale(0.75).flip());
    hero.addChild(heronode);
    
    //Assemble the base scene
    sceneRoot = new Branch();
    sceneRoot.addChild(forest);
    sceneRoot.addChild(village);
    sceneRoot.addChild(wolfentry);
  }

Understanding inheritance

public class Superhero {
  public String name;
  public int strength;
  public Superhero() {
    name = “Batman”;
    strength = 10;
  }
  public void introduce() {
    System.out.print(“Hello.  I am “ + name + “.  And “);
    if(strength < 15) {
      System.out.println(“I am weak.”);
    } else {
      System.out.println(“I am strong.”);
    }
}


public class  NinjaTurtle extends Superhero {
  public NinjaTurtle(int i) {
    super();
    String[] turtles = {“Leonardo”, “Donatello”, “Raphael”, “Michaelangelo”};

    name = turtles[i];
    strength = 25;
  }
  public void introduce() {
    System.out.println(“I’m “ + name);
  }
}

• LLNode is an abstract class that implements all of the basic functionality of a linked list.
• DrawableNode is a class that knows how to draw itself and also has linked list functionality.

abstract public class LLNode {

  /*The next branch/node/whatever to process*/
  public LLNode next;

  /*Constructor for LLNode just sets next to null*/
  public LLNode() {
    next = null;
  }

  /**
   *Methods to set and get next elements* @param nextOne next element in list
   */
  public void setNext(LLNode nextOne) {
    this.next = nextOne;
  }

  public LLNode getNext() {
    return this.next;
  }

  /*** Method to remove node from list, fixing links
   *appropriately* @param node element to remove from list.
   */
  public void remove(LLNode node) {
    /* assume you have working code here */
  }

  /*** Insert the input node after this node
   *@param node element to insert after this
   **/
  public void insertAfter(LLNode node) {
    /* assume you have working code here */
  }
} //end of LLNode class

public class DrawableNode {
  public DrawableNode next;

  /* Constructors */
  public DrawableNode() {
    next = null;
  }

  /* Methods */
  public void setNext(DrawableNode nextOne) {
    this.next = nextOne;
  }

  public Drawable getNext() {
    Return this.next;
  }

  public void remove(DrawableNode node) {
    /* Assume working code */

  public void insertAfter(DrawableNode node) {
    /* Assume working code */
  }
}// end of DrawableNode class

Make a Super Truck

import java.awt.Color; // For color

/**
 * Truck -- delivers product from Factory
 * to Warehouse.
 **/
public class Truck extends DEAgent {

  /////// Constants for Messages
  public static final int FACTORY_ARRIVE = 0;
  public static final int WAREHOUSE_ARRIVE = 1;

  ////// Fields /////
  /**
   * Amount of product being carried
   **/
  public int load;

  //// METHODS ///
  /** A new load is between 10 and 20 on a uniform distribution */
  public int newLoad(){
    return 10+randNumGen.nextInt(11);
  }

  /** A trip distance averages 3 days */
  public double tripTime(){
    double delay = randNumGen.nextGaussian()+3;
    if (delay < 1)
      // Must take at least one day
    {return 1.0+((DESimulation) simulation).getTime();}
    else {return delay+((DESimulation) simulation).getTime();}
  }
  /**
   * Set up the truck
   * Start out at the factory
   **/
  public void init(Simulation thisSim){
    // Do the default init
    super.init(thisSim);
    this.setPenDown(false); // Pen up
    this.setBodyColor(Color.green); // Let green deliver!

    // Show the truck at the factory
    this.moveTo(30,350);
    // Load up at the factory, and set off for the warehouse
    load = this.newLoad();
    ((DESimulation) thisSim).addEvent(
              new SimEvent(this,tripTime(),WAREHOUSE_ARRIVE));
  }

  /**
   * Process an event.
   * Default is to do nothing with it.
   **/
  public void processEvent(int message){
    switch(message){
      case FACTORY_ARRIVE:
        // Show the truck at the factory
        ((DESimulation) simulation).log(this.getName()+"\t Arrived at factory");
        this.moveTo(30,350);
        // Load up at the factory, and set off for the warehouse
        load = this.newLoad();
        ((DESimulation) simulation).addEvent(
              new SimEvent(this,tripTime(),WAREHOUSE_ARRIVE));
        break;
      case WAREHOUSE_ARRIVE:
        // Show the truck at the warehouse
        ((DESimulation) simulation).log(this.getName()+"\t Arrived at warehouse with load \t"+load);
        this.moveTo(50,50);
        // Unload product -- takes zero time (unrealistic!)
        ((FactorySimulation) simulation).getFactory().add(load);
        load = 0;
        // Head back to factory
        ((DESimulation) simulation).addEvent(
              new SimEvent(this,tripTime(),FACTORY_ARRIVE));
        break;
    }
  }

// CONSTRUCTORS GO HERE, BUT THEY’VE BEEN REMOVED FOR THE EXAM.
}

Binary Trees are Cute

Short Answer

Links to this Page

• Exam Reviews last edited on 4 December 2007 at 9:14 pm by c-76-17-114-206.hsd1.ga.comcast.net
• Announcements-Spring 2007 last edited on 24 April 2007 at 12:05 am by c-76-17-114-206.hsd1.ga.comcast.net
• Final exam review Spring2007: Definition Time last edited on 30 April 2007 at 9:14 am by c-71-236-23-184.hsd1.ga.comcast.net
• Final exam review Spring2007: Short Answer last edited on 25 April 2007 at 1:55 pm by c-76-17-114-206.hsd1.ga.comcast.net
• Final exam review Spring2007:Writing methods on the Picture class last edited on 28 April 2007 at 10:19 pm by not available
• FinalExam Review Spring2007: Draw the Tree last edited on 30 April 2007 at 1:29 pm by r67h50.res.gatech.edu
• FinalExam Review Spring2007: Draw a Wolf Tree last edited on 30 April 2007 at 9:59 am by c-71-236-23-184.hsd1.ga.comcast.net
• Final exam review Spring2007:Understanding inheritance last edited on 30 April 2007 at 12:18 pm by 207.151.194.102
• FinalExam Review Spring2007: Make a Super Truck last edited on 30 April 2007 at 10:23 am by r43h166.res.gatech.edu
• Final exam review Spring2007: Binary Trees are Cute last edited on 30 April 2007 at 11:14 am by r43h166.res.gatech.edu