Hunter Liu's Website

7. Week 4 Tuesday: Practise with Loops!

So far, we’ve learned a lot about coding: we’ve learned how to produce outputs, accept user inputs, store and manipulate variables, and use if statements to produce branching, responsive behaviours. However, this is still a rather limited set of capabilities, and we’re far from capable of utilising C++’s full power.

What if you’re printing out all of the numbers between 1 and 1000, for whatever reason? There’s got to be a better way to do this than just typing cout << 1 << " " << 2 << " " << ..... Moreover, what if you’re printing all the numbers between 1 and 10000? Or even worse?

While this situation is quite contrived, there are many more situations where you need to repeat code a known or unknown number of times, such as:

• You’re collecting data from an electronic thermometer. You’ve harvested two million data points, but you need to convert the data from Celsius to Fahrenheit.
  • Sub-scenario: you’re interested in statistics related to this data, such as the mean, standard deviation, how well it fits a model, etc.
• You’ve scanned a book into your computer, and you need to count how many words are in that book.
• You need to compute a mathematical expression that’s defined using sums, products, or a recursive relationship — examples include computing \(n!\), computing binomial coefficients, computing elements of the Fibonacci sequence, etc.
  • A related sub-scenario is if you need to apply Newton’s method to numericall solve a differential equation (or, more commonly, a higher-order numerical solution such as the Runge-Kutta methods).
• You’re sorting your (totally legal) digital library of thousands of movies alphabetically.

There are a billion other scenarios that revolve around repeating instructions some number of times or until some condition is reached. As a mathematician, most of my examples will arise from data analysis and numerical methods, but I hope it’s enough to convince you nonetheless.

We can delineate loops into two separate categories: either you are repeating a set of instructions until something happens, or you are repeating a set of instructions a known number of times. We can describe the first situation as a while loop, and the syntax is as follows:

1while( [condition] ) {
2    // repeated code... 
3} 

This will check the condition next to the while loop, then execute the code between the curly braces if the condition was true. Once the code is executed, it will go back to the top and check the condition again. If at any time the condition is false, it will skip everything between the curly braces and move on.

In fact, while loops can be used to capture the second situation as follows:

1int repetitions = 0; 
2while(repetitions < [number of repetitions]) {
3    // repeated code... 
4    repetitions++; 
5} 

This will keep track of how many times the code has been repeated. It will repeat the code until it’s been repeated an appropriate number of times.

This is bad for two reasons:

1. You need two extra lines to keep track of the number of repetitions, and they may be spread out over your code. This makes the code far less manageable.
2. The variable name repetitions in the above example can never be declared again. You will either have to re-use the same variable several times (and keep track of it throughout all of your code!) or come up with a new variable name for each loop.

The workaround is to use a for loop, which has the following syntax:

1for(int counter = 0; counter < [number of repetitions]; counter++) {
2    // repeated code....
3}

This keeps everything in one place so it’s easier to keep track of, especially for when you need to modify your code. You may replace counter with whatever name you want! Often times, we’ll use the name i instead of counter since it’s easier to write.

Very generally speaking, if you want to repeat code a known number of times, you should use a for loop. If you don’t know how many times you’ll need to repeat some code, you should use a while loop.

There are some things to pay attention to regarding for loops, however.

1. Be wary of the semicolons! They only go between the three statements within the for loop, but not after the counter++.
2. The variable counter is accessible within the loop, but not outside the loop. Once the for loop has finished running, the variable counter will cease to exist, and you are allowed to redefine it (or even use it in a new for loop) if you want!
3. The int counter = 0; functions as a mostly regular variable declaration in C++. This means that if you have already defined the variable counter before, the code will break.
4. Like while loops, for loops check the condition before each repetition of the loop.

1for(int i = 0; i <= 5; i++) {
2    cout << "I like cheese" << endl; 
3} 

1for([initialisation]; [condition]; [update]) {
2    // repeated code... 
3} 

1[initialisation]; 
2while([condition]) {
3    // repeated code...
4    [update]; 
5}

That was quite a bit of text, so let’s look at an example.

Sample Run: 
INPUT  I live at 123 RAM Street. 
OUTPUT I live at *** RAM Street. 

Let’s write some pseudocode first to describe what we want to happen.

1. Accept a line of text from the user’s input and store it in a string variable line.
2. For each character c in the user’s input, repeat the following:
   • If c is a digit, replace it with an asterisk.
   • Otherwise, do nothing.
3. Print out the modified string.

But how can we use loops to do something for every character c in a string? At some point, we’re going to have to use the .at() function for strings, and we’ll be repeating some operation on line.at(0), line.at(1), etc. So, we ought to rephrase our pseudocode in terms of the index rather than the character:

1. Accept a line of text from the user’s input and store it in a string variable line. Let N be its length.
2. For each index i = 0, 1, 2, ..., N - 1, repeat the following:
   • Set c to the character at index i.
   • If c is a digit, replace it with an asterisk.
   • Otherwise, do nothing.
3. Print out the modified string.

Let’s convert this to code step by step.

For the first step, we need to be sensitive to spaces, so we’ll use getline rather than a cin.

1string line; 
2getline(cin, line); 
3int N = line.length(); 

For the second step, we’ll set up a for loop since we know something is repeated exactly N times! So,

 1for(int i = 0; i < N; i++) {
 2    // get the character at index
 3    char c = line.at(i); 
 4
 5    // if it's a digit, replace it! 
 6    if(c >= '0' && c <= '9') {
 7        line.at(index) = '*'; 
 8        // why doesn't "c = '*';" work? 
 9    } 
10
11    // otherise, do nothing (no code) 
12} 

And of course, at the end, we’ll need to print something out.

1cout << line << endl; 

Let’s take a look at another similar example.

Sample Run:
INPUT   John Smith
OUTPUT  JOHN SMITH

INPUT   John Old McDonald
OUTPUT  JOHN OLD MCDONALD

INPUT   John O'Niel McDonald, Sr.
OUTPUT  JOHN ONIEL MCDONALD SR

As usual, we’ll begin by producing some pseudocode. The first approach we’ll demonstrate is one where we create a fresh empty string, then append alphabetic characters from the user’s input one at a time (capitalising if necessary) and skipping over the non-space non-alphabetic characters. More specifically,

1. Take a string full_name as input, and let N be the length of the input.
2. Create an empty string called all_caps.
3. For each index i = 0, 1, ..., N-1, perform the following:
   • Let ch be the character at index i in the user’s input.
   • If ch is a space or an upper-case letter, append it to all_caps.
   • If ch is a lower-case letter, convert it to upper-case, then append it to all_caps.
   • Otherwise, don’t do anything with ch and keep going.
4. Print out all_caps to the screen.

Let’s now convert this to code. We’ll be reliant on ASCII math and writing loops to do so. First, to take a full name as an input (which may include spaces), we should use getline rather than a direct cin statement.

1string full_name;
2getline(cin, full_name);
3int N = full_name.length();

Next, we’ll create the empty string.

1string all_caps = "";

For the loop, we’ll elect to use a for loop: we know exactly how many times the loop should run (N times). To append a character to a string, you can either use the push_back function or the += operator.

 1for(int i = 0; i < N; i++) {
 2    // obtaining the character at index i
 3    char ch = full_name.at(i);
 4
 5    // space or uppercase character: just add it to all_caps
 6    if(ch == ' ' || (ch >= 'A' && ch <= 'Z')) {
 7        all_caps += ch;
 8    }
 9
10    // lowercase character: convert to uppercase, then add.
11    if(ch >= 'a' && ch <= 'z') {
12        ch += 'A' - 'a';
13        all_caps += ch;
14    }
15
16    // remaining cases: just ignore them and don't do anything.
17}

The last step, of course, is to print out all_caps to the screen. here’s the completed code:

 1#include <iostream>     // cin, cout
 2#include <string>       // getline, strings
 3
 4using namespace std;
 5
 6int main() {
 7    // 1. read input, define N
 8    string full_name;
 9    getline(cin, full_name);
10    int N = full_name.length();
11
12    // 2. declare all_caps as empty string
13    string all_caps = "";
14
15    // 3. loop through the full_name string,
16    //    one character at a time.
17    for(int i = 0; i < N; i++) {
18        // obtaining the character at index i
19        char ch = full_name.at(i);
20
21        // space or uppercase character: just add it to all_caps
22        if(ch == ' ' || (ch >= 'A' && ch <= 'Z')) {
23            all_caps += ch;
24        }
25
26        // lowercase character: convert to uppercase, then add.
27        if(ch >= 'a' && ch <= 'z') {
28            ch += 'A' - 'a';
29            all_caps += ch;
30        }
31
32        // remaining cases: just ignore them and don't do anything.
33    }
34
35    // 4. print out the result.
36    cout << all_caps << endl;
37
38    return 0;
39}

There is an alternative solution. It’s somewhat unnatural to define a new string and rebuild the user’s input one character at a time; I suspect more human pseudocode would be as follows:

1. Take a string full_name as input and define N as its length.
2. For each index i = 0, 1, ..., N - 1, perform the following:
   • Define ch as the character at index i in full_name.
   • If ch is a lowercase letter, convert it to uppercase.
   • If ch is neither a space nor a letter, remove it from the string.
3. Print full_name to the screen.

To remove a character from a string, we can use the erase function for strings. This pseudocode directly modifies the user’s input, deleting unwanted characters and capitalising lowercase letters as we go. Let’s code this solution up:

 1// 1. read full name from user input
 2string full_name;
 3getline(cin, full_name);
 4int N = full_name.length();
 5
 6// 2. for each index 0, 1, ...., N - 1
 7for(int i = 0; i < N; i++) {
 8    // obtain character at index i
 9    char ch = full_name.at(i);
10
11    // if ch is lowercase, convert to uppercase
12    if(ch >= 'a' && ch <= 'z') {
13        // note: we should not modify ch, since it's a copy
14        // of the character in the string full_name.
15        full_name.at(i) += 'A' - 'a';
16    }
17
18    // if ch is NOT a space and NOT an uppercase letter,
19    // delete the character from the string
20    if(ch != ' ' && (ch < 'A' || ch > 'Z')) {
21        // erases one character, starting at index i.
22        full_name.erase(i, 1);
23    }
24
25    // in remaining cases, do nothing!
26}
27
28// 3. print out results.
29cout << full_name << endl;

The two problems in the code are as follows: first, the length of the string may decrease throughout the for loop. If we ever end up deleting a character, i = N - 1 would cease to be a valid index, resulting in a runtime error. The fix to this is to remove line 4, and replace the condition in the for loop with i < full_name.length(). This tells the for loop to check the length of the string at every iteration, making it robust to changes in string length.

The second problem is more subtle, and it’s revealed when we input john o'neil. The output becomes JOHN OnEIL; the for loop somehow skips over the n following the apostrophe. The reason is that when i = 6, we delete the apostrophe and update the index to i = 7. But when we delete the apostrophe, the n moves to index i = 6! This index shifting causes the for loop to skip over the n and leave it as-is. The fix is to add i-- after line 22 to adjust the index according to this backwards shift. This way, none of the characters get skipped inadvertently.