# 8.2. Examples With for Statements¶

Thus far all of our for loops have used a sequence of successive integers. Suppose you want to print the first n multiples of k, like the first 5 multiples of 3: 3, 6, 9, 12, 15. This could be handled by generating a sequence i = 1 through n, and multiply each i by k:

for (int i = 1; i <= n; i++) {
Console.WriteLine(i*k);
}


Another approach is to note that the numbers you want to print advance in a regular fashion, too, but with an increment 3 in the example above, or k in general:

for (int i = k; i <= n*k; i = i+k) {
Console.WriteLine(i);
}


The

i = i + k;


is a common pattern, less common than incrementing by one, but still very common. C# and many other languages allow a shorter version:

i += k;


This means to increment the variable i by k.

Warning

Be careful: the += must be in that order, with no space between. Unfortunately the reverse order:

i =+ k;


is also legal, and just assigns the value of k to i.

Most C# binary operations have a similar variation. For instance if op is +, -, *, / or %,

variable op= expression

means the same as

variable = variable op expression

For example

x *= 5;


is the same as

x = x * 5;


## 8.2.1. Tables¶

Reports commonly include tables, often with successive lines generated by a consistent formula. As a simple first table, we can show the square, cube, and square root of numbers 1 through 10. The Math class has a function Sqrt, so we take the square root with Math.Sqrt function. The pattern is consistent, so we can loop easily:

for ( int n = 1; n <= 10; n++) {
Console.WriteLine("{0} {1} {2} {3}", n, n*n, n*n*n, Math.Sqrt(n));
}


The numbers will be there, but the output is not pretty:

1 1 1 1
2 4 8 1.4142135623731
3 9 27 1.73205080756888
4 16 64 2
5 25 125 2.23606797749979
6 36 216 2.44948974278318
7 49 343 2.64575131106459
8 64 512 2.82842712474619
9 81 729 3
10 100 1000 3.16227766016838


First we might not need all those digits in the square root approximations. We can replace {3} by {3:F4} to just show 4 decimal places.

We can adjust the spacing to make nice columns by using a further formatting option. The longest entries are all in the last row, where they take up, 2, 3, 4, and 6 columns (for 3.1623). Change the format string:

for ( int n = 1; n <= 10; n++) {
Console.WriteLine("{0,2} {1,3} {2,4} {3,6:F4}",
n, n*n, n*n*n, Math.Sqrt(n));
}


and we generate the neater output:

 1   1    1 1.0000
2   4    8 1.4142
3   9   27 1.7321
4  16   64 2.0000
5  25  125 2.2361
6  36  216 2.4495
7  49  343 2.6458
8  64  512 2.8284
9  81  729 3.0000
10 100 1000 3.1623


We are using two new formatting forms:

{index,fieldWidth} and
{index,fieldWidth:F#}

where index, fieldWidth, and # are replaces by specific literal integers. The new part with the comma (not colon) and fieldWidth, sets the minimum number of columns used for the substituted string, padding with blanks as needed.

Warning

There is a special language for the characters between the braces in a format string. The rules are different than in regular C# code, where comma and colon are symbols, and the parser allows optional whitespace around them. This is not the case inside the braces of a format string: There cannot be a space after the colon or before the comma. Some blanks are legal; some blanks lead to exceptions being thrown, and other positions for blanks just silently give the wrong format.

The safest approach for a programmer is just to have no blanks between the braces in a format string.

If the string to be inserted is wider than the fieldWidth, then the whole string is inserted, ignoring the fieldWidth. Example:

string s = "stuff";
Console.WriteLine("123456789");
Console.WriteLine("{0,9}\n{0,7}\n{0,5}\n{0,3}", s);


generates:

123456789
stuff
stuff
stuff
stuff


filling 9, 7, and then 5 columns, by padding with 4, 2, and 0 blanks. The last line sticks out past the proposed 3-column fieldWidth.

One more thing to add to our power table is a heading. We might want:

n   square    cube    root


To make the data line up with the heading titles, we can expand the columns, with code in example power_table/power_table.cs:

Console.WriteLine("{0,2}{1,7}{2,5}{3,7}",
"n", "square", "cube", "root");
for ( int n = 1; n <= 10; n++) {
Console.WriteLine("{0,2}{1,7}{2,5}{3,7:F4}",
n, n*n, n*n*n, Math.Sqrt(n));
}


generating:

 n  square    cube    root
1       1       1  1.0000
2       4       8  1.4142
3       9      27  1.7321
4      16      64  2.0000
5      25     125  2.2361
6      36     216  2.4495
7      49     343  2.6458
8      64     512  2.8284
9      81     729  3.0000
10     100    1000  3.1623


Note how we make sure the columns are consistent in the heading and further rows: We used a format string for the headings with the same field widths as in the body of the table. A separate variation: We also reduced the length of the format string by putting all the substitution expressions in braces right beside each other, and generate the space between columns with a larger field width.

Left Justification: Though our examples have always right justified in a field (padding on the left), for completeness we note this alternative: A minus sign in front of the fieldWidth places the result left justified (padded on the right). For example:

string s = "stuff";
Console.WriteLine("1234567890");
Console.WriteLine("{0,-9}|\n{0,-7}|\n{0,-5}|\n{0,-3}|", s);


prints:

1234567890
stuff    |
stuff  |
stuff|
stuff|


where the ‘|’ appears after any blank padding in each line.

## 8.2.2. ASCII Codes¶

Here is a reverse lookup from the Numeric Code of String Characters: Find the characters for a list of numeric codes. Just as we can cast a char to an int, we can cast an int 0-127 to a char.

The Unicode used by C# is an extension of the ASCII codes corresponding to the characters on a US keyboard. The codes were originally used to drive printers, and the first 32 codes are non-printable instructions to the printer. Characters 32 - 126 yield the 95 characters on a standard US keyboard.

A loop to print each code followed by a space and the corresponding printable character would be:

for (int i = 32; i < 127; i++) {
Console.WriteLine("{0,3} {1}", i, (char)i);
}


To make all the character line up we added a field width 3 for the code column.

If you run this in csharp, the first line printed does not appear to have a character: That is the blank character. All the other characters are visible.

Let us make a more concise table, putting 8 entries per line. We can print successive parts using Write instead of WriteLine, but we still need to advance to the next line after every 8th entry, for codes 39, 47, 55, .... Since they are 8 apart, their remainder when divided by 8 is always the same:

7 = 39 % 8 = 47 % 8 = 55 % 8 = ....

We can add a newline after each of these is printed. This requires a test:

for (int i = 32; i < 127; i++) {
Console.Write("{0,3} {1}  ", i, (char)i);
if (i % 8 == 7) {
Console.WriteLine();
}
}


Recall that Console.WriteLine() with no parameters only advances to the next line.

Paste that whole code at once into csharp to see the result.

The next csharp> prompt appears right after 126 ~. There is no eighth entry on the last line, and hence no advance to the next line. A program printing this table should include an extra Console.WriteLine() after the loop.

## 8.2.3. Modular Multiplication Table¶

We have introduced the remainder operator % and mentioned that the corresponding mathematical term is “mod”. We can extend that to the idea of modular arithmetic systems. For example, if we only look at remainders mod 7, we can just consider numbers 0, 1, 2, 3, 4, 5, and 6. We can do multiplication and addition and take remainders mod 7 to get answers in the same range. For example 3 * 5 mod 7 is (3 * 5) % 7 in C#, which is 1. As we look more at this system, we will observe and explain more properties.

The next example is to make a table of multiplication, mod 7, and later generalize.

Tables generally have row and column labels. We can aim for something like:

* | 0 1 2 3 4 5 6
-----------------
0 | 0 0 0 0 0 0 0
1 | 0 1 2 3 4 5 6
2 | 0 2 4 6 1 3 5
3 | 0 3 6 2 5 1 4
4 | 0 4 1 5 2 6 3
5 | 0 5 3 1 6 4 2
6 | 0 6 5 4 3 2 1


The border labels make the table much more readable, but let us start simpler, with just the modular multiplications:

0 0 0 0 0 0 0
0 1 2 3 4 5 6
0 2 4 6 1 3 5
0 3 6 2 5 1 4
0 4 1 5 2 6 3
0 5 3 1 6 4 2
0 6 5 4 3 2 1


This is more complicated in some respects than our previous table, so start slow, with some pseudocode. We need a row for each number 0-6, and so a for loop suggests itself:

for (int r = 0; r < 7; r++) {
print row
}


Each individual row also involves a repeated pattern: calculate for the next number. We can name the second number c for column. The next revision replaces “print row” by a loop: a nested loop, inside the loop for separate rows:

for (int r = 0; r < 7; r++) {
for (int c = 0; c < 7; c++) {
print modular multiple on same line
}
}


and the modular multiplication is just regular multiplication followed by taking the remainder mod 7, so you might come up with the C# code:

for (int r = 0; r < 7; r++) {
for (int c = 0; c < 7; c++) {
int modProd = (r*c) % 7;
Console.Write(modProd + " ");
}
}


You can test this in csharp, and see it is not quite right! Chopped-off output starts:

0 0 0 0 0 0 0 0 1 2 3 4 5 6 0 2 4 6 1 3 5 0 3 6 2 5 1 4 0...


Though we want each entry in a row on the same line, we need to go down to the next line at the end of each line! Where do we put in the newline in the code? A line is all the modular products by r, followed by one newline. Each modular product for a row is printed in the inner for loop. We want to advance after that, so the newline must be inserted outside the inner loop. On the other hand we do want it done for each row, so it must be inside the outer loop:

 1 2 3 4 5 6 7 for (int r = 0; r < 7; r++) { for (int c = 0; c < 7; c++) { int modProd = (r*c) % 7; Console.Write(modProd + " "); } Console.WriteLine(); } 

You can copy and test that code in csharp, and it works!

It is important to be able to play computer on nested loops and follow execution, statement by statement. Look more closely at the code above, noting the added line numbers. The basic pattern is sequential: Complete one statement before going on to the next. Inside the execution of a looping statement, there are extra rules, for testing and looping through the whole body. Within a loop body, each complete statement is executed sequentially.

Most new students can get successfully to line 4:

line r c modProd comment
1 0 - - initialize outer loop
2 0 0 - initialize inner loop
3 0 0 0
4 0 0 0 Write 0

After reaching the bottom of the loop, where do you go? You finish the innermost enclosing statement. You are in the inner loop, so the next line is the inner loop heading where you increment c and continue with the loop since 1 < 7. This inner loop continues until you reach the bottom of the inner loop, line 4, with c = 6, and return to the heading, line 2, and the test fails, finishing the inner row loop:

line r c modProd comment
1 0 - - initialize outer loop
2 0 0 - 0 < 7, enter loop body
3 0 0 0 (0*0)%7
4 0 0 0 Write 0
2 0 1 - c=0+1=1, 1 < 7: true
3 0 1 0 (0*1)%7
4 0 1 0 Write 0
2 0 2 - c=1+1=2, 2 < 7: true
...       ... through c = 6
4 0 6 0 Write 0
2 0 7 - c=+1=7, 7 < 7: false

At this point the inner loop statement, lines 2-4, has completed, and you continue. You go on to the next statement in the same sequential chuck as the inner loop statement in lines 2-4: That sequential chunk is the the outer loop body, lines 2-6. The next statement is line 6, advancing printing to the next line. That is the last statement of the outer loop, so you return to the heading of the outer loop and modify its loop variable r. The two lines just described are:

line r c modProd comment
6 0 - - print a newline
1 1 - - r=s0+1=1, 1 < 7 enter outer loop

Then you go all the way through the inner loop again, for all columns, with c going from 0 through 6, and exit at c=7, finish the body of the outer loop by advancing to a new print line, and return to the outer loop heading, setting r = 2..., until all rows are completed.

The common error here is to forget what loop is the innermost one that you are working on, and exit that loop before is is totally finished: It finishes when the test of the condition controlling the loop becomes false.

Look back one more time and make sure the code for this simpler table makes sense before we continue to the one with labels....

The fancier table has a couple of extra rows at the top. These two rows are unlike the remaining rows in the body of the table, so they need special code.

If we go back to our pseudocode we could add to it:

print heading row
print dash-row
for (int r = 0; r < 7; r++) {
print body row
}


First analyze the heading row: Some parts are repetitive and some are not: Print "* |" once, and then there is a repetitive pattern printing 0 - 6, which we can do with a simpler loop than in the table body:

Console.Write("* | ");
for ( int i = 0; i < 7; i++) {
Console.Write(i + " ");
}
Console.WriteLine();


The dashed line can be generated using StringOfReps from Lab: Loops. How many dashes? A digit and a space for each of seven columns and for a row header, so we need (7+1)*(1+1) characters, plus one for the ‘|’: 1 + (7+1)*(1+1). Thinking ahead, we will leave that expression unsimplified.

We have done most of the work for the rows of the body of the table in the simpler version. We just have a bit of printing for the initial row label. Where does the code go? It is repeated for each row, so it is inside the outer loop, but it is just printed once per row, so it comes before the inner column loop. The row label is r. The whole code is in example mod7_table/mod7_table.cs and below:

//heading
Console.Write("* | ");
for ( int i = 0; i < 7; i++) {  //column headings
Console.Write(i + " ");
}
Console.WriteLine();

Console.WriteLine(StringOfReps("-", 1 + (7+1)*(1+1)));

for (int r = 0; r < 7; r++) {     // table body
Console.Write(r + " | ");      // row heading
for (int c = 0; c < 7; c++) {  // data columns
int modProd = (r*c) % 7;
Console.Write(modProd + " ");
}
Console.WriteLine();
}


Besides the 0 row and 0 column in the mod 7 table, note that in each line the products are a permutation of all the numbers 1-6. That means it is possible to define the inverse of the multiplication operation, and mod 7 arithmetic actually forms a mathematical field. Modular arithmetic (with much larger moduli!) is extremely important in public key cryptography, which protects all your online financial transactions.... Knowing a lot more math is useful! (But it is not required for this course.)

The inverse operation to multiplication for prime moduli is easy to work out by brute force, going through the row of products. A much more efficient method is needed for cryptography: That method involves an elaboration of Greatest Common Divisor.

Finally, let us generalize this table to mod n. With n up to about 25, it is reasonable to print. Most of the changes are just replacing 7 by n. There is a further complication with column width, since the numbers can be more than one digit long. We can do formatting with a field width. Unfortunately in C# the field width must be a literal integer embedded in the format string, but our number of digits in n is variable.

Here is a good trick: Construct the format string inside the program. To get the format for a number and an extra space mod 7, we want format string “{0,1} ”, but for mod 11, we want “{0,2} ”. This 1 or 2 is the number of characters in n as a string, given by

numberWidth = ("" + n).Length;


We can create the format string with a string concatenation expression:

string colFormat = "{0," + numberWidth + "}";


or use another format string and substitution. This is an excuse to illustrate including explicit braces (for the main format string). Recall the explicit braces are doubled. Check out this version:

string colFormat = string.Format("{{0,{0}}} ", numberWidth);


which we use in the code for the whole function, below, and in example program mod_mult_table/mod_mult_table.cs.

/// Print a table for modular multiplication mod n.
static void MultTable(int n)
{
int numberWidth = ("" + n).Length;
string colFormat = string.Format("{{0,{0}}} ", numberWidth);
string rowHeaderFormat = colFormat + "| ";
for ( int i = 0; i < n; i++) {
Console.Write(colFormat, i);
}
Console.WriteLine();

Console.WriteLine(StringOfReps("-",(numberWidth+1)*(n+1) + 1));

for (int r = 0; r < n; r++) { //rows of table body
for (int c = 0; c < n; c++) {
Console.Write(colFormat, (r*c) % n);
}
Console.WriteLine();
}
}


## 8.2.4. Reversed String Returned¶

In String Backwards Exercise/Example we discuss iterating through a string’s indices and characters to print the string reversed. That might be useful, but it logically the joining of two separate ideas: reversing a string and printing it. We already know how to print a string as a step. Now consider the first part as its own function:

      /// Return s in reverse order.
/// If s is "drab", return "bard".
static string Reverse (string s)


To go along with this chapter, we will use a for loop heading rather a while loop as in reversed_print/reversed_print.cs:

for (int i = s.Length - 1; i >= 0; i--) {


A more significant difference is that in the previous example we immediately printed, individually, each letter that we wanted. Now we need to create a single string, with all the characters, before returning the result.

Let us think of the example in the documentation: If we start with s as "drab", and we go through the letters one at a time in reverse order, b a r d, we build up successively:

b
ba
bar
bard


We need a loop with variables and operations. The sequence of reversed letters, s[i], are the last character on the end of each line above.

At least lines after the first are constructed from previous parts, so, for instance, "bar" comes from combining the initial part "ba" with the latest character 'r' (s[i]). We need a name for the initial part. I used the name rev. Combining with a string is done with the + operator. Then when rev is "ba" and s[i] is 'r', the combination, using the variable names, is

rev + s[i]


We want this in our loop, so we must be able to use that expression each time through the loop, so rev changes each time through the loop. In the next iteration rev is the result of the previous expression. The assignment statement to give us the next version of rev can just be:

rev = rev + s[i];


That gives us the general rule. Pay attention now to the beginning and end: The end is simple: The last value for rev is the complete reversed string, so that is what we return.

How do we initialize rev? You could imagine rev starting as "b", but the the first character that we add is 'a', and we would not be going through all the characters in our loop. It is better to go all the way back to the beginning: If we use the general form with the first letter in the reversed sequence,

rev = rev + s[i];


then the result of the initial rev + 'b' should just be "b". So what would rev be?

Remember the empty string: initialize rev to be "".

The result is:

/// Return s in reverse order.
/// If s is "drab", return "bard".
static string Reverse (string s)
{
string rev = "";
for (int i = s.Length - 1; i >= 0; i--) {
rev += s[i];
}
return rev;
}


We used our new operator += to be more concise.

This function and a Main used to demonstrate it are in reversed_string/reversed_string.cs.

## 8.2.5. Exercises¶

### 8.2.5.1. Head or Tails Exercise¶

Write a program heads_tails.cs. It should include a function Flip(), that will just randomly print Heads or Tails once. Accomplish this by choosing 0 or 1 arbitrarily with a random number generator. More details follow.

Use a Random object, as in Number Guessing Game Lab, except this time it is important not to make the Random object be a local variable inside the Flip function: A new Random object in likely initialized using the current time. The Flip function has no interaction with the user, so it can be repeated very quickly, and new Random objects may not register a new value through several reruns of Flip. This would give the same answer, and be completely contrary to the idea of random results!

Hence it is generally a good idea to only create a single Random object that stays in scope for the whole program. One way to do that is to make it static. Place the declaration

static Random r = new Random();


inside your class but outside of any function, positioned like the static constants discussed in Static Variables.

Then you can use r in any function in your class. For int variables low and higher, with low < higher:

int n = r.Next(low, higher);


returns a (pseudo) random int, satisfying low <= n < higher. If you select low and higher as 0 and 2, so there are only two possible values for n, then you can choose to print Heads or Tails with an if-else statement based on the result.

Warning

We have discovered some problems with the Next() implementation when running on Mono that sometimes results in random values not being generated. This is likely a bug that will be fixed. If you experience any problems with Next(), the following is for you!

An alternative to generating random 0 and 1 values for heads and tails is to generate random double-precision values. Using the same variable, r, you can call r.NextDouble() to get a random value between 0 and 1. You can consider any generated value $$n < 0.5$$ to be heads; $$n >= 0.5$$ represents tails:

double n = r.NextDouble();
if (n < 0.5) {
} else {
// tails
}


In your Main method have a for loop calling Flip() 10 times to test it, so you generate a random sequence of 10 heads and/or tails. With these 10 rapid calls, it is important that a new Random object is only created once. The suggested static variable declaration ensures that.

### 8.2.5.2. Group Flips Exercise¶

Write a program format_flips.cs. It should include the function Flip() and the static Random declaration from the last exercise. Also include another function:

/// Print out the results from the total number of random flips of a coin.
/// Group them groupSize per line, each followed by a space.
/// The last line may contain fewer than groupSize flips
/// if total is not a multiple of groupSize.  The last line
/// should be followed by exactly one newline in all cases.
/// For example, GroupFlips(10, 4) *could* produce:
///   Tails Tails
static void GroupFlips(int total, int groupSize)


Complete this function definition and test with a variety of calls to GroupFlips in Main. The output from the previous exercise would be produced by the call:

GroupFlips(10, 1);


### 8.2.5.3. Reverse String foreach Exercise¶

We already have discussed Reversed String Returned. It used a for loop to go through the characters in reverse order. Write a version with the only loop heading:

foreach(char ch in s) {


and no reference to indices in s.

### 8.2.5.4. Only Letters Exercise¶

Write a program that defines and tests a function with description and heading:

/// Return s with all non-letters removed.
/// For example OnlyLetters("Hello, World!") returns "HelloWorld".
static string OnlyLetters(string s)


Assume the English alphabet.

### 8.2.5.5. Palindrome Exercise¶

Write a program palindrome.cs that defines and tests a function with description and heading:

/// Return true when s is a palindrome.
/// For example IsPalindrome("A Toyota!") returns true.
static bool IsPalindrome(string s)


A palindrome is a string that contains the same sequence of letters, ignoring capitalization, forward and backward. Non-letters are ignored. Examples are “Madam, I’m Adam.” and “Able was I ‘ere I saw Elba.”

IsPalindrome can be written very concisely by copying and using functions from previous exercises.

### 8.2.5.6. Nested Play Computer Exercise¶

Predict what these code fragments print. Then check yourself in csharp:

for (int i = 3; i > 0; i--) {
for (int j = i; j < 4; j++) {
Console.Write(j);
}
Console.WriteLine();
}

string s = "abcdef";
for (int i = 1; i < s.Length; i += 2) {
for (int k = 0; k < i; k++) {
Console.Write(s[i]);
}
}


### 8.2.5.7. Power Table Exercise¶

1. Write a program power_table.cs that completes and tests the function with this heading. Be sure your program tests with several values for each parameter:

/// Print a table of powers of positive integers.
/// Assume 1 <= nMax <= 12, 1 <= powerMax <= 7.
/// Example: output of PowerTable(3, 4)
///       n^1       n^2      n^3      n^4
///         1         1        1        1
///         2         4        8       16
///         3         9       27       81
///
public static void PowerTable(int nMax, int powerMax)


Make sure the table always ends up with right-justified columns.

2. Make the table have columns all the same width, but make the width be as small as possible for the parameters provided, leaving a minimal one space (but not less!) between columns somewhere in the table. Consider heading widths, too.