CS 46A - Lecture 15

Pre-class reading

• Section 6.3

Common Loop Algorithm: Computing a Total

• Example — keep a running total: a variable to which you add each input value:

  double total = 0; 
  while (in.hasNextDouble()) 
  { 
     double input = in.nextDouble(); 
     total = total + input; 
  }

Common Loop Algorithm: Counting Matches

• Example — count how many uppercase letters are in a string:

  int upperCaseLetters = 0; 
  for (int i = 0; i < str.length(); i++) 
  {
     char ch = str.charAt(i); 
     if (Character.isUpperCase(ch)) 
     { 
        upperCaseLetters++; 
     } 
  }

Lecture 15 Clicker Question 1

What is wrong with this algorithm to find the average of a set of scores?

int total = 0; 
int count = 0;
while (in.hasNextInt()) 
{ 
   int input = in.nextDouble(); 
   total = total + input; 
   count++;
}
double average = total / count;

1. The code won't compile
2. An exception will occur when there is no input
3. The average will not always be calculated correctly
4. Both 2 and 3

Common Loop Algorithm: Finding the First Match

• Example — find the first lowercase letter in a string:

  boolean found = false; 
  char ch = '?'; 
  int position = 0; 
  while (!found && position < str.length()) 
  { 
     ch = str.charAt(position); 
     if (Character.isLowerCase(ch)) { found = true; } 
     else { position++; } 
  }

Lecture 15 Clicker Question 2

What are the values of found, ch, and position when the algorithm has finished processing the string FRED?

1. found = false, ch = ?, position = 5
2. found = false, ch = d, position = 4
3. found = false, ch = ?, position = 4
4. found = true, ch = d, position = 5

Common Loop Algorithm: Prompting Until a Match is Found

• Example — Keep asking the user to enter a positive value < 100 until the user provides a correct input:

  boolean valid = false; 
  double input; 
  while (!valid) 
  { 
     System.out.print("Please enter a positive value < 100: "); 
     input = in.nextDouble(); 
     if (0 < input && input < 100) { valid = true; } 
     else { System.out.println("Invalid input."); } 
  }

Common Loop Algorithm: Comparing Adjacent Values

• Example — check whether a sequence of inputs contains adjacent duplicates such as 1 7 2 9 9 4 9:

  double input = in.nextDouble(); 
  while (in.hasNextDouble()) 
  { 
     double previous = input; 
     input = in.nextDouble(); 
     if (input == previous) { System.out.println("Duplicate input"); } 
  }

Lecture 15 Clicker Question 3

What happens with the algorithm "Comparing Adjacent Values" when only one input is provided?

1. The algorithm will falsely report an adjacent duplicate
2. The algorithm will report that there is no adjacent duplicate
3. The algorithm will report nothing at all
4. An exception will occur

Common Loop Algorithm: Processing Input with Sentinel Values

• Example — process a set of values
• Sentinel value: Can be used for indicating the end of a data set
• 0 or -1 make poor sentinels; better to use Q:

  System.out.print("Enter value, Q to quit: ");
  String input = in.next();
  if (input.equalsIgnoreCase("Q"))
     We are done
  else
  {
     double x = Double.parseDouble(input);
     . . .
  }

Loop and a Half

• Sometimes termination condition of a loop can only be evaluated in the middle of the loop
• Then, introduce a boolean variable to control the loop:

  boolean done = false;
  while (!done)
  {
     Print prompt
     String input = read input;
     if (end of input indicated)
        done = true;
     else
     {
        Process input
     }
  }

ch06/dataset/DataAnalyzer.java

import java.util.Scanner;

/**
   This program computes the average and maximum of a set
   of input values.
*/
public class DataAnalyzer
{  
   public static void main(String[] args)
   {  
      Scanner in = new Scanner(System.in);
      DataSet data = new DataSet();

      boolean done = false;
      while (!done)
      {  
         System.out.print("Enter value, Q to quit: ");
         String input = in.next(); 
         if (input.equalsIgnoreCase("Q"))
            done = true;
         else
         {  
            double x = Double.parseDouble(input);
            data.add(x);
         }
      }

      System.out.println("Average = " + data.getAverage());
      System.out.println("Maximum = " + data.getMaximum());
   }
}

ch06/dataset/DataSet.java

/**
   Computes information about a set of data values.
*/
public class DataSet
{
   private double sum;
   private double maximum;
   private int count;

   /**
      Constructs an empty data set.
   */
   public DataSet()
   {
      sum = 0;
      count = 0;
      maximum = 0;
   }

   /**
      Adds a data value to the data set
      @param x a data value
   */
   public void add(double x)
   {
      sum = sum + x;
      if (count == 0 || maximum < x) maximum = x;
      count++;
   }

   /**
      Gets the average of the added data.
      @return the average or 0 if no data has been added
   */
   public double getAverage()
   {
      if (count == 0) return 0;
      else return sum / count;
   }

   /**
      Gets the largest of the added data.
      @return the maximum or 0 if no data has been added
   */
   public double getMaximum()
   {
      return maximum;
   }
}

Program Run:

• Enter value, Q to quit: 10
  Enter value, Q to quit: 0
  Enter value, Q to quit: -1
  Enter value, Q to quit: Q
  Average = 3.0
  Maximum = 10.0

Lecture 15 Clicker Question 4

   public void add(double x)
   {
      sum = sum + x;
      if (maximum < x) maximum = x;
      count++;
   }

What is the effect of this change?

1. The maximum will still be correct for all inputs
2. The maximum will be incorrect for all inputs
3. The maximum will be incorrect when no inputs are provided
4. The maximum will be incorrect if all inputs are negative