Copyright © 1997, 2013
Robert W. Hasker

More on If, Loops

• Ch. 4

Switch statement

• Example: write a piece of code to tell user the number of apples in a crate.
• Pseudocode:

          print "there are "
          when napples
            = 2: print "a couple"
            = 3: print "a few"
            = 4, 5: print "several"
            > 5: print "many"
          print " apples in the crate"
  

• In Java:

          System.out.println("there are ");
          if ( napples == 2 )
             System.out.println("a couple");
          else if ( napples == 3 )
             System.out.println("a few");
          else if ( napples == 4 || napples == 5 )
             System.out.println("several");
          else
             System.out.println("many");
          System.out.println(" apples in the crate.");
  

• Alternative form: switch:

          System.out.println("there are ");
          switch ( napples )
          {
          case 2:
             System.out.println("a couple");
             break;
          case 3:
             System.out.println("a few");
             break;
          case 4:
          case 5:
             System.out.println("several");
             break;
          default:
             System.out.println("many");
          }
          System.out.println(" apples in the crate.");
  

• Notes about switch
  • if leave off break;, fall through to next case
  • default: all other cases
  • type of expression: integers, characters
    • Not Strings, floats

Event-driven While Loops

• Event-driven while loops: repeat action until event
  • general version of count-controlled, sentinel-controlled
• Example: compute pay for employees at $6.50 per hour
  • each time through: ask user if want to continue

    	more_employees <- true
    	while more_employees do
    	  read hours worked
    	  print pay ($6.50 per hour with no overtime pay)
    	  ask if want to process more employees
    

  • Implementation (might just point students to this on-line):

       public static void main(String[] args)
       {
          final double HOURLY_PAY = 6.50;
          double hours;
          boolean more_employees = true;		// assume at least 1 employee
          while ( more_employees )
          {
    	 System.out.print("Enter hours worked for next employee: ");
             hours = in.nextDouble();
    	 System.out.println("Pay: " + hours * HOURLY_PAY);
    	 System.out.print("Do you have more employees to pay? ");
    	 char resp = in.nextChar();
    	 more_employees = resp == 'y' || resp == 'Y';
          }
       }
    

  • Event: user enters n, more_employees becomes false.

    	initialize
    	while event not satisfied
    	   process
    	   check event
    

How to Write a While Loop

• Steps:
  1. identify exit condition: what must be true when exit loop
  2. write opposite form of step 1 as the condition of the while loop
     • loop will execute while test is true; i.e., it will execute as long as the exit condition has not been satisfied
  3. write pseudocode for loop body
     • make minimal progress towards goal
     • update loop control at end (counter, reading data)
     • will need braces if loop body contains more than one statement
  4. Add setup: initialization/read data
  5. Add cleanup: restore data, close files
• Example: count non-whitespace characters until have read 5 sentences:
  • steps:
    1. exit: num_periods == 5
    2. header: while num_periods < 5
    3. body: read and count char; if period, increment num_periods
    4. setup: init num_periods, char_count
    5. cleanup: print char_count
  • code:

            int char_count = 0, num_periods = 0;
            while ( num_periods < 5 )
            {
               char ch = in.nextChar();
               char_count++;
               if ( ch == '.' )
                  num_periods++;
            }
    

• Example: count numbers entered until they sum up to 1000:
  • Steps:
    1. exit: sum >= 1000
    2. condition: while sum < 1000
    3. body: read number, add to total, increment count
    4. setup: initialize sum, count
    5. cleanup: print result
  • code:

    	int sum = 0;
    	int count = 0;
    	while ( sum < 1000 )
    	{
    	   int num = nextInt();
    	   sum = sum + num;
    	   count++;
    	}
    	System.out.println("Number of numbers: " + count);
    

More Discussion

• Note the difference between an if statement and a while statement.
  • The if executes its action 0 or 1 times; the while an arbitrary number of times (including zero times).
• Note indentation; indent body of loop by one level.
• Note that while loops almost always use {} to control a series of statements.
  • However, the {} is optional.
• When to use control constructs?
  • 0 or 1 time: if statement
    • if an action takes place sometimes but not always, use one-legged if
    • if there are two alternative actions, use the full if
  • 0 or more times: while loop
    • if know number of times in advance: count-controlled
    • if process until event: event-controlled
    • if process until specific value: sentinel-controlled

Truth Tables and Equivalence

• write out truth tables for &&, ||, !
• !(a > b) equivalent to a <= b
• !!x is equivalent to x: prove with truth tables
• DeMorgan's Laws:
  • !(x && y) equiv to !x || !y
  • !(x || y) equiv to !x && !y
  • example: speed > 55 && speed < 75
    • negation: !(speed > 55) || !(speed < 75), or
      speed <= 55 || speed >= 75
  • prove one using truth tables

Examples

• issue: when to use count-controlled loop vs. sentinel-controlled vs. eof-controlled
• count guesses until guess height:

          read target
          read guess
          count = 1
          while guess != target
             count++
             read guess
          print count
  

• compute total hours of classes in which student is enrolled
• count number of consecutive sevens rolled
• compute checking account balance after series of credits and debits

Testing Logic

• issue: how to test programs, especially ones with if statements and loops?
  • "if it ain't tested, it's broke" (Pete Schumacher, Avista)
• if
  • code coverage or statement coverage: making sure each statement covered at least once
  • essentially, make sure tests cover case where condition is true and case where condition is false
• testing loops
  • executing loop body a "normal" number of times
  • executing loop body just once
  • not executing loop body at all
• try to force an infinite loop
• watch for off-by-one errors; execute it by hand to make sure!

More Difficult Examples

• count dice rolls until reach 7 or 11 (&& vs ||)
• compute bowling averages
  • input: lists of teams with "letter" for each team, -1 to mark end of each team list; example:

            3                       number of teams
            A 130 112 143 -1        team A (3 players)
            B -1                    team B (0 players!)
            C 180 201 145 115 -1    team C (4 players)
    

  • output: average for each team
  • twist: compute average for all teams
• determine bad batches of light bulbs
  • input: list of batches with observed lifetimes of sampled bulbs; -1 marks end of list; example:

            A 780 519 341 112 -1
            B -1
            C 1115 13 20 -1
    

  • output: names of batches with average lifetime less than MIN_AVE_LIFETIME

Short-circuit Evaluation

• look at

          if ( n != 0 && sum / n > 20 ) ...
  

  what would happen in n was 0?
  • in Java, second part not evaluated!
• likewise, with ||:

          if ( n == 0 || pow(pow(n, 0.5), n) > 200.0 ) ...
  

  • in Java, second part again not evaluated

Code Inspections

• Issue: testing can't catch everything, especially when loops involved
• alternative: code inspection/"desk checks"
  • examine each line of program on paper
  • compare program against algorithm
  • execute code by hand on small sample input
  • look for common mistakes:
    • mixing up < and <= or > and >=
    • loop limits "off-by-one"
    • integer division where floating-point division needed
  • in general: review logic of program
• suggestion: do before making sure program compiles
  • temptation when code doesn't compile: make random changes
  • the changes can often lead you further from a correct solution!
• (when permitted): do in teams
  • but not on programming assignments!!!

Review

• switch
• event-driven while loops
• 5 steps for writing a loop from scratch
• more on boolean expressions
• testing loops
• inspections