U4 | Iteration
4.1 while Loops
- A while loop is a fundamental control structure in programming used for repeated execution of a block of code as long as a condition is true.
- The loop starts by evaluating the condition. If the condition is true, the code inside the loop is executed.
- After each iteration, the condition is re-evaluated, and if it’s still true, the loop continues. If the condition is false initially, the loop code is never executed.
- While loops are used when you don’t know in advance how many times the loop needs to execute.
- There’s a risk of infinite loops if the condition never becomes false, so be cautious. You can use variables and complex expressions as loop conditions.
- It’s essential to update the loop control variable within the loop to prevent infinite loops.
- While loops are typically used for tasks such as iterating over collections or waiting for a specific condition to be met.
- You can always break out of a while loop prematurely using the break statement.
Example of While Loops
public class PyramidPattern {
public static void main(String[] args) {
int height = 5;
int row = 1;
while (row <= height) {
int spaces = height - row;
int stars = 2 * row - 1;
// Print spaces
int spaceCount = spaces;
while (spaceCount > 0) {
System.out.print(" ");
spaceCount--;
}
// Print stars
int starCount = stars;
while (starCount > 0) {
System.out.print("*");
starCount--;
}
System.out.println(); // Move to the next line for the next row
row++;
}
}
}
4.2 for Loops
- Iterative statement that checks for condition
- Repeatedly execute a a block of code as long as the condition is met
- Condition specifies amount of times
for Loops vs. while Loops
- while Loops: use when number of iterations is unknown
- for Loops: use when number of iterations is known
int i = 0;
while (i < 5) {
System.out.println(i);
i++;
}
0
1
2
3
4
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
0
1
2
3
4
Popcorn Hacks
- Calculate and print the sum of all even numbers from 1 to a given positive integer ‘n’ (user input n)
int n = 10;
int sum = 0;
for (int i = 0; i < n; i+=2){
sum += i;
}
System.out.println(sum);
20
For Each
- Enhanced for loop
- Uses colon instead
- Used for collections and arrays
int[] arr = {1,2,3,4};
for(int i : arr){
System.out.println(i);
}
1
2
3
4
- Three parts in for loop header: variable initialization, Boolean (conditional) expression, and increment/decrement statement
Question: Which part is which?
- variable initialization (int i=0): sets variable before loop starts
- Boolean (conditional) expression (i < 5): defines condition for loop to run, in this case, the loop continues as long as i is less than 5, so loops 5 times i 05
- increment/decrement statement (i++): increases variable each time code block in the loop is executed, in this case it increases by 1
- variable can be used in the code block for other various reasons besides specifying how many times the loop will repeat
- Boolean (conditional) expression and increment/decrement statement together determine how many times the loop will repeat
4.3 Developing Algorithms Using Strings
LEARNING OBJECTIVES:
For algorithms in the context of a particular specification that involves String
objects:
- identify standard algorithms
- modify standard algorithms
- develop an algorithm
Java has many methods that are helpful when working with strings:
String .substring
–> retrieves portion of a stringString .equals
–> compares two stringsString .length
–> returns length of a stringfor Loop
–> iterating through characters of a string
Finding a substring within a string
We can use the “window” method:
A “window” is created the same length as the substring. We then iterate through the main string in sections and compare to the substring
For example:
I T E R A T E
with substring “ERA”
public class StringFinder {
public static void main(String[] args) {
String word = "iterate";
String sub = "ate";
boolean found = false; // will be set to true once substring is found
// subtract length of substring. this fully defines the length of the window
for (int i = 0; i <= word.length()-sub.length(); i++) { //iterating forwards: starting at first index (0) and going to the length of the word.. let's try word.length
String portion = word.substring(i, i + (sub.length()));
System.out.println(portion);
if (portion.equals(sub)){ // make sure you use .equals!!
found = true;
break; // added break statement to exit loop after completion - Student addition (incorrect)
} // added parentheticals to assist with if blocking - Student addition
}
if (found)
System.out.println("substring is found within string!");
else
System.out.println("substring is NOT within string");
}
}
StringFinder.main(null);
ite
ter
era
rat
ate
substring is found within string!
POPCORN HACK: Run the code.. what happened? How can we fix it?
Tell us below!
The code segment did not fully find the substring in the string above. Rather, it did not look at the correct frame nor did it even loop looking at the last letter, thus, it was off by one and not finding the correct substring. We do not subtract the sub.length, which means that it will end up going out of bounds.
Another issue:
By not setting it equal to the last position of the list, we do not allow the last letter to be seen.
I T E R A T E
What if our substring was the word “RATE”? Note that RATE is at the end of the whole string
HACKS
Create a algorithm similar to the one above. Except this time, use iteration to count the number of vowels within the main string.
HINT: Use the boolean expressions we have learned in previous lessons. Which would you use when comparing your “window” with multiple options of substrings?
public class VowelCounter {
public static int countVowels(String inputString) {
// Define a set of vowels
String vowels = "aeiouAEIOU";
// Initialize a counter for vowels
int vowelCount = 0;
// Iterate through each character in the string
for (int i = 0; i < inputString.length(); i++) {
char currentChar = inputString.charAt(i);
// Check if the character is a vowel
if (vowels.indexOf(currentChar) != -1) {
// Increment the vowel count
vowelCount++;
}
}
// Return the final count
return vowelCount;
}
public static void main(String[] args) {
// Example usage:
String inputString = "Hello, World!";
int result = countVowels(inputString);
System.out.println("The number of vowels in '" + inputString + "' is: " + result);
}
}
VowelCounter.main(null);
The number of vowels in 'Hello, World!' is: 3
4.4 Nested Iteration
nested iteration
When you have one loop inside another, the inner loop has to finish all its rounds before the outer loop moves to the next round. If the inner loop has a “stop” command, it only stops for that round of the outer loop. The next time the outer loop starts a new round, the inner loop starts over.
If you have two nested loops without stops, and the outer one runs n times while the inner one runs m times each time the outer one goes around, the inner loop will run m times n times, which is m * n times in total. This rule also applies if you have more than two nested loops. To find the total number of times the innermost loop runs, just multiply how many times each loop runs per round.
public class NestedLoopsDemo {
public static void main(String[] args) {
int n = 3; //numb of times the outside loop runs
int m = 2; //numb of times the inside loop runs
//the nested loops
for (int i = 1; i <= n; i++) {
System.out.println("Outer loop iteration: " + i);
for (int j = 1; j <= m; j++) {
System.out.println("Inner loop iteration: " + j);
}
}
}
}
NestedLoopsDemo.main(null)
Outer loop iteration: 1
Inner loop iteration: 1
Inner loop iteration: 2
Outer loop iteration: 2
Inner loop iteration: 1
Inner loop iteration: 2
Outer loop iteration: 3
Inner loop iteration: 1
Inner loop iteration: 2
Break Statement
break statement
public class BreakExample {
public static void main(String[] args) {
for (int i = 1; i <= 3; i++) {
System.out.println("Outer loop iteration " + i);
for (int j = 1; j <= 3; j++) {
System.out.println("Inner loop iteration " + j);
if (i == 2 && j == 2) {
System.out.println("Breaking inner loop");
break; //break out of the inside loop when i is 2 and j is 2.
}
}
}
}
}
BreakExample.main(null)
Outer loop iteration 1
Inner loop iteration 1
Inner loop iteration 2
Inner loop iteration 3
Outer loop iteration 2
Inner loop iteration 1
Inner loop iteration 2
Breaking inner loop
Outer loop iteration 3
Inner loop iteration 1
Inner loop iteration 2
Inner loop iteration 3
Popcorn HACK
When the targetNumber is found, you can print a message and use the break statement to exit the loop. When it’s not found, you can print a message indicating that the number was not found.
public class BreakHack {
public static void main(String[] args) {
int targetNumber = 42; //numb we want
int[] numbers = {10, 20, 30, 40, 50, 60, 70}; //numb array
for (int number : numbers) {
if (number == targetNumber) {
System.out.println("Number found!");
break;
}
}
System.out.println("Number not found 💀");
}
}
BreakHack.main(null)
Number not found 💀
Continue Statement
continue statement
public class ContinueExample {
public static void main(String[] args) {
for (int i = 1; i <= 3; i++) {
System.out.println("Outer loop iteration " + i);
for (int j = 1; j <= 3; j++) {
if (i == 2 && j == 2) {
System.out.println("Skipping inner loop iteration " + j);
continue; //skip the iteration when i is 2 and j is 2.
}
System.out.println("Inner loop iteration " + j);
}
}
}
}
ContinueExample.main(null);
Outer loop iteration 1
Inner loop iteration 1
Inner loop iteration 2
Inner loop iteration 3
Outer loop iteration 2
Inner loop iteration 1
Skipping inner loop iteration 2
Inner loop iteration 3
Outer loop iteration 3
Inner loop iteration 1
Inner loop iteration 2
Inner loop iteration 3
Patterns and Shapes
import java.util.Scanner;
public class InteractivePyramid {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter the symbol you want to use: ");
char symbol = scanner.next().charAt(0);
System.out.print("Enter the number of rows for the pyramid: ");
int numRows = scanner.nextInt();
for (int i = 1; i <= numRows; i++) {
//print space before the symbol
for (int j = 1; j <= numRows - i; j++) {
System.out.print(" ");
}
//print
for (int k = 1; k <= 2 * i - 1; k++) {
System.out.print(symbol);
}
System.out.println(); //next line
}
scanner.close();
}
}
InteractivePyramid.main(null);
Enter the symbol you want to use: Enter the number of rows for the pyramid: *
***
*****
*******
*********
***********
*************
***************
*****************
public class Pattern {
public static void main(String[] args) {
int rows = 5; // You can change the number of rows as needed
// Outer loop for the number of rows
for (int i = 0; i < rows; i++) {
// Inner loop for printing spaces
for (int j = 0; j < rows - i - 1; j++) {
System.out.print(" ");
}
// Inner loop for printing stars (using 'x' as the character)
for (int k = 0; k < 2 * i + 1; k++) {
System.out.print("*");
}
// Move to the next line after each row is printed
System.out.println();
}
for (int i = rows; i > 0; i--){
for(int j=0; j<=8; j++){
System.out.print("*");
}
System.out.println();
}
for (int i = rows - 1; i >= 0; i--) {
// Inner loop for printing spaces
for (int j = 0; j < rows - i - 1; j++) {
System.out.print(" ");
}
// Inner loop for printing stars
for (int k = 0; k < 2 * i + 1; k++) {
System.out.print("*");
}
// Move to the next line after each row is printed
System.out.println();
}
}
}
Pattern.main(null);
*
***
*****
*******
*********
*********
*********
*********
*********
*********
*********
*******
*****
***
*
Hacks
- Modify pyramid code:
- Create different patterns (other then pyramid) by modifying nested loop structure
- Questions
- What is a nested iteration, continue statement, and break statement (in your own words)?
- Nested iteration is placing one for loop in another, allowing the user to creates loops within loops, and do two tasks within the same loop at an equivalent time. This can be used to iterate or do other tasks as they need to be done in two dimensions.
- Break statements break out of their loop, or exit out prematurely. This can be used to exit a loop once a condition is met in order to prevent an infinite loop.
- Continue statements exit out of the loop, but not fully. Rather, they stop the current iteration and move to the next iteration. This allows for conditionals that omit certain aspects of a loop, and can be used in selection.
- Create a simple example of a continue statement or break statement
for(int i = 0; i < 10; i++){
if(i%2 ==0){
continue;
}
System.out.println(i); // will not occur if condition above is met
}
// only prints odd
1
3
5
7
9
4.5 Informal Code Analysis
Learning objective: Compute statement execution counts & informal run-time comparison of iterative statements
Essential Knowledge: A statement execution count indicates the number of times a statement is executed by the program
What IS informal code analysis?
Answer:
// CODE EXAMPLE #1 (for loop)
public class InformalCodeAnalysis {
public static void main(String[] args) {
int count = 0;
for (int k = 0; k < 30; k++)
{
if (k % 3 == 0) // statement 1
{
count++; // statement 2
}
}
}
}
How many times will statement 1 execute?
Answer: 30 times, the loop loops 30 times, so the if statement is checked each time
How many times will statement 2 execute?
Answer: 10 times, this only runs if the number is a multiple of 3, thus this only occurs 10 times.
// CODE EXAMPLE #2 (for loop)
public class InformalCodeAnalysis {
public static void main(String[] args) {
int count = 0;
for (int k = 4; k < 30; k+=3)
{
count++; // statement 3
}
}
}
How many times will statement 3 execute?
Answer: 26 times, because 30-4 = 26/3 = 8+1 = 9, so the code segment, which executes each loop iteration, executes 9 times.
// Rewrite the code segment below to have a faster run-time based on statement execution counts
for (int k = 0; k < 135; k+=5)
{
System.out.println(k); // Rewritten by incrementing by 5 as opposed to checking
}
0
5
10
15
20
25
30
35
40
45
50
55
60
65
70
75
80
85
90
95
100
105
110
115
120
125
130
// CODE EXAMPLE #3 (while loop)
int num = (int)(Math.random() * 10);
while (num % 2 != 0)
{
num = (int)(Math.random() * 10); // statement 4
}
What is the min/max number of times statement 4 will execute?
Answer: The minimum value would be 0, or the maximum value would be unknown, b/c we never know what number it generates, thus not knowing if that’s going to happen.
// CODE EXAMPLE #4 (nested loop)
for (int outer = 0; outer < 3; outer++)
{
for (int inner = 0; inner < 4; inner++)
{
// statement #5
}
}
How many times will statement #5 execute?
Answer: 12 times. 3*4 = 12
// CODE EXAMPLE #5 (nested loop)
int k = 0;
while (k < 5)
{
int x = (int)(Math.random() * 6) + 1;
while (x != 6)
{
// statement #6
x = (int)(Math.random() * 6) + 1;
}
k++;
}
How many times will statement #6 execute?
Answer: We don’t know, because of there being a random.
4.5 Hacks
#1 How many times will statement #1 and statement #2 execute in the code segments below?
for (int k = 0; k < 1000; k++)
{
// statement #1
}
1000 times
for (int k = 6; k < 50; k++)
{
// statement #2
}
50-6 = 44 hacks.
#2 How many times will statement #3 execute for the code segment below?
int k = 1;
while (k <=7)
{
for (int z = 0; z < 4; z++)
{
// statement #3
}
k++;
}
#3 Create 3 seperate code segments that execute a statement 10 times using:
(a) a for loop
(b) a while loop
(c) a nested loop
// 3a code
for (int i = 0; i < 10; i++){
System.out.println("Statement");
}
Statement
Statement
Statement
Statement
Statement
Statement
Statement
Statement
Statement
Statement
// 3b code
int i = 0;
while (i < 10){
System.out.println("Statement");
i++;
}
Statement
Statement
Statement
Statement
Statement
Statement
Statement
Statement
Statement
Statement
// 3c code
for (int i = 0; i < 5; i++){
for (int j = 0; j < 2; j++){
System.out.println("Statement");
}
}
Statement
Statement
Statement
Statement
Statement
Statement
Statement
Statement
Statement
Statement