Lecture Notes 07: More Loops

Objectives

• Use some nested for-loops with independent variables.
• Use some nested for-loops with dependent conditions.
• Identify and correct syntax errors related to above objectives.
• Distinguish between syntax errors and debugging.

Before Starting

• Read Sections 7.01 to 7.03 in the Codio Course

If you do not have your Codio course ready, use any text editor or simple IDE. Some possibilities are:

• Write using Sublime; Compile and run in the Terminal
• Use IDEs like: IntelliJ, DrJava, or JGrasp

Catching Up

Before we move forward, let's catch up (complete any remaining work from the previous module)
In this case, make sure we've got:

1. Simple For loops. initialization, stopping conditions, and iteration step.

Nested for-loops

We'll start by writing a program to print a little number triangle like this:

  1
  22
  333
  4444

Notice: there's repetition across a row of numbers: a potential use of for-loops!

Here's the program, using for-loops:

Observe:

• We've used System.out.print to avoid printing each number on a single line.

• System.out.println() merely goes to the next line.
  (Or, ends the current line being printed.)

Identify repetition and try a Nested For Loop

Next, observe that the upper-limits of the for-loops are themselves increasing:

Another way to say this:

    When the value is 2, print a row of 2's
    When the value is 3, print a row of 3's
    When the value is 4, print a row of 4's
  

Thus, we could try to do is:

    for (int j=2; j<=4; j++) {
        // Print a row of j's (j of them)
    }
  

But we already know how to print a row of j's:

    for (int j=2; j<=4; j++) {
        // Print a row of j's (j of them)
        for (int i=0; i<j; i++) {
            System.out.print (j)
        }
    }
  

The complete program:

Activity 3: Change the program to print a fifth row with five 5's. Also include the row of 1's inside the loop: that is, fix the for-loop conditions so that you don't need the stand-alone println to print 1. Write your code in ForLoopPrint2.java

Let's review what we learned above:

• The outer loop variable's value is used in the inner loop:

  

• Consider a single iteration of the outer-loop (e.g., when j is 3).

  

  • For this value of j, the inner loop executes j times.
  • Thus, when j is 3, the inner loop has 3 iterations.

• This is an example of a nested for-loop in which the inner loop's execution depends on the value of the outer-loop variable.

Tracing through a program in detail

At first this will appear tedious, but it is critical to firm understanding of how programs execute, and eventually to your own writing of programs.

We'll first do a longer, more narrative version here, and then show you how to submit a much shorter version for your exercises.

For our example, let's look at the program we last saw:

public class ForLoopPrint2 {

    public static void main (String[] argv)
    {
        System.out.println (1);
        for (int j=2; j<=4; j++) {
            for (int i=0; i<j; i++) {
                System.out.print (j);
            }
            System.out.println();
        }
    }

}
  

• Open this same page in another browser, and have the program side-by-side, as you read what's below.
• Read out aloud what you see below.

Ready? Let's trace through:

• Right at the start, the first line is System.out.println(1); This prints out 1, and moves to the next line.

• Initially j=2 at the start of the outer for-loop.

  

• Since the condition j<=4 is immediately tested at entry into the loop, we see that j<=4 is satisfied when j=2.

• This gets us into the outer loop.
  • Now we encounter the inner for-loop, where i is set to 0 (int i=0).

    

  • Is i<j now? At the moment i is 0, j is 2. So, since 0<2, we enter the inner loop.
  • Inside the inner loop, we execute System.out.print(j). which, because j is now 2, will print 2.
  • This is NOT println so the output will not go to the next line yet.
  • We're at the end of the inner loop, so now i increments to 1:

    

  • Coming back to the top of the inner for-loop, we check whether the current value of i (which is now 1) satisfies the condition i<j. Note that j is still 2 so, yes, it's satisfied.
    • Remember: the initial setting of the loop (int i=0) is never executed again after entering the loop (It could, and in this program, will be executed again if we return to the loop once we've left it).
  • So now inside the inner-loop, we print 2 again (print, not println).

    

  • Then, at the end of the inner for-loop, i increments to 2.
  • We're back to the entrance of the inner-loop. The condition 2<2 fails.
  • We exit the inner loop and proceed to whatever code follows the loop.

• Now we're at System.out.println().

  

  This simply causes the output to go to the next line without printing any actual thing.

  

• Then, it's on to the end of the outer for-loop, where j is incremented to 3.

• Remember: the third part of the loop statement (the increment or decrement, in some cases) is done at the END of the loop, even though it's written in one line. That's just the strangeness of writing code.

• Now we're back to checking the condition j<=4 at the top of the outer for-loop. j is 3 now.

• Since j<=4 (that is, 3<=4), we enter the loop again.

• Now, we see the inner loop again (AFTER exiting it earlier).
  • So, now int i=0 is executed, initializing this for-loop's variable to i=0.

    

  • Then, we enter and print 3 (since j is 3 at this moment).
  • i increments to 1, we enter and print 3.
  • i increments to 2, we enter and print 3.
  • i increments to 3, which fails i<j because 3<3 fails, and we exit the inner loop.
  • So, three 3's get printed.

• Then, it's on to System.out.println().

• Thus, the output so far is:

    1
    22
    333
    

• Now j increments to 4 and because j<=4 is satisfied by j=4, we enter the outer-loop again.

• Now, we see the inner loop again (AFTER exiting it the second time earlier).
  • Now int i=0 is executed, setting i=0.
  • Then, we enter and print 4 (since j is 4 at this moment).
  • i increments to 1, we print 4.
  • i increments to 2, we print 4.
  • i increments to 3, we print 4.
  • i increments to 4, which fails i<j (since j is currently 4), and we exit.

• Next, println() occurs, which gets to the next line.

• Now j increments to 5, which fails the j<=4 condition in the outer-loop.

• We exit the outer-loop and proceed. This gets us to the end of the curly bracket that's the end of public static void main (String[] argv).

  

• And this ends the program's execution.

• The output is:

    1
    22
    333
    4444
    

The Simple Table

We will use a simple table to keep track of values as they are changed throughout the program. An example is shown for the previous tracing exercise:

Note that the 2 is only "alive" between the last increment and the time the test fails (i<j). It is there just to highlight the end. In reality as soon as we leave the inner loop, i is no longer "alive" and so, the printing of the newline \n happens when i does not exist anymore.

First, trace through the values of i and j by hand and try to figure out what gets printed. Do this painstakingly for each possible value of i and j.
Use the shorter "table" format we just explained. Then, edit, compile and execute the above program to see if you were right.

Activity 5: Write a program to print out consecutive integers in a diagonal, as in

  1
   2
    3
     4
      5
  

I'm feeling cold: b rrrrrr rrrrr rrrr rrr rr r
  

Reading and writing

Let's consider how to read a single for-loop, such as:

• First, "see" the entire for-block as a whole, without looking at the details:

  

  Note: like the class but unlike methods, the opening brace is on the same line as the for.

• Then, figure out how the for-loop variable is going to change:

  

  Say to yourself

  • "The variable is i and it starts at 0."
  • "The increment is 1."
  • "The last iteration is when i is 5."

• Next, look for where the loop-variable is being used:

  

• Now perform the mental execution, iteration by iteration.
         ⇒ It helps to write down successive values of loop variables.

Writing:

• Make sure that you stick to the conventional style.

• Again, when writing, always type matching brackets together.

What does it print? Try to figure this out by mental execution first. Then, type it up, compile and execute to confirm, writing your code in MyForExercise.java.

When things go wrong

As code gets more complex, it gets easier to make mistakes, and harder to find them.

In each of the programs below, try to determine the error without compiling the program. Then, write up the program, compile and see what the compiler says. After that, fix the error.

Activity 8: Find the errors!

Program 1:

Write your (corrected) code in

Program 2:

Write your corrected code in

Program 3:

Write your corrected code in

Program 4:

Write your corrected code in

Program 5:

Write your corrected code in

Program 6:

Write your corrected code in

The last one is technically not a syntax error but a logical error:

• Logical errors compile fine, but cause a problem during execution.

• The process of identifying and fixing logical errors is called debugging.

• A bug is a logical error.

1
22
333
4444

55555
4444
333
22
1
    

public class ForLoopPrintDown {

  public static void main (String[] argv)
  {
    for (int i=5; i>=1; i--) {
      for (int j=1; j<i; j++); {
        System.out.print (i);
      }
      System.out.println ();
    }

  }

}
    

Meta

This module was a bit different, a little more challenging than modules 1-3.

What to keep in mind:

• It is only natural to feel like you are in an alien landscape.
         ⇒ You would feel no different doing the first few modules while learning a foreign language with an entirely different script.

• It takes a while to absorb some of the details, and that's just fine.

• Notice that exercises 4.15 and 4.16 were significantly more challenging than others:
  • In prior exercises, you merely typed in something and tried it out, or make a small change.
  • With 4.15 and 4.16 you had to do it all from scratch.
  • Both involved problem-solving
           ⇒ Taking a problem described in words and finding a solution.

• Problem-solving is a higher-level skill than programming.
  • It takes time to acquire this skill.
  • There is no magic formula or words to simply make "problem solving" work for you.
  • The only way is to develop this skill is to struggle with problems, and with lots of them.

• Finally, think about this:
  • Anyone can acquire both programming and problem-solving skills with sufficient dedication. So why not you?
  • If you get past these hurdles with determination, you will leave behind all those who gave up earlier.