Download Determinate Loops

Chapter 6
Repetition
Asserting Java
© Rick Mercer
Algorithmic Pattern:
The Determinate loop
 We often need to perform some action a specific
number of times:
—
—
—
Produce 89 paychecks.
Count down to 0 (take 1 second of the clock).
Compute grades for 81 students
 The determinate loop pattern repeats some action
a specific number of times.
Determinate Loops
 This template repeats a process n times (you fill in
the comments):
int n = /* how often we must repeat the process */
for( int j = 1; j <= n; j = j + 1 ) {
// the process to be repeated
}
—
determinate loops must know the number of
repetitions before they begin
• know exactly how many employees, or students, or
whatever that must be processed, for example
General Form
The Java for loop
for ( initial statement ; loop-test ;
•
repeated-part
}
—
update-step)
{
When a for loop is encountered, the initial-statement is
executed (used here quite often as int j = 1). The
loop-test evaluates. If loop-test is false, the for loop
terminates. If loop-test is true, the repeated-part
executes followed by the update-step.
Flow chart view of a for loop
Initial statement
True
False
Loop test
Iterative part
update-step
Example for loop that produces an
average
Scanner keyboard = new Scanner(System.in);
System.out.print("How many do you want to average? ");
int n = keyboard.readInt();
// Do something n times
for(int j = 1; j <= n; j = j + 1) {
System.out.print( "Enter number: " ); // <- Repeat 3
number = keyboard.nextInt( );
// <- statements
sum = sum + number;
// <- n times
}
double average = sum / n;
System.out.print( "Average of " + n + " numbers is "
+ average);
Demonstration
 Active Learning, Write the output :
int n = 5;
for(int j = 1; j <= n; j = j + 1) {
System.out.println(j);
}
for(int k = 10; k >= 0; k = k - 2) {
System.out.println(k);
}
Other Incrementing Operators
 It is common to see determinate loops of this form where
n is the number of repetitions
for( int j = 1; j <= n; j++ ) }
// ...
}
 The unary ++ and -- operators add 1 and subtract 1 from
their operands, respectively.
int n =
n++; //
n++; //
n--; //
0;
n is now 1 equivalent to n=n+1; or n+=1;
n is now 2
n is now 1 again
 The expression n++ is equivalent to n
= n + 1;
Other Assignment Operators
 Java has several assignment operators in addition
to = (-= and +=)
j -= 2; is the equivalent of j = j - 2;
sum += x; is the equivalent of sum = sum + x;
 What is sum when a user enters 7 and 8?
int sum = 0;
int x = 0;
System.out.print("Enter
x = keyboard.nextInt();
sum += x;
System.out.print("Enter
x = keyboard.nextInt();
sum += x;
a number: ");
// user enters 7
a number: ");
// user enters 8
While Loops and
Scanner Objects Constructed
with a String Argument
Determinate Loops with while
 The determinate loop pattern can be implemented with
the Java while loop
 This template repeats a process n times:
int n = /* how often we must repeat the process */
int counter = 1;
while ( counter <= n ) {
// the process to be repeated
counter = counter + 1;
}
—
determinate loops must know the number of repetitions before
they begin: know exactly how many employees, or students, or
whatever that must be processed, for example
Example for loop that produces an
average
Scanner keyboard = new Scanner(System.in);
double sum = 0.0;
double number;
System.out.print("How many do you want to average? ");
int n = keyboard.nextInt();
int counter = 1;
// Do something n times
while (counter <= n) {
System.out.print("Enter number: "); // <- Repeat 3
number = keyboard.nextDouble();
// <- statements
sum = sum + number;
// <- n times
counter = counter + 1; // make sure the loop stops
}
double average = sum / n;
System.out.print("Average of "+ n +" numbers is "+
average);
Active Learning
 What is the output :
int j = 1;
int n = 5;
while(j <= n) {
System.out.print (j + " ");
j = j + 1;
}
j = 0;
while(j <= 2 * n) {
System.out.print (j + " ");
j = j + 2;
}
Indeterminate Loops
 Determinate loops have a limitation
—
We must know n (the number of repetitions) in
advance
 Many situations need us to repeat a set of
statements an unspecified number of times:
—
—
—
Processing report cards for every student in a school
(or paychecks for all employees, or...)
Allowing 1 to many ATM transactions
Asking the user for specific input and allowing re-entry
of input after invalid inputs
Some things that terminate
indeterminate loops
 An indeterminate loop repeats a process until some
stopping event terminates the repetition
 There are many such events, but we'll focus on these:
—
—
—
—
User enters a special value indicating end of data
A logical expression becomes false
The Grid's mover hits the wall or an edge
The end of a file is encountered
 Indeterminate loops do not need to know n in advance
 Indeterminate loops can actually determine n
Pattern
Indeterminate loop
Problem
Some process must repeat an unknown number
of times so some event is needed to terminate
the loop.
Algorithm
while( the termination event has not occurred ) {
execute these actions
bring the loop closer to termination
}
Code
Example
while(myGrid.frontIsClear())
myGrid.putDown( );
myGrid.move( );
}
{
Example Indeterminate Loop
need Grid.java
// Using random robot placement, instruct robot to get to
// the wall in front, turn left, and move to the next wall
public class MoveAroundTheGrid {
public static void main(String[] args) {
Grid g = new Grid(10, 15);
while (g.frontIsClear()) {
g.move();
}
g.turnLeft();
while (g.frontIsClear()) {
g.move();
}
}
}
While loop with a Scanner
Sometimes a stream of input from the
keyboard or a file needs to be read until there
is no more data in the input stream
Consider a Scanner object constructed with a
String argument
—
The string represents an input stream
 You will need Scanner in project 2, methods 9
and 10: sumInScanner and maximumInScanner
These assertions pass
@Test
public void showScanner() {
Scanner scannerWithInts = new Scanner("1 2 3");
assertEquals(1, scannerWithInts.nextInt());
assertEquals(2, scannerWithInts.nextInt());
assertEquals(3, scannerWithInts.nextInt());
Scanner scanner =
new Scanner("There are five words here.");
assertEquals("There", scanner.next());
assertEquals("are", scanner.next());
assertEquals("five", scanner.next());
assertEquals("words", scanner.next());
assertEquals("here.", scanner.next());
}
A test method to test num100s
@Test
public void testNum100s() {
ControlFun cf = new ControlFun();
Scanner scanner0 = new Scanner("1 2 3");
Scanner scanner1 = new Scanner("4 100 2 5");
Scanner scanner3 =
new Scanner("100 100 2 -3 5 3 2 -100 100");
assertEquals(0, cf.num100s(scanner0));
assertEquals(1, cf.num100s(scanner1));
assertEquals(3, cf.num100s(scanner3));
}
Answer
public int num100s (Scanner scanner) {
int result = 0;
while (scanner.hasNextInt()) {
int next = scanner.nextInt();
if (next == 100)
result++;
}
return result;
}
Careful using next too often!
 These assertions should pass with the code that
follows on the next slide
@Test
public void testSumOfNegs() {
ControlFun cf = new ControlFun();
Scanner scanner0 = new Scanner("1 2 3");
Scanner scannerA = new Scanner("1 -2 3");
Scanner scannerB = new Scanner("-4 1 -2 3");
assertEquals(0, cf.sumOfNegatives(scanner0));
assertEquals(-2, cf.sumOfNegatives(scannerA));
assertEquals(-6, cf.sumOfNegatives(scannerB));
}
What's wrong with this method?
public int sumOfNegatives(Scanner scanner) {
int result = 0;
while (scanner.hasNextInt()) {
if (scanner.nextInt() < 0) {
result += scanner.nextInt();
}
}
return result;
}