Details on Counting and Looping
|
|
Details on Counting and Looping |
Doing Something While a Condition is True
Introduction
The C# language supports various ways to keep checking a condition to take some action until a condition becomes false. In the previous lesson, we saw that one way to perform this operation is with the with keyword. We also saw that this with keyword by itself doesn't control the starting point of its operation. You need an external way to set that starting point. Fortunately, C# provides various options to address different issues related to counting and looping.
Practical Learning: Introducing Looping
| Control | (Name) | Text | TextAlign |
| Label | Machine Cost: | ||
| TextBox | txtMachineCost | Right | |
| Label | Estimated Life: | ||
| TextBox | txtEstimatedLife | Right | |
| Label | Years | ||
| Button | btnCalculate | Calculate | |
| Label | ____________ | ||
| Label | Declining Rate: | ||
| TextBox | txtDecliningRate | Right | |
| Label | % | ||
| ListView | lvwDepreciation |
View: Details GridLines: True FullRowSelect: True Anchor: Top, Bottom, Left, Right |
List View Columns
| (Name) | Text | TextAlign | Width |
| colYears | Years | 35 | |
| colBeginningOfYear | Book Value at Beginning of Year | Center | 170 |
| colDepreciationYear | Depreciation for the Year | Center | 130 |
| colEndOfYear | Book Value at End of Year | Center | 140 |
do This while a Condition is True
Sometimes, before executing a repeating action, or before checking the condition for the first time, you may want to first execute a statement. In other words, you want to first execute a statement before checking its condition. To make this possible, the C-based languages, which includes C#, use a combination of the do and while keywords used in a formula as follows:
do statement while (condition);
If the statement includes more than one line of code, you must include the statement section in a body included inside curly brackets. The formula becomes:
do { statement } while (condition);
The body delimited by curly brackets can be used even it there is only one statement to exercute.
The do...while condition executes a statement first. After the first execution of the statement, the compiler examines the condition. If the condition is true, then it executes the statement again. It will keep executing the statement as long as the condition is true. Once the condition becomes false, the looping (the execution of the statement) will stop. This can be illustrated as follows:
If the statement is a short one, such as made of one line, you can write it after the do keyword. Like the if and the while statements, the condition being checked must be included between parentheses. The whole do...while statement must end with a semicolon. Here is an example:
If you are creating the condition in a method of a class, if the statement is long and should span more than one line, start it with an opening curly bracket "{" and end it with a closing curly bracket "}".
using static System.Console;
public class Exercise
{
public static int Main(string[] args)
{
int number = 0;
do {
WriteLine("Make sure you review the time sheet before submitting it.");
number++;
} while (number <= 4);
WriteLine("==========================================================");
return 1_000;
}
};
This would produce:
Make sure you review the time sheet before submitting it. Make sure you review the time sheet before submitting it. Make sure you review the time sheet before submitting it. Make sure you review the time sheet before submitting it. Make sure you review the time sheet before submitting it. ========================================================== Press any key to continue . . .
Practical Learning: doing Something while a Condition is True
using System;
using System.Windows.Forms;
namespace DoubleDecliningBalance1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void btnCalculate_Click(object sender, EventArgs e)
{
int estimatedLife;
double machineCost = 0.00;
try
{
machineCost = double.Parse(txtMachineCost.Text);
}
catch (FormatException)
{
MessageBox.Show("You must type a valid value that represents the " +
"cost of the machine. Since you don't provide a " +
"valid value, we will set the machine cost to 0.00.",
"Depreciation: Straight-Line Method");
txtMachineCost.Text = "0.00";
}
try
{
estimatedLife = int.Parse(txtEstimatedLife.Text);
}
catch (FormatException)
{
MessageBox.Show("You didn't enter a valid number of years for the life of " +
"the machine. Please correct it, otherwize, we will consider that this machine " +
"has no life, or a life of 0 years.",
"Depreciation: Straight-Line Method");
estimatedLife = 1;
txtEstimatedLife.Text = "1";
}
double decliningRate = (100.00 / estimatedLife) * 2.00;
double[] yearlyDepreciations = new double[estimatedLife];
double[] bookValuesEndOfYear = new double[estimatedLife];
double[] bookValuesBeginningOfYear = new double[estimatedLife];
int year = 1;
// Year 1
bookValuesBeginningOfYear[0] = machineCost;
yearlyDepreciations[0] = machineCost * decliningRate / 100;
bookValuesEndOfYear[0] = machineCost - yearlyDepreciations[0];
int i = 1;
// The other years
do
{
yearlyDepreciations[i] = bookValuesEndOfYear[i - 1] * decliningRate / 100;
bookValuesEndOfYear[i] = bookValuesEndOfYear[i - 1] - yearlyDepreciations[i];
bookValuesBeginningOfYear[i] = bookValuesEndOfYear[i - 1];
i++;
} while (i <= estimatedLife - 1);
i = 0;
ListViewItem lviDepreciation = null;
// Displaying the values
txtDecliningRate.Text = decliningRate.ToString("F");
lvwDepreciation.Items.Clear();
do
{
lviDepreciation = new ListViewItem(year.ToString());
lviDepreciation.SubItems.Add(Math.Ceiling(bookValuesBeginningOfYear[i]).ToString());
lviDepreciation.SubItems.Add(Math.Ceiling(yearlyDepreciations[i]).ToString());
lviDepreciation.SubItems.Add(Math.Ceiling(@bookValuesEndOfYear[i]).ToString());
lvwDepreciation.Items.Add(lviDepreciation);
i++;
year++;
} while (i <= estimatedLife - 1);
}
}
}
Machine Cost: 24680 Estimated Life 8
| Control | (Name) | Text | TextAlign |
| Label | United Mexican States | Font: Georgia, 20.25pt, style=Bold | |
| Label | ____________________________________ | ||
| ListView | lvwStates |
View: Details GridLines: True FullRowSelect: True Anchor: Top, Bottom, Left, Right |
List View Columns
| (Name) | Text | TextAlign | Width |
| colNumber | # | 25 | |
| colStateName | State Name | 100 | |
| colCapital | Capital | 150 | |
| colAreaSqrKms | Area (Sqr Kms) | Right | 90 |
| colAreaSqrMiles | Area (Sqr Ml) | Right | 80 |
| colAdmissionToFederation | Admission to Federation | Center | 130 |
Introduction
Some operations require that you visit each item in a range, usually a range of numbers. To let you do this,the C-based languages, including C#, provide the for keyword. The primary formula to follow is:
for(start; end; frequency) statement;
The for loop is typically used to visit each number of a range. For this reason, it is divided in three parts. The first section specifies the starting point of the range. This start expression can be a variable assigned to the starting value. An example would be int count = 0;.
The second section sets the counting limit. This end expression is created as a Boolean expression that can be true or false. An example would be count < 5. This means that the counting would continue as long as the value of start is less than 5. When such a condition becomes false, the loop or counting would stop.
The last section determines how the counting should move from one value to another. If you want the loop to increment the value from start, you can apply the ++ operator to it. Here is an example:
using static System.Console;
public class Exercise
{
public static int Main(string[] args)
{
for (int number = 0; number <= 5; number++)
WriteLine("The time sheet was checked and this payroll has been approved.");
WriteLine("===============================================================");
return 15_000_101;
}
}
This would produce:
The time sheet was checked and this payroll has been approved. The time sheet was checked and this payroll has been approved. The time sheet was checked and this payroll has been approved. The time sheet was checked and this payroll has been approved. The time sheet was checked and this payroll has been approved. The time sheet was checked and this payroll has been approved. =============================================================== Press any key to continue . . .
In the above example, we declared the variable in the for expression. You can use a variable from any source or declare a variable before the loop. Here is an example:
using static System.Console;
public class Exercise
{
public static int Main(string[] args)
{
int number;
for (number = 0; number <= 5; number++)
WriteLine("The time sheet was checked and this payroll has been approved.");
WriteLine("===============================================================");
return 15_000_101;
}
}
In the above code, we first declared a variable, then initialized it in the loop. If you have a variable that has been initialize and want to use it in the loop, in the section of the loop where the variable is supposed to be initialized, leave it empty. Here is an example:
using static System.Console;
public class Exercise
{
public static int Main(string[] args)
{
span class="codered">int number = 0;
for (; number <= 5; number++)
WriteLine("The time sheet was checked and this payroll has been approved.");
WriteLine("===============================================================");
return 15_000_101;
}
}
Practical Learning: Counting for a Loop
using System.Windows.Forms;
namespace CountriesStatistics3
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
Show();
}
void Show()
{
string[] states = new string[31];
states[0] = "Guanajuato"; states[1] = "Tamaulipas"; states[2] = "Michoacán"; states[3] = "Coahuila";
states[4] = "Chihuahua"; states[5] = "Baja California Sur"; states[6] = "Nayarit"; states[7] = "Puebla";
states[8] = "Oaxaca"; states[9] = "Morelos"; states[10] = "Sonora"; states[11] = "Aguascalientes";
states[12] = "Baja California"; states[13] = "Tabasco"; states[14] = "Jalisco"; states[15] = "México";
states[16] = "Guerrero"; states[17] = "Colima"; states[18] = "Zacatecas"; states[19] = "Sinaloa";
states[20] = "Campeche"; states[21] = "Quintana Roo"; states[22] = "Nuevo León"; states[23] = "Hidalgo";
states[24] = "Tlaxcala"; states[25] = "Yucatán"; states[26] = "Querétaro"; states[27] = "Veracruz";
states[28] = "San Luis Potosí"; states[29] = "Durango"; states[30] = "Chiapas";
string[] capitals = new string[] { "Guanajuato", "Ciudad Victoria", "Morelia",
"Saltillo", "Chihuahua", "La Paz",
"Tepic", "Puebla de Zaragoza", "Oaxaca de Juárez",
"Cuernavaca", "Hermosillo", "Aguascalientes",
"Mexicali", "Villahermosa", "Guadalajara",
"Toluca de Lerdo", "Chilpancingo de los Bravo", "Colima",
"Zacatecas", "Culiacán", "San Francisco de Campeche",
"Chetumal", "Monterrey", "Pachuca",
"Tlaxcala", "Mérida", "Santiago de Querétaro",
"Xalapa", "San Luis Potosí", "Victoria de Durango", "Tuxtla Gutiérrez"};
int[] areasSqrKms = new int[] { 30608, 80175, 58643, 151563, 247455, 73922, 27815, 34290, 93793, 4893,
179503, 5618, 71446, 24738, 78599, 22357, 63621, 5625, 75539, 57377,
57924, 42361, 64220, 20846, 3991, 39612, 11684, 71820, 60983, 123451, 73289 };
int[] areasSqrMiles = new int[] { 11818, 30956, 22642, 58519, 95543, 28541, 10739, 13240, 36214, 1889,
69306, 2169, 27585, 9551, 30347, 8632, 24564, 2172, 29166, 22153,
22365, 16356, 24800, 8049, 1541, 15294, 4511, 27730, 23546, 47665, 28297 };
int[] ordersOfAdmissionToFederation = new int[] { 2, 14, 5, 16, 18, 31, 28, 4, 3, 27,
12, 24, 29, 13, 9, 1, 21, 23, 10, 20,
25, 30, 15, 26, 22, 8, 11, 7, 6, 17, 19 };
ListViewItem lviState = null;
for(int i = 0; i < states.Length; i++)
{
lviState = new ListViewItem((i + 1).ToString());
lviState.SubItems.Add(states[i]);
lviState.SubItems.Add(capitals[i].ToString());
lviState.SubItems.Add(areasSqrKms[i].ToString());
lviState.SubItems.Add(areasSqrMiles[i].ToString());
lviState.SubItems.Add(ordersOfAdmissionToFederation[i].ToString());
lvwStates.Items.Add(lviState);
}
}
}
}
| Control | (Name) | Text | TextAlign |
| Label | Machine Cost: | ||
| TextBox | txtMachineCost | Right | |
| Label | Salvage Value: | ||
| TextBox | txtSalvageValue | Right | |
| Label | Estimated Life: | ||
| TextBox | txtEstimatedLife | Right | |
| Label | Years | ||
| Button | btnCalculate | Calculate | |
| Label | ____________ | ||
| Label | Depreciable Amount: | ||
| TextBox | txtDepreciableAmount | Right | |
| Label | % | ||
| ListView | lvwDepreciation |
View: Details GridLines: True FullRowSelect: True Anchor: Top, Bottom, Left, Right |
List View Columns
| (Name) | Text | TextAlign | Width |
| colYears | Years | ||
| colFraction | Fraction | Center | 100 |
| colDepreciation | Depreciation | Center | 125 |
Reversing the Counting Direction
Instead of proceeding from a lower to a higher value in a loop, you can visit the values from the end of a list to the beginning. To do this, fir the first part of the loop, set the last value as the starting point. For the second part of the loop, specify the possible ending point as the first value. For its Boolean expression, you usually set a condition that would work backwards. This is usually done using the > or the >= operator. The last section usually applies the -- operator to the variable of the loop. The formula to follow can be the following:
for(end; start; frequency) statement;
Practical Learning: Reversing the Counting Direction
using System;
using System.Windows.Forms;
namespace SumOfTheYearsDigits1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void btnCalculate_Click(object sender, EventArgs e)
{
int estimatedLife;
double machineCost = 0.00;
double salvageValue = 0.00;
try
{
machineCost = double.Parse(txtMachineCost.Text);
}
catch (FormatException)
{
MessageBox.Show("You must type a valid value that represents the " +
"cost of the machine. Since you don't provide a " +
"valid value, we will set the machine cost to 0.00.",
"Depreciation: Straight-Line Method");
txtMachineCost.Text = "0.00";
}
try
{
salvageValue = double.Parse(txtSalvageValue.Text);
}
catch (FormatException)
{
MessageBox.Show("You must provide a value you estimate the machine " +
"will have at the end of the cycle (or the end of its " +
"life cycle). If you don't enter a valid value, we will " +
"consider the estimated end value to 0.00.",
"Depreciation: Straight-Line Method");
txtSalvageValue.Text = "0.00";
}
try
{
estimatedLife = int.Parse(txtEstimatedLife.Text);
}
catch (FormatException)
{
MessageBox.Show("You didn't enter a valid number of years for the life of " +
"the machine. Please correct it, otherwize, we will consider " +
"that this machine has no life, or a life of 0 years.",
"Depreciation: Straight-Line Method");
estimatedLife = 1;
}
int year = 1;
int reverse = 0;
int sumOfYears = (estimatedLife * (estimatedLife + 1)) / 2;
double[] depreciations = new double[estimatedLife];
string[] fractions = new string[estimatedLife];
double depreciatiableAmount = machineCost - salvageValue;
txtDepreciatiableAmount.Text = depreciatiableAmount.ToString("F");
for (int i = estimatedLife - 1; i >= 0; i--)
{
fractions[reverse] = (i + 1) + "/" + sumOfYears;
depreciations[reverse] = (depreciatiableAmount * (i + 1)) / sumOfYears;
reverse++;
}
ListViewItem lviDepreciation = null;
lvwDepreciation.Items.Clear();
for (int i = 0; i <= @estimatedLife - 1; i++)
{
lviDepreciation = new ListViewItem(year.ToString());
lviDepreciation.SubItems.Add(fractions[i].ToString());
lviDepreciation.SubItems.Add(Math.Ceiling(depreciations[i]).ToString());
lvwDepreciation.Items.Add(lviDepreciation);
year++;
}
}
}
}
Machine Cost: 6850 Salvage Value: 500 Estimated Life 8
For Each Item In a List
Inseead of visiting the elements of a list by counting them, you may want to visit each item directly. To assist you with this, the C# language provides an operator named foreach. The formula to use it is:
foreach(variable in list) statement;
The loop starts with the foreach keyword followed by parentheses. In the parentheses, enter the list that contains the elements you want. Precede that list with an operator named in. The foreach loop needs a variable that would represent an item from the list. Therefore, in the parentheses, start by declaring a variable before the in operator. Of course, the variable declared by a data type and a name. Outside the parentheses, create a statement of your choice. At a minimum, you can simply display the variable's value to the user. Here is an example:
using static System.Console;
public class Exercise
{
public static int Main(string[] args)
{
int[] numbers = new int[] { 102, 44, 525, 38, 6, 28, 24481, 327, 632, 104 };
foreach (int n in numbers)
WriteLine("Number: {0}", n);
WriteLine("===============================");
return 22_813_729;
}
}
This would produce:
Number: 102 Number: 44 Number: 525 Number: 38 Number: 6 Number: 28 Number: 24481 Number: 327 Number: 632 Number: 104 =============================== Press any key to continue . . .
You can declare the variable with the var keyword. Here is an example:
using static System.Console;
public class Exercise
{
public static int Main(string[] args)
{
string[] provinces = new string[] { "Saskatchewan", "British Columbia",
"Ontario", "Alberta", "Manitoba" };
foreach (var administration in provinces)
WriteLine("Province: {0}", administration);
WriteLine("===============================");
return 22_813_729;
}
}
You can include the statement inside curly brackets. This is especially useful if you to execute more than one statement.
Controlling a Loop
Loops and Conditional Statement Nesting
You can create a conditional statement in the body of a loop. This is referred to as a nesting. Here is an example:
using static System.Console;
public class Exercise
{
public static int Main(string[] args)
{
int number = 0;
while (number < 5)
{
WriteLine("Make sure you review the time sheet before submitting it.");
if (number == 2)
WriteLine("This is the third warning about your time sheet.");
number++;
}
WriteLine("===============================================================");
return 15_000_101;
}
}
This would produce:
Make sure you review the time sheet before submitting it. Make sure you review the time sheet before submitting it. Make sure you review the time sheet before submitting it. This is the third warning about your time sheet. Make sure you review the time sheet before submitting it. Make sure you review the time sheet before submitting it. =============================================================== Press any key to continue . . .
On the other hand, you can nest a loop in a conditional statement.
As mentioned in our introductions, a loop is supposed to navigate from a starting point to an ending value. Sometimes, for any reason, you want to stop that navigation before the end of the loop. To support this, the C-based languages, which include C#, provide the break keyword. The formula to use the break statement is:
break;
Although made of only one word, the break statement is a complete statement; therefore, it can (and should always) stay on its own line (this makes the program easy to read).
The break statement applies to the most previous conditional statement to it; provided that previous statement is applicable. The break statement can be used in a while condition, in a do...while, or a for loops to stop an ongoing operation. Here is an example that is used to count the levels of a house from 1 to 12 but it is asked to stop at 3:
using static System.Console;
public class Exercise
{
public static int Main(string[] args)
{
for (int number = 0; number <= 5; number++)
{
WriteLine("The time sheet was checked and this payroll has been approved.");
if (number == 2)
break;
}
WriteLine("===============================================================");
return 15_000_101;
}
}
This would produce:
The time sheet was checked and this payroll has been approved. The time sheet was checked and this payroll has been approved. The time sheet was checked and this payroll has been approved. =============================================================== Press any key to continue . . .
Continuing a Conditional Statement
Instead of stopping the flow of a loop, you may want to skip one of the values. To support this, the C-based languages such as C# provide the continue keyword. The formula to use it is:
continue;
When processing a loop, if the statement finds a false value, you can use the continue statement inside of a while, a do...while, or a for conditional statements to ignore the subsequent statement or to jump from a false Boolean value to the subsequent valid value, unlike the break statement that would exit the loop. Like the break statement, the continue keyword applies to the most previous conditional statement and should stay on its own line. Here is an example that is supposed to count the levels of a house from 1 to 6:
using static System.Console;
public class Exercise
{
public static int Main(string[] args)
{
string strNumbers = "";
for (int number = 0; number <= 5; number++)
{
if (number == 3)
continue;
strNumbers += number.ToString() + " ";
WriteLine("The list of numbers is {0}", strNumbers);
}
WriteLine("===========================================");
return 15_000_101;
}
}
This would produce:
The list of numbers is 0 The list of numbers is 0 1 The list of numbers is 0 1 2 The list of numbers is 0 1 2 4 The list of numbers is 0 1 2 4 5 =========================================== Press any key to continue . . .
Notice that, when the compiler gets to 3, it ignores it.
Changing a Value in the Loop
Inside a loop, you may want to put a flag that would monitor the evolution of a piece of code so that, if a certain value is encountered, instead of skipping the looping by 1, you can make it jump to a valued range of your choice. To do this, in the loop, check the current value and if it gets to one you are looking for, change it. Here is an example where a loop is asked to count from 0 to 15:
using static System.Console;
public class Exercise
{
public static int Main(string[] args)
{
string strNumbers = "";
for (int number = 0; number < 15; number++)
{
if (number == 6)
number = 10;
strNumbers += number.ToString() + " ";
}
WriteLine("The list of numbers is {0}", strNumbers);
WriteLine("===========================================");
return 22_813_729;
}
}
This would produce:
The list of numbers is 0 1 2 3 4 5 10 11 12 13 14 =================================================== Press any key to continue . . .
Notice that, when the loop reaches 6, it is asked to jump to number 10 instead.
Selecting a Value From a List
Introduction
If you have a list, such as an array, made of too many values, at one time you may want to isolate only the first n members of the list, or the last m members of the list, or a range of members from an index i to an index j. Another operation you may be interested to perform is to find out if a certain value exists in the list. One more interesting operation would be to find out what members or how many members of the list respond to a certain criterion.
for Looping
Consider the following array:
public class Exercise
{
public static int Main(string[] args)
{
int[] numbers = new[] { 102, 44, 525, 38, 6, 28, 24481, 327, 632, 104 };
}
}
Imagine you want to access only the first n members of the array. To do this, you can use an if conditional statement nested in a for loop. Here is an example that produces the first 4 values of the array:
using static System.Console;
public class Exercise
{
public static int Main(string[] args)
{
int[] numbers = new int[] { 102, 44, 525, 38, 6, 28, 24481, 327, 632, 104 };
for (int i = 0; i < 10; i++)
if (i < 4)
WriteLine("Number: {0}", numbers[i]);
WriteLine("===============================");
return 22_813_729;
}
}
This would produce:
Number: 102 Number: 44 Number: 525 Number: 38 =============================== Press any key to continue . . .
You can use the same technique to get the last m members of a list. You can also use a similar technique to get one or a few values inside of the list, based on a condition of your choice. Here is an example that gets the values that are multiple of 5 from the array:
using static System.Console;
public class Exercise
{
public static int Main(string[] args)
{
int[] numbers = new int[] { 102, 44, 525, 38, 6, 28, 24481, 327, 632, 104 };
for (int i = 0; i < 10; i++)
if (numbers[i] % 5 == 0)
WriteLine("Number: {0}", numbers[i]);
WriteLine("===============================");
return 22_813_729;
}
}
This would produce:
Number: 525 =============================== Press any key to continue . . .
while(true)
For the different situations in which we used a while condition so far, we included a means of checking the condition. As an option, you can include juste the true Boolean constant in the parentheses of true. Here is an example:
using static System.Console;
public class Exercise
{
public static int Main(string[] args)
{
while (true)
WriteLine("Application development is fun!!!");
return 22_813_729;
}
}
This type of statement is legal and would work fine, but it has no way to stop because it is telling the compiler "As long as 'this' is true, ...". The question is, what is "this"? As a result, the program would run for ever. Therefore, if you create a while(true) condition, in the body of the statement, you should (must) provide a way for the compiler to stop, that is, a way for the condition to be (or to become) false. This can be done by including an if condition. Here is an example:
using static System.Console;
public class Exercise
{
public static int Main(string[] args)
{
int i = 0;
while (true)
{
if (i > 8)
break;
WriteLine("Application development is fun!!!");
i++;
}
WriteLine("===============================");
return 22_813_729;
}
}
This would produce:
Application development is fun!!! Application development is fun!!! Application development is fun!!! Application development is fun!!! Application development is fun!!! Application development is fun!!! Application development is fun!!! Application development is fun!!! Application development is fun!!! =============================== Press any key to continue . . .
Instead of using while(true), you can first declare and initialize a Boolean variable, or you can use a Boolean variable whose value is already known. The value can come from a method or by other means.
Practical Learning: Ending the Lesson
|
|
||
| Previous | Copyright © 2001-2020, FunctionX | Next |
|
|
||