1. Lecture 6
Repetition
Richard Gesick

2. Overview
Iteration
4 kinds of good loops
Infinite Loops

3. Looping
In computing, we often need to perform the same operations on multiple items.
Typically, these tasks follow this pattern:
initialize values (set total to 0)
process items one at a time (add price to total)
report results (report total)
The flow of control that programmers use to complete jobs with this pattern is called looping, or repetition.

4. Iteration One thing that computers do well is repeat commands
Programmers use loops to accomplish this
4 kinds of loops in C#
for loop
while loop
do while loop
foreach loop

5. Criteria for loops Usually have some initial condition
Starting a counter
Beginning in a certain state
Must have a test to continue
Must make progress towards finishing

6. “I will not pour Clorox in the fish tank”
Loops in Everyday Life
Bad children are told to write sentences on the board
“I will not pour Clorox in the fish tank”
Have to write this sentence either
A certain number of times
Until the teacher is happy
As many as you can during break

7. The for Loop
Ideal when you know the number of iterations to perform before the loop begins
Examples:
Find the sum of 5 numbers
Find the maximum of 20 numbers
Print the odd numbers from 1 to 10

8. The for loop
format:
for (<initialization>; <test to continue>; <increment>) {
// everything in here is what is repeated
// over and over again }
Initialization is where the counter is given a starting value
The test determines whether or not to continue
The increment can be any amount, including negative, and occurs after the loop statements execute

9. More for Loop Syntax Notes:
for ( initialization; loop condition; loop update ) {
// loop body }
Notes:
semicolons separate terms in the loop header
no semicolon follows the loop header
curly braces are required only if more than one statement is in the loop body

10. for Loop Flow of Control
The initialization statement is executed (once only).
The loop condition is evaluated. If the condition is true, the loop body is executed.
The loop update statement is executed, and the loop condition is reevaluated (#2).
And so on, until the condition is false.

11. Satisfying the Teacher
Example: 1000 sentences? No problem…
int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (“I will not pour Clorox…”); }
// Remember, counter++ is the same as
// counter = counter + 1

12. “But I want them numbered!”
No problem…
int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (counter + “I will not pour…”); }

13. Why this works 1 counter int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (counter + “I will not pour…”); }
counter 1

14. Why this works 1 counter true int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (counter + “I will not pour…”); }
counter
true 1

15. Why this works
counter
int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (counter + “I will not pour…”); }
Output: 1 I will not pour Clorox in the Fish Tank 1

16. Why this works 2 counter int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (counter + “I will not pour…”); } 2

17. Why this works 2 counter true int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (counter + “I will not pour…”); }
true 2

18. Why this works
counter
int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (counter + “I will not pour…”); }
Output: 2 I will not pour Clorox in the Fish Tank 2

19. Why this works 3 counter int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (counter + “I will not pour…”); } 3

20. Why this works 3 counter true int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (counter + “I will not pour…”); }
true 3

21. Why this works
counter
int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (counter + “I will not pour…”); }
Output: 3 I will not pour Clorox in the Fish Tank 3

22. Why this works 4 counter int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (counter + “I will not pour…”); } 4

23. When will it end? We see that this will go on for a while
It’s a little more interesting later around 1000

24. Why this works 999 counter true int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (counter + “I will not pour…”); }
true
999

25. Why this works
counter
int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (counter + “I will not pour…”); }
Output: 999 I will not pour Clorox in the Fish Tank
999

26. Why this works 1000 counter int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (counter + “I will not pour…”); }
1000

27. Why this works 1000 counter true for last time int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (counter + “I will not pour…”); }
true for last time
1000

28. Why this works (are we finished?)
counter
int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (counter + “I will not pour…”); }
Output: 1000 I will not pour Clorox in the Fish Tank
1000

29. Why this works 1001 counter int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (counter + “I will not pour…”); }
1001

30. Why this works 1001 … counter false int counter;
for (counter = 1; counter <= 1000; counter++) {
Console.WriteLine (counter + “I will not pour…”);
} // Jump down here and continue …
false
1001

31. Final Output
1 I will not pour Clorox in the fish tank. 2 I will not pour Clorox in the fish tank. 3 I will not pour Clorox in the fish tank. 4 I will not pour Clorox in the fish tank I will not pour Clorox in the fish tank I will not pour Clorox in the fish tank.

32. Another Example of Repetition
int num; for ( num = 1 ; num <= 3 ; num++ ) { C.Wln(num + “Potato”); }

33. num ?
int num; for ( num = 1 ; num <= 3 ; num++ ) C.Wln(num+"Potato");
OUTPUT

34. num 1
int num; for ( num = 1 ; num <= 3 ; num++ ) C.Wln(num+"Potato");
OUTPUT

35. 1
num
int num; for ( num = 1 ; num <= 3 ; num++ ) C.O.Wln(num+"Potato");
true
OUTPUT

36. num 1
int num; for ( num = 1 ; num <= 3 ; num++ ) C.O.Wln(num+"Potato");
OUTPUT
1Potato

37. num 2
int num; for ( num = 1 ; num <= 3 ; num++ ) C.Wln(num+"Potato");
OUTPUT
1Potato

38. 2
num
int num; for ( num = 1 ; num <= 3 ; num++ ) C.Wln(num+"Potato");
true
OUTPUT
1Potato

39. num 2
int num; for ( num = 1 ; num <= 3 ; num++ ) C.O.Wln(num+"Potato");
OUTPUT
1Potato
2Potato

40. num 3
int num; for ( num = 1 ; num <= 3 ; num++ ) C.Wln(num+"Potato");
OUTPUT
1Potato
2Potato

41. 3
num
int num; for ( num = 1 ; num <= 3 ; num++ ) C.Wln(num+"Potato");
true
OUTPUT
1Potato
2Potato

42. num 3
int num; for ( num = 1 ; num <= 3 ; num++ ) C.Wln(num+"Potato");
OUTPUT
1Potato
2Potato
3Potato

43. num 4
int num; for ( num = 1 ; num <= 3 ; num++ ) C.Wln(num+"Potato");
OUTPUT
1Potato
2Potato
3Potato

44. 4
num
int num; for ( num = 1 ; num <= 3 ; num++ ) C.Wln(num+"Potato");
false
OUTPUT
1Potato
2Potato
3Potato

45. 4
int num; for ( num = 1 ; num <= 3 ; num++ ) C.Wln(num+"Potato");
num
false
When the loop control condition is evaluated and has value false, the loop is said to be “satisfied” and control passes to the statement following the For statement.

46. The output was:
1Potato
2Potato
3Potato

47. int count ; for ( count = 4 ; count > 0 ; count-- ) { C
int count ; for ( count = 4 ; count > 0 ; count-- ) { C.Wln(count); } C.Wln(“Done”);
OUTPUT: 4 3 2 1
Done

48. The while Loop
The while loop is designed for repeating a set of operations on data items when we don't know how many data items there will be.
We will get some signal when we have reached the end of the items to process.
The end of data items could be indicated by a special input value called a sentinel value or by reaching the end of a file
Receiving the signal is an event; we call this event-controlled looping

49. The while loop Good for when you don’t know how many times to repeat
Teacher says “Write until I’m happy”
Has format:
while (<boolean value>) {
// stuff to repeat over and over }

50. Operation of the while Loop
If the condition evaluates to true, the loop body is executed, then the condition is re-evaluated.
As long as the condition evaluates to true, we continue to repeat the loop body.
The loop body must "update the loop condition"; that is, it must perform some operation that eventually will cause the loop condition to evaluate to false
Typically, the loop update will be an attempt to read the next input value, in order to detect the sentinel value or the end of the file.

51. Loop Characteristics
All loops have the following three characteristics:
initialization
test
update

52. Count-controlled Loop
int count ; count = 4; // initialize loop variable while (count > 0) // test expression { C.Wln(count); // repeated action count -- ; // update loop variable } C.Wln(“Done”);

53. Count-controlled Loop
int count ; count = 4; while (count > 0) { C.Wln(count); count -- ; } C.Wln("Done");
count
OUTPUT

54. Count-controlled Loop4
int count ; count = 4; while (count > 0) { C.Wln(count); count -- ; } C.Wln("Done");
OUTPUT

55. Count-controlled Loop4
int count ; count = 4; while (count > 0) { C.Wln(count); count -- ; } C.Wln("Done");
TRUE
OUTPUT

56. Count-controlled Loop4
int count ; count = 4; while (count > 0) { C.O.Wln(count); count -- ; } C.O.Wln("Done");
OUTPUT 4

57. Count-controlled Loop3
int count ; count = 4; while (count > 0) { C.Wln(count); count -- ; } C.Wln("Done");
OUTPUT 4

58. Count-controlled Loop3
int count ; count = 4; while (count > 0) { C.Wln(count); count -- ; } C.Wln("Done");
TRUE
OUTPUT 4

59. Count-controlled Loop3
int count ; count = 4; while (count > 0) { C.Wln(count); count -- ; } C.Wln("Done");
OUTPUT 4 3

60. Count-controlled Loop2
int count ; count = 4; while (count > 0) { C.Wln(count); count -- ; } C.Wln("Done");
OUTPUT 4 3

61. Count-controlled Loop2
int count ; count = 4; while (count > 0) { C.Wln(count); count -- ; } C.Wln("Done");
TRUE
OUTPUT 4 3

62. Count-controlled Loop2
int count ; count = 4; while (count > 0) { C.Wln(count); count -- ; } C.Wln("Done");
OUTPUT 4 3 2

63. Count-controlled Loop1
int count ; count = 4; while (count > 0) { C.Wln(count); count -- ; } C.Wln("Done");
OUTPUT 4 3 2

64. Count-controlled Loop1
int count ; count = 4; while (count > 0) { C.Wln(count); count -- ; } C.Wln("Done");
TRUE
OUTPUT 4 3 2

65. Count-controlled Loop1
int count ; count = 4; while (count > 0) { C.Wln(count); count -- ; } C.Wln("Done");
OUTPUT 4 3 2 1

66. Count-controlled Loop
int count ; count = 4; while (count > 0) { C.Wln(count); count -- ; } C.Wln("Done");
OUTPUT 4 3 2 1

67. Count-controlled Loop
int count ; count = 4; while (count > 0) { C.Wln(count); count -- ; } C.Wln("Done");
FALSE
OUTPUT 4 3 2 1

68. Count-controlled Loop
int count ; count = 4; while (count > 0) { C.Wln(count); count -- ; } C.Wln("Done");
OUTPUT 4 3 2 1
Done

69. Example: Re-Writing 1-1000 (using a while loop)
counter 1
int counter = 1; while (counter < 1000) { Console.WriteLine (counter + “I will not…”); }

70. Example: Re-Writing 1-1000 (using a while loop)
counter 1
int counter = 1; while (counter < 1000) { Console.WriteLine (counter + “I will not…”); }

71. Example: Re-Writing 1-1000 (using a while loop)
counter 1
int counter = 1;
while (counter < 1000) {
Console.WriteLine (counter + “I will not…”); }
Output: 1 I will not pour Clorox in the fish tank

72. Example: Re-Writing 1-1000 (using a while loop)
counter 1
int counter = 1; while (counter < 1000) { Console.WriteLine (counter + “I will not…”); }

73. Example: Re-Writing 1-1000 (using a while loop)
counter 1
int counter = 1; while (counter < 1000) { Console.WriteLine (counter + “I will not…”); }

74. Example: Re-Writing 1-1000 (using a while loop)
counter 1
int counter = 1;
while (counter < 1000) {
Console.WriteLine (counter + “I will not…”); }
Output: 1 I will not pour Clorox in the fish tank

75. Example: Re-Writing 1-1000 (using a while loop)
counter 1
int counter = 1; while (counter < 1000) { Console.WriteLine (counter + “I will not…”); }

76. Example: Re-Writing 1-1000 (using a while loop)
counter 1
int counter = 1; while (counter < 1000) { Console.WriteLine (counter + “I will not…”); }

77. Example: Re-Writing 1-1000 (using a while loop)
int counter = 1;
while (counter < 1000) {
Console.WriteLine (counter + “I will not…”); }
Output: 1 I will not pour Clorox in the fish tank
counter 1

78. } Infinite Loops This loop isn’t making a lot of progress!
Loops that repeat forever are called infinite loops
Apparently “lock up”
Output:
1 I will not pour Clorox in the fish tank . }
Continue
forever

79. Problem Solved… 1 counter
int counter = 1; while (counter < 1000) { Console.WriteLine (counter + “I will not…”); counter++; }

80. Problem Solved… 1 counter
int counter = 1; while (counter < 1000) { Console.WriteLine (counter + “I will not…”); counter++; }

81. Problem Solved… 1 counter
int counter = 1;
while (counter < 1000) {
Console.WriteLine (counter + “I will not…”);
counter++; }
Output: 1 I will not pour Clorox in the fish tank

82. Problem Solved… 2 counter
int counter = 1; while (counter < 1000) { Console.WriteLine (counter + “I will not…”); counter++; }
// Remember, counter++ is the same as // counter = counter + 1

83. Example: Re-Writing 1-1000 (using a while loop)
counter 2
int counter = 1; while (counter < 1000) { Console.WriteLine (counter + “I will not…”); counter++; }

84. Problem Solved… 2 counter
int counter = 1; while (counter < 1000) { Console.WriteLine (counter + “I will not…”); counter++; } 2

85. Problem Solved… 2 counter
int counter = 1;
while (counter < 1000) {
Console.WriteLine (counter + “I will not…”);
counter++; }
Output: 2 I will not pour Clorox in the fish tank 2

86. Problem Solved… 3 counter
int counter = 1; while (counter < 1000) { Console.WriteLine (counter + “I will not…”); counter++; } 3

87. How does it end?
counter
int counter = 1; while (counter < 1000) { Console.WriteLine (counter + “I will not…”); counter++; }
999

88. How does it end?
counter
int counter = 1; while (counter < 1000) { Console.WriteLine (counter + “I will not…”); counter++; }
999

89. How does it end?
counter
int counter = 1; while (counter < 1000) { Console.WriteLine (counter + “I will not…”); counter++; }
999

90. Problem Solved… 999 counter
int counter = 1;
while (counter < 1000) {
Console.WriteLine (counter + “I will not…”);
counter++; }
Output: 999 I will not pour Clorox in the fish tank
999

91. How does it end?
counter
int counter = 1; while (counter < 1000) { Console.WriteLine (counter + “I will not…”); counter++; }
1000

92. How does it end?
counter
int counter = 1; while (counter < 1000) { Console.WriteLine (counter + “I will not…”); counter++; }
1000

93. How does it end? 1000 counter now false
int counter = 1; while (counter < 1000) { Console.WriteLine (counter + “I will not…”); counter++; } // So we never print out // 1000 I will not pour Clorox in the fishtank
now false
1000

94. Another Problem Solved
counter
int counter = 1; while (counter <= 1000) { Console.WriteLine (counter + “I will not…”); counter++; }
now true
1000

95. Example
bool teacherHappy = false; int lineNumber = 1; while (!teacherHappy) { Console.WriteLine (lineNumber + “I will not…”); lineNumber++; teacherHappy = attitudeFunction ( ); } // assume attitudeFunction can change // teacherHappy

96. The do-while loop Similar to while loop
Must execute at least one time (test is at bottom)
Has format:
do {
}while (<boolean value>);

97. Example (count from 1 to 3)
counter
int counter = 0; do { counter++; Console.WriteLine (counter); } while (counter < 3);

98. Example (count from 1 to 3)
counter
int counter = 0; do { counter++; Console.WriteLine (counter); } while (counter < 3);

99. Example (count from 1 to 3)
counter 1
int counter = 0; do { counter++; Console.WriteLine (counter); } while (counter < 3);

100. Example (count from 1 to 3)
counter 1
int counter = 0; do { counter++; Console.WriteLine (counter); } while (counter < 3);
Output: 1

101. Example (count from 1 to 3)
counter 1
int counter = 0; do { counter++; Console.WriteLine (counter); } while (counter < 3);

102. Example (count from 1 to 3)
counter 2
int counter = 0; do { counter++; Console.WriteLine (counter); } while (counter < 3);

103. Example (count from 1 to 3)
counter 2
int counter = 0; do { counter++; Console.WriteLine (counter); } while (counter < 3);
Output: 2

104. Example (count from 1 to 3)
counter 2
int counter = 0; do { counter++; Console.WriteLine (counter); } while (counter < 3);

105. Example (count from 1 to 3)
int counter = 0;
do {
counter++;
Console.WriteLine (counter);
} while (counter < 3);
// Note: counter is now 3, but we still have
// to finish out the loop – it doesn’t skip
counter 3

106. Example (count from 1 to 3)
counter 3
int counter = 0; do { counter++; Console.WriteLine (counter); } while (counter < 3);
Output: 3

107. Example (count from 1 to 3)
counter 3
int counter = 0; do { counter++; Console.WriteLine (counter); } while (counter < 3);
now false, so loop is finished

108. Summary
for loops good for when you know how many times you want to repeat
while and do-while good for when you don’t
foreach loop useful for processing collections
All loops must finish, or they become infinite loops
All loops must have a test to continue, or they become infinite loops