Raw scores for all exams have been posted. 

Please come and pick them up, at which point we can discuss:

(a) adjustments (via lab reports for that week)

(b) retakes (you can score 100, better score kept) 

Today I want to give an example of a retake, third exam. 

Problem One: Write a program that asks the user for an integer and then 
prints out the prime factorization of the number. For example, if the user
enters 300 program prints: 2 2 3 5 5.

Sean Chris Jeremy Thomas Will Danmiel Laura Noah Santiago 
Clayton Taylor Danny Seth Josh Andrew Jay Alex Andrzej Adam
Xinning Pong Anna Rishu Jiachen Brandon Maro Josh Troy Anthony
Dimas Creighton Austin Angely Donovan Jacob Alex Shichao Joel 
Ryan Hao Ethan Omar Chen Scott Rodrigo Sean Brad Nikita Megan
Sam Sam Wonyong?

  n > 1     n           f         n % f == 0      factorization 
-----------------------------------------------------------------
  true                                              [] 
  true    300           2            true           [2]
          150           2            true           [2 2]
           75           2            false          [2 2]
           75           3            true           [2 2 3]
           25           3            false          [2 2 3]
           25           4            false          [2 2 3]
           25           5            true           [2 2 3 5]
  true      5           5            true           [2 2 3 5 5]
  false     1          

ArrayList<Integer>() factorization = new ArrayList<Integer>(); 
for ( int n = Integer.parseInt(args[0]), f = 2; n > 1;       ) {
  if ( n % f == 0) {
    factorization.add( f ); 
    n = n / f;
     
  } else {
    f = f + 1;
  }  
}
System.out.println( factorization ); 

The code then is:

import java.util.*; 

class Program {
  public static void main(String[] args) {

    ArrayList<Integer> factorization = new ArrayList<Integer>();

    for ( int n = Integer.parseInt(args[0]), f = 2; n > 1;       ) {

      if ( n % f == 0) {
        factorization.add( f );
        n = n / f;

      } else {
        f = f + 1;
      } 
    }

    System.out.println( factorization );

    
  }
}

Compile and run to get:

Welcome to DrJava.  Working directory is C:\Users\dgerman\Desktop
> java Program 300
[2, 2, 3, 5, 5]
> java Program 27
[3, 3, 3]
> java Program 100007
[97, 1031]
> java Program 1111111
[239, 4649]
> 

The third exam is on 4/15.

I want to be able to sort (in more than one way) a sequence of objects. 

In this exercise we will model a game. 

A game has a few players. Players play with a dice. 

Let's design the dice:

  -- a dice produces a number between 1 and 6 (random, integer)

class Dice {
  // provide code here
  public static void main (String[] args) {
    Dice d = new Dice(); 
    for (int i = 0; i < 20; i++) {
      System.out.print(d.roll() + " "); 
    } 
  }  
}

Compile run and you get 

 1 6 5 2 4 5 1 2 6 3 4 2 5 3 1 2 4 3 6 5 


class Dice {
  public int roll() {
    return (int) (Math.random() * 6) + 1;  
  }
  public static void main (String[] args) {
    Dice d = new Dice();
    for (int i = 0; i < 20; i++) {
      System.out.print(d.roll() + " ");
    }
  }
}

Let's define Player such that

class Player {
  // your code here
  public static void main(String[] args) {
    Player p = new Player("Adrian"); 
    System.out.println( p ); // Adrian [] false 
    p.add( 4 ); 
    System.out.println( p ); // Adrian [4] false 
    p.add( 6 ); 
    System.out.println( p ); // Adrian [4 6] false 
    p.add( 5 ); 
    System.out.println( p ); // Adrian [4 6 5] false 
    p.add( 6 ); 
    System.out.println( p ); // Adrian [4 6 5 6] true 
    p.add( 1 ); 
    System.out.println( p + " " + p.score()); // Adrian [4 6 5 6 1] true 22 
    p.add( 3 ); 
    System.out.println( p + " " + p.isWinner()); // Adrian [4 6 5 6 1 3] true true 

  } 
}

Let's design like so: 

class Player {
  String name; 
  ArrayList<integer> scores; 
  Player(String name) {
    this.name = name;
  }
  void add(int number) {
    this.scores.add( number );     
  }
  int score() {
    int sum = 0; 
    for (Integer num : this.scores) {
      sum = sum + num; 
    }
    return sum;
  }
  boolean isWinner() {
    return this.score() >= 21;
  }
}

Here's the final implementation:

import java.util.*; 

class Player {
  String name;
  ArrayList<Integer> scores = new ArrayList<Integer>();
  Player(String name) {
    this.name = name;
  }
  void add(int number) {
    this.scores.add( number );
  }
  int score() {
    int sum = 0;
    for (Integer num : this.scores) {
      sum = sum + num;
    }
    return sum;
  }
  boolean isWinner() {
    return this.score() >= 21;
  }
  public String toString() {
    return this.name + " " + this.scores + " " + this.score() + " " + this.isWinner();  
  }
  public static void main(String[] args) {
    Player p = new Player("Adrian"); 
    System.out.println( p ); // Adrian [] false 
    p.add( 4 ); 
    System.out.println( p ); // Adrian [4] false 
    p.add( 6 ); 
    System.out.println( p ); // Adrian [4 6] false 
    p.add( 5 ); 
    System.out.println( p ); // Adrian [4 6 5] false 
    p.add( 6 ); 
    System.out.println( p ); // Adrian [4 6 5 6] true 
    p.add( 1 ); 
    System.out.println( p + " " + p.score()); // Adrian [4 6 5 6 1] true 22 
    p.add( 3 ); 
    System.out.println( p + " " + p.isWinner()); // Adrian [4 6 5 6 1 3] true true 
    
  } 
  
}

Now let's look at the Game abstraction:

import java.util.*;

class Game {
  ArrayList<Player> players;
  Dice d = new Dice();
  Game(ArrayList<Player> players) {
    this.players = players;
  }
  void start() {
    while (true) {
      for (Player p : players) {
        p.add(d.roll());
        System.out.println(p);
        if (p.isWinner())
          return;
      }
    }
  }
  public static void main(String[] args) {
    ArrayList<Player> players = new ArrayList<Player>();
    for (int i = 0; i < args.length; i++)
      players.add(new Player(args[i]));
    Game a = new Game(players);
    a.start();
  }
}

--