Loops We have already seen instances where a robot needs to repeat instructions to perform a task turnRight(); moveMile(); Harvesting beepers in a field By defining new instructions we have been able to minimize repetitive instructions runMarathon();

Loops for known number of repetitions There are times when you know how many times an instruction needs to be repeated… turnRight() is always 3 left turns moveMile() is always 8 moves() Method turnRight() with a loop: void turnRight() { for (int count = 0; count < 3; count++) { turnLeft(); }

FOR loop: General form for (int count = 0; count < <numberOfTimes>; count++) { <instruction-list>; } int count: count is the name of a variable that stores integers (whole numbers); it’s initial value is 0 count < <numberOfTimes> : as long as the current value of count is less than the number of loops we want, we keep looping; count will be equal to the number of loops we wanted when the loop is finished count++: we increment (add 1 to) the value of count <instructions>: Any valid robot instructions, including other loops

FOR loop: Other examples void moveMile() { for (int count = 0; count < 8; count++) { move(); } Harvester Karel = new Harvester(2, 2, East, 0); for (int count = 0; count < 3; count++) { Karel.pickTwoRows();

FOR loop: What does this do? void whatDoIDo() { for (int count = 0; count < 4; count++) { for (int count2 = 0; count2 < 6; count2++) { move(); } turnLeft();

Loops for an unknown number of repetitions Suppose we know we want a robot to repeat a series of instructions, but we do not know how many times… Task: There is a beeper somewhere on the same street in front of the robot, but we do not know exactly where… How does the robot find the beeper? FOR loop requires an upper limit (and there is no guarantee the beeper will fall within the range) IF statements are a one-time execute statement We need something to combine the testing ability of the IF statement with the iteration of a FOR loop

WHILE loop: General form while ( <test> ) { <instruction-list>; } Reserved word while starts the instruction, parentheses enclose the <test> , and braces enclose the <instruction-list>; in the usual way <test>: The same conditions used in the IF instructions A robot starts the loop by checking the <test> in it’s current situation If TRUE, the robot executes the <instruction-list>; and rechecks the situation If FALSE, the robot executes instructions that follow the WHILE loop

WHILE loop: find the beeper class BeeperFinder extends Robot { // usual constructor // assumes no intervening wall segments void findBeeper() { while (! nextToABeeper()) { move(); }

WHILE loop: Clear a corner A robot is on a corner that may or may not have beepers on it. The robot is to make sure that the corner is clear of all beepers // fill in the blanks void clearCorner() { while ( _____________________) { _____________________; }

Build a WHILE loop: 4 step process When a robot has to do something an unknown number of times (clear a corner of beepers) Step 1: Identify the one test that must be true when the robot is finished with the loop ! nextToABeeper() Step 2: Use the opposite form of the test nextToABeeper() Step 3: Within the WHILE, make progress toward completion of the WHILE pickBeeper() Step 4: Do whatever you need to do before or after the loop to complete solving the problem For this problem, nothing else needs to be done

Clear all beepers to a wall A robot is somewhere in the world facing south. One beeper is on each corner between the robot’s current position and the southern boundary wall. There is no beeper on the corner the robot is currently standing. Write a new method, clearAllBeepersToTheWall(), to pick up all of the beepers Download BeeperSweeper Demo

Is the loop correct? We cannot test all possible solutions We have to convince ourselves the method is correct Step 1: Show the method works correctly when the initial situation results in the test being false Step 2: Each time the loop body executes, the robot’s new situation is simpler and similar to the original situation

Errors to avoid with WHILE loops The fence post problem In order to have five sections of fence, how many fence posts do we need? We often encounter the fence post problem when working with WHILE loops Re-examine BeeperSweeper, in which the robot has a beeper on the corner he starts from

Errors to avoid with WHILE loops Infinite Execution Look at the following loop while ( facingNorth()) { pickBeeper(); move(); } Think of step 3 in building loops (Within the WHILE, make progress toward completion of the WHILE). Is this happening here? What will happen to the robot is he is not facing north? If he is facing north?

Errors to avoid with WHILE loops When is the test of a WHILE loop checked? while (nextToABeeper()) { pickBeeper(); move(); } If there is more than one beeper on a corner, will the robot pick them all before moving on? The robot checks the <test> only before it executes the <instruction-list>, not after each instruction in the list The body of a while is like a fence section, and the test is the fence post. The number of test evaluations is always one more then the number of executions of the body of the WHILE instruction

Nested WHILE loops Look again at BeeperSweeper Instead of just one beeper per corner, there can be any number (possibly 0, but less than infinite) beepers on a corner

WHILE and IF instructions What will happen with this code fragment? if (facingSouth()) { while (! facingSouth()) { turnLeft(); } Conflicting tests

WHILE and IF instructions What will happen with this code fragment? while (! frontIsClear() ) { if (frontIsClear()) { move(); } else { turnLeft(); } Unnecessary test

WHILE and IF instructions What will happen with this code fragment? while (nextToABeeper() ) { if (nextToABeeper()) { pickBeeper(); } Redundant test

When to use repeating instructions