3.1 program development - william paterson...
TRANSCRIPT
© 2017 Gilbert Ndjatou Page 59
Chapter 3 Problem Solving and the Computer
An algorithm is a step-by-step operations that the CPU must execute in order to solve a problem, or
to perform that task.
A program is the specification of an algorithm in a programming language.
Before a programmer can write a program to solve a problem or to perform a task, he or she must
first determine an algorithm to solve that problem or to perform that task.
This chapter discusses computer problem solving methodologies and how these methodologies are
used to solve and specify the solutions of some standard problems in computer science.
3.1 Program Development
The development of a program to perform a task or to solve a problem is in general
performed in six steps.
These steps are organized into four phases:
1. the requirements analysis phase
2. the design phase
3. the implementation phase and
4. the testing phase
We will use the following simple programming problem to discuss all these steps.
Given that the circumference of a circle is 2 * * r, and that its area is * r * r, where r is its
radius and is the constant value 3.14, write a C++ program to read the radius of a circle, and to
compute its perimeter and area.
Requirements Analysis Phase (Steps 1 and 2)
Step 1: you analyze the problem or the task in order to determine the desired result(s) or the
output items that the program must produce.
For our sample programming problem, the objective is to compute the circumference and
the area of the circle.
The output items are therefore:
the circumference of the circle (identified as circumf )
the area of the circle (Identified as area)
Step 2: you analyze the problem or the task in order to determine the data items (input or
constants) that will be processed in order to produce the desired result(s) or output items.
For our sample programming problem, the input item is the radius of the circle
(identified as radius).
© 2017 Gilbert Ndjatou Page 60
Design Phase (Steps 3 and 4)
Step 3
1. You design an algorithm for transforming the data items (input or generated) into the desired
result(s) or output.
2. You specify the algorithm either in a programming language, using a pseudo-code, or using a
flowchart.
For our sample programming problem, the algorithm is specified in pseudo-code as follows:
1. Read the radius of the circle into variable radius.
2. Calculate the circumference of the circle as follows:
circumf = 2 * 3.14 * radius
3. Calculate the area of the circle as follows:
area = 3.14 * radius * radius
4. Display the results (circumference and area).
Step 4: You check the algorithm manually using specific data to make sure that it is correct.
Implementation Phase (Step 5)
Step 5: You write the algorithm that you have designed in step 3 in a programming language.
For our sample programming problem, the program is provided in Figure 3.1
Testing Phase (Step 6)
Step 6: You test the program (using selected test data) to verify that it works correctly, and that it
also fulfills its requirements.
© 2017 Gilbert Ndjatou Page 61
Figure 3.1
/************************************************************************
Program to read the radius of a circle and to compute its
circumference and area.
************************************************************************/
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
cout << setprecision(2) << fixed << showpoint;
const double PI = 3.14; // holds the value of PI
double radius, // to hold the radius of a circle
circumf, // to hold its circumference
area; // to hold its area
/*-----------------read the radius of the circle---------------*/
cout << “\nEnter the radius of the circle:\t”;
cin >> radius;
/*--------------compute its circumference----------------------*/
circumf = 2 * PI * radius;
/*---------------compute its area -----------------------------*/
area = PI * radius * radius;
/*-------------- print its circumference and area--------------*/
cout << endl << “The circumference of the circle is:\t”
<< circumf << endl << “and its area is:\t” << area;
return( 0 );
}
© 2017 Gilbert Ndjatou Page 62
Algorithm, Flowchart, and Pseudo-code
The basic operations of a C/C++ programming language are specified using the following
statements or structures:
the input statement
the output statement
the assignment statements
the single-way selection structure
the two-way selection structure
the multiple-way selection structure
the counter-controlled iteration structure, and
the logically-controlled iteration structure.
These statements and structures are specified in pseudo-code using English language-like
statements:
The input statement may be specified using an English-like statement with the keyword read.
The output statement may be specified using an English-like statement with the keyword write.
The assignment statement may be specified using an English-like statement with the keyword
compute or calculate.
They may also be specified using the flowchart symbols in Figure 3.2:
The input statement is specified by using symbol (b) in which the keyword read is inserted
along with the names of the variables where values should be read.
The output statement is specified by using symbol (b) in which the keyword write is inserted
along with the expressions whose values should be printed.
The assignment statement is specified by using symbol (c) in which a C++ like assignment
statement is inserted.
© 2017 Gilbert Ndjatou Page 63
Figure 3.2 Flowchart Symbols
SYMBOL
(a)
(b)
(c)
(d)
(e)
(f)
NAME
Terminal
Input/Output
Process
Flow Lines
Decision
Connector
DESCRIPTION
Indicates the beginning or the
end of an algorithm.
Indicates an input or an output
operation.
Indicates a computation or a
data manipulation.
Used to connect the symbols
and to indicate the logic flow.
Indicates a decision point in an
algorithm.
Indicates an entry or an exit
from another part of the
flowchart.
The specification of the above algorithm using a Flowchart is provided in Figure 3.3.
© 2017 Gilbert Ndjatou Page 64
Figure 3.3 Algorithm to read the radius of a circle, and to calculate its circumference and area
Input: the radius of the circle
Output: its circumference and area
Variables: radius (double) to hold the radius of the circle
circumf (double) to hold its circumference
area (double) to hold its area
Exercise 3.1*
a. Specify an algorithm (in pseudo-code and using a flowchart) to read the width and the length of a
rectangle and to calculate its perimeter and area.
b. Write the C++ code segment that corresponds to the algorithm in part a.
Exercise 3.2
In the division of a positive integer value by 10, the quotient is the same number without the right-most
digit (for example, 345 / 10 = 34) and the remainder is the right-most digit (for example, 345 % 10 = 5).
a. Specify an algorithm (using a flowchart) to read a 3-digit positive integer value, and to output its
digits in reverse order (for example, if the integer value is 345, the output will be 5 4 3).
b. Write the C++ program segment that corresponds to the algorithm in part a.
Start
Read
radius
circumf = 2 * 3.14 * radius
area = 3.14 * radius * radius
Write
circumf, area
Stop
© 2017 Gilbert Ndjatou Page 65
3.3 Logical Expressions
The specification of each of the programming language structures above involves a test that the CPU
must first performs on a logical expression (also referred to as a condition).
We will therefore discuss logical expressions before we can discuss these structures.
A logical expression (or condition) is an expression that evaluates to either true or false.
There are two types of conditions:
simple conditions and
Compound conditions.
Simple Conditions
A simple condition has the following syntax:
<arithmetic expression> <relational operator> <arithmetic expression>
Relational Operators
C/C++ Symbol Meaning
< is less than
> is greater than
== is equal to
<= is less than or equal to
>= is greater than or equal to
!= is not equal to
Evaluations of simple conditions
Assuming that the variables are defined and initialized as follows:
int num1 = 5 , num2 = 7 , num3 = 2;
float fnum = 11.75;
char ch = ‘K’;
Evaluate the following conditions:
a) num1 >= 5 d) num2 + 3 == num3 * 4
b) fnum + 7.2 != fnum / 2 e) 3 * num1 + 4 < num3 * 2
c) fnum * 2 > num1 + 20 f) ‘A’ <= ch
© 2017 Gilbert Ndjatou Page 66
Solutions
a) num1 >= 5 d) num2 + 3 == num3 * 4
5 >= 5 7 + 3 == 2 * 4
True 10 == 8
False
b) fnum + 7.2 != fnum / 2 e) 3 * num1 + 4 < num3 * 2
11.75 + 7.2 != 11.75 / 2 3 * 5 + 4 < 2 * 2
18.95 != 5.875 19 < 4
True False
c) fnum * 2 > num1 +20 f) ‘A’ <= ch
11.75 *2 > 5 + 20 ‘A’ <= ‘K’
13.75 > 25 True
False
Characters are ordered according to their ASCII code representations:
‘0' < ‘1' < ‘2' < . . . < ‘9' < ‘A’ < . . . < ‘Z’ < ‘a’ . . . < ‘z’.
Relational operators have a lower precedence than arithmetic operators:
o In the absence of parentheses, arithmetic operations are evaluated before any relational operation
is evaluated.
However, it is a good programming practice to use parentheses to clarify the meaning of logical
expressions.
For example: (fnum * 2) > (num1 + 20)
Exercise 3.3*
Assuming that the variables are defined and initialized as follows:
int num1 = 9 , num2 = 5 , num3 = 10;
float fnum = 12.50;
char ch = ‘P’;
Evaluate the following conditions:
a. num1 <= 5 b. 3 * num1 + 4 < num3 * 2
c. 3 * num2 > fnum + 2 d. 2 * num1 + 12 == 3 * num3
e. num1 + 3 != num1 * 4 f. ch – ‘M’ == 5
© 2017 Gilbert Ndjatou Page 67
Compound Conditions
A compound condition is built from simple conditions and logical operators.
Logical Operators
C++ Symbol Meaning Evaluation
&&
AND
<condition1> && <condition2> is true if and only if
both conditions are true
||
OR
<condition1> || <condition2> is true if and only if at
least one of the two conditions is true
! NOT !<condition> is true if and only if <condition> is false
Evaluations of compound conditions
True || True True || False False || Tue False || False
True True True False
True && True True && False False && True False && False
True False False False
short-circuit evaluation
There is a short-circuit evaluation of a compound condition when you do not have to evaluate the
right-most condition in order to get the true value of the compound condition:
True || True and True || False Therefore True || -
True True True
Also,
False && True and False && False Therefore False && -
False False False
Exercise 3.4*
Assuming that the variables are defined and initialized as follows:
int num1 = 5, num2 = 7, num3 = 2;
float fnum = 11.75;
char ch = ‘K’;
Compute the true value of each of the following compound conditions:
a) num1 >= 5 || num2 + 3 == num3 d) num2 + 3 == num3 * 4 || ch >= ‘Z’
b) ‘A’ <= ch && fnum + 7.2 != 2.5 e) num1 < 3 && num2 > num3
c) !(3 * num1 + 4 < num3 * 2) f) !(fnum * 2 < num1 + 20)
© 2017 Gilbert Ndjatou Page 68
Solutions
a) num1 >= 5 || num2 + 3 == num3 d) num2 + 3 == num3 * 4 || ch >= ‘Z’
5 >= 5 || 7 + 3 == 2 * 4 || ‘K’ >= ‘Z’
True 10 == 8 || False
True False || False
False False
b) ‘A’ <= ch && fnum + 7.2 != 2.5 e) num1 < 3 && num2 > num3
‘A’ <= ‘K’ && 11.75 + 7.2 != 2.5 5 < 3 &&
True && 18.95 != 2.5 False
True && True False
True
c) !(3 * num1 + 4 < num3 * 2) f) !(fnum * 2 < num1 + 20)
!( 3 * 5 + 4 < 2 * 2) !(11.75 * 2 < 5 + 20)
!( 19 < 4) !( 23.50 < 25)
! False !True
True False
In the evaluation of an expression, operators with higher precedence are evaluated before those with
lower precedence.
Operators with the same precedence are evaluated in the order specified in the “order of evaluation”
column.
Precedence of C/C++ Operators
Operator Order of Evaluation Precedence
!
Unary –
right to left
7
*
/
%
left to right
6
+
-
left to right
5
<
<=
>
<=
left to right
4
==
!=
left to right
3
&& left to right 2
|| left to right 1
© 2017 Gilbert Ndjatou Page 69
Accuracy of Floating-Point Values
The fact that floating-point values are approximated inside a computer makes it difficult to test for
the equality of floating-point values.
For example, if the variable fnum is defined as follows:
float fnum = 7.1;
Then, the condition: fnum / 2 == 3.55 may not be true.
The problem may be solved by assuming that two floating-point values are equal if their difference
is relatively very small.
This is done by testing if the absolute value of their difference is less than a certain value chosen by
the programmer (for example 0.000001).
Using the library function fabs() that takes as argument a floating-point value and returns its
absolute value, the condition:
value1 == value2
is replaced with the condition: fabs(value1 - value2) < 0.000001
which tests whether the difference between the two values is small enough so that we can make them
equal.
Evaluation of True and False
In the C/C++ programming language,
false is represented by the integer value 0, and
any value other than 0 represents true.
Therefore, the following two conditions have the same true value (are equivalent):
Conditions value != 0 and value
(Saying that value is not zero is the same thing as saying that value is true)
Conditions value == 0 and ! value
(Saying that value is zero is the same thing as saying that !value is true)
bool Data Type
A variable with data type bool can only hold the bool values true and false.
Examples:
bool flag = true;
bool condValue = false, HighTemperature, ExtremeTemperature;
double temperature;
HighTemperature = false;
cin >> temperature;
HighTemperature = (temperature >= 120)
ExtremeTemperature = (HighTemperature || (temperature <= -20);
© 2017 Gilbert Ndjatou Page 70
Exercise 3.5
A. Assuming that the variables are defined and initialized as follows:
int num1 = 9 , num2 = 5 , num3 = 10;
float fnum = 12.50;
char ch = ‘P’;
Evaluate the following conditions (using short circuit evaluation whenever possible):
a. 2 * num1 - 5 >= 9 || fnum / 2 + 10 <= 6.5
b. num1 + num2 == num3 + 5 && 2 * num3 <= 4 * num2
c. ! (num1 + 5 <= 13)
d. 3 * num1 > num1 + num2 && num1+ 3 >= 12
e. ! ( num3 % 4 < 3)
f. num1 - 5 >= num3 || num2 < 15 && num1 >= 9
B. Which of the following conditions are equivalent (that means have the same true value)?
a. num1 != 0 b. !num1 c. num1 == 0 d. !(num1 == 0) e. num1
C. Suppose that a person’s age is stored in the variable age, his number of children in the variable
NumChild, his salary in the variable salary, and his height in the variable height. Write relational
expressions to specify the following conditions:
a. he is 45 year old.
b. he is more than 5.7 feet tall.
c. his salary is between 35,000 and 50,000.
d. he does not have 3 children.
h. he is either 6.0 feet tall, or he has less than 4 children.
j. he is not older that 35 and he has 2 or 3 children
© 2017 Gilbert Ndjatou Page 71
3.4 Two-Way Selection using the if-else Structure
The solution of some problems requires the CPU to test a condition and to select the action to be
performed based on whether or not that condition is true.
Example:
Suppose that at a party, you serve alcohol drinks only to guests who are 21 or older, and a juice to
guests who are less than 21.
When a guest comes to get a drink, you first test his age: if he is 21 or older, you serve him an
alcohol drink; otherwise you serve him a juice.
The solutions of these types of problems are written using a two-way selection structure which is
specified using a flowchart as follows:
False True
It says to do the following:
Test condition
a. if it is true, perform the actions (T-Action) specified by T-Statement,
b. otherwise, perform the actions (F-Action) specified by F-Statement.
Next-Statement is the statement that says what to do after any of the actions (F-Action or T-Action)
above has been executed.
Condition
F-Statement T-Statement
Next-Statement
© 2017 Gilbert Ndjatou Page 72
A two-way selection structure may be specified using pseudo-code as follows:
1. If <condition> is true, do the following:
<T-Statement>
2. Otherwise, do the following:
<F-Statement>
3. <Next-Statement>
It is specified in C++ using the if - else structure as follows:
if (<condition>)
<T-statement>
else
<F-statement>
<Next-Statement>
<T-statement> is a single statement that specifies the T-Action
<F-statement> is a single statement that specifies the <F-Action>.
Case Study 3.1
Problem Statement
Write a program to read the age of an individual, and to output the message “serve alcohol drink” if he is
21 or older, and the message “serve juice” otherwise. Your program will then output the message
“thank you for using this program.”
Program Logic
output: “Serve alcohol” or “Serve Juice”, depending on the individual’s age.
Input: an individual’s age.
Variables: age (int) to hold an individual’s age.
Algorithm Specification (using Pseudo-code)
1. Read the individual’s age into variable age.
2. If this individual’s age is 21 or more, do the following:
2.a. output the message “serve alcohol drink”.
3. Otherwise, do the following:
3.a. output the message “serve juice”.
4. Output the message “thank you for using this program”.
© 2017 Gilbert Ndjatou Page 73
Algorithm Specification (using a Flowchart)
False True
Figure 3.4 Using the if-else Structure
/*************************************************************************
Program to read the age of an individual and to output the type of drink
that he should be served
*************************************************************************/
#include <iostream>
using namespace std;
#define DRINKAGE 21
int main()
{
int age; // to hold an individual’s age
/*----------------- read the individual’s age------------------------*/
cout << “\n\nEnter the individual’s age please:\t”;
cin >> age;
/*--------determine what type of drink he should be served ---------*/
if (age >= DRINKAGE) // he is over the drinking age
cout << endl << “Serve alcohol drink”;
else // he can not drink alcohol
cout << endl << “Serve juice”;
cout << endl << “Thank you for using this program”;
return (0);
}
start
Read
age
age >= 21
Write “Thank you for
Using this program”
Stop
Write “serve alcohol drink”
Write
“serve a juice”
© 2017 Gilbert Ndjatou Page 74
Exercise 3.6*
a. Specify an algorithm (in pseudo-code and using a flowchart) to read a nonzero integer value and to
determine if it is positive or negative. If it is positive, print it with the message “POSITIVE”,
otherwise, print it with the message “NEGATIVE.” At the end, print the message “Thank You.”
b. Write the C++ code segment that corresponds to the algorithm in part a.
Exercise 3.7*
a. Specify an algorithm (using a flowchart) to read a character value and to determine if it is a digit (0,
1, 2, 3, 4, 5, 6, 7, 8, 9). If it is, print it with the message “DIGIT”; otherwise print it with the
message “NOT A DIGIT.”
b. Write the C++ code segment that corresponds to the algorithm in part a.
Exercise 3.8
a. Specify an algorithm (using a flowchart) to read a character and to determine if it is a letter of the
alphabet. If it is a letter of the alphabet, print it with the message, “it is a letter” otherwise, print it
with the message, “it is not a letter.”
b. Write the C++ code segment that corresponds to the algorithm in part a.
Case Study 3.2
Problem Statement
Write a program to read a positive integer value and to determine if it is even or odd. If it is even, print
it with the message “EVEN”; otherwise, print it with the message “ODD”.
Program Logic
Output: the input value with the message “EVEN” or “ODD”, depending on whether the input
value is even or odd.
Input: an integer value.
Variable: num (int) to hold the input value.
Note: An integer value is even if the remainder in its division by 2 is 0; otherwise, it is odd.
Algorithm Specification (using Pseudo-code)
1. Read a positive integer value into the variable num.
2. If num % 2 is 0, then do the following:
2.a print the input value with the message “EVEN”.
3. Otherwise do the following:
3.a print the input value with the message “ODD”
© 2017 Gilbert Ndjatou Page 75
Algorithm Specification (using a Flowchart)
False True
Figure 3.5 Using the if - else Structure
/************************************************************************
Program to read an integer value and to determine if it is even or odd
************************************************************************/
#include <iostream>
using namespace std;
int main()
{
int num; // to hold the value read
/*---------------- read in an integer value--------------------------*/
cout << “\n\nEnter an integer value please:\t”;
cin >> num;
/*----------------determine if it is even or odd --------------------*/
if (num %2 == 0) // it is even
cout << endl << num << “\tEVEN”;
else // it is odd
cout << endl << num << “\tODD”;
return ( 0 );
}
Exercise 3.9*
a. Specify an algorithm (using a flowchart) to read an integer value and to determine if it is a multiple
of 5. If it is a multiple of 5, print it with the message “MULTIPLE OF 5”, otherwise, print it with
the message NOT MULTIPLE OF 5.”
b. Write the C++ code segment that corresponds to the algorithm in part a.
Start
Read
num
num % 2 = 0
Write
num, “odd”
Write
num, “even”
Stop
© 2017 Gilbert Ndjatou Page 76
Compound Statement
A compound statement has the following syntax:
{
(One or more statements to be executed as a block)
}
Example
{
num2 = num1 + 5;
num1 = num1 +1;
}
The statements of a compound statement are executed one after another, starting with the first one in
the sequence.
A compound statement may appear anywhere in a C++ program where a single statement may
appear.
If you have to specify two or more statements as the T-statement or the F-statement of an if-else
structure, these statements must be specified as a compound statement.
Examples
if(num1 > num2)
{
num2 = num1 + 5;
num1 = num1 +1;
}
else
num1 = num2 -5 ;
if(num1 < num2)
num2 = num1 + 4;
else
{
num2 = num1 + 5;
num1 = num1 +1;
}
Case study 3.3
Problem Statement
Write a program to read an integer value and to do the following:
If the value read is zero, print it with the message “INVALID DIVISOR”.
Otherwise read a second value and then compute and print the quotient and the remainder in the
division of the second value by the first.
At the end write the message “Thank you for using this program.”
© 2017 Gilbert Ndjatou Page 77
Program Logic
Output: the quotient and the remainder in the division of the second value by the first or the
message “0 is invalid divisor” depending on the input.
Input: one or two integer values, depending on the value of the first.
Variables:
divisor (int) to hold the first value.
dividend (int) to hold the second value.
Note:
The second value is input and the quotient and the remainder in the division of the second value by
the first are computed only if the first value is not zero.
Algorithm Specification (using a Flowchart)
False True
Start
Read
divisor
divisor == 0
Write
divisor
“invalid divisor”
Read
dividend
Write
dividend / divisor
dividend % divisor
Write
“Thank you”
Stop
© 2017 Gilbert Ndjatou Page 78
Algorithm Specification (using Pseudo-Code)
1. Read the first value into variable divisor.
2. If the value read is zero (divisor == 0), do the following;
2.a write the value read (0) with the message “INVALID DIVISOR”
3. Otherwise do the following:
3.a read the second value into variable dividend.
3.b write the quotient of second value divided by the first:
dividend / divisor
3.c write the remainder of the second value divided by the first:
dividend % divisor
4. Write the message “Thank you for using this program”.
The program is provided in figure 3.6.
Figure 3.6 Using a Compound Statement in an if-else Structure
/*************************************************************************
Program to read two integer values and to compute the quotient and the
remainder in the division of the second value by the first.
*************************************************************************/
#include <iostream>
using namespace std;
int main()
{
int divisor, // to hold the first value
dividend; // to hold the second value
/*---------------------- read in the divisor-----------------------*/
cout << “\n\nEnter the divisor please:\t”;
cin >> divisor;
/*-----read the dividend and compute the quotient and the remainder--*/
if (divisor == 0) // it is invalid
cout << endl << divisor << “\tIS INVALID DIVISOR”;
else
{
cout << “\n\nEnter the dividend please:\t”;
cin >> dividend;
cout << “\nThe quotient in the division of:\t”
<< dividend << “ by ” << divisor << “\tis:\t”
<< (dividend / divisor);
cout << “\nand the remainder is:\t” << (dividend % divisor);
}
cout << “\n\nThank you for using this program”;
return( 0 );
}
© 2017 Gilbert Ndjatou Page 79
Exercise 3.10*
Assuming that all variables are properly defined and initialized, what are the error(s) in each of the
following program segments?
a. cin >> num;
if (num = 5)
sum = num + 4;
else
sum = num + 10;
b. cin >> num;
if (num > 5 && <= 10)
cout << (num + 15);
else
cout << (num - 3);
c. cin >> num;
if (num < 15)
result1 = 2 * num;
result2 = num + 20;
else
result1 = 5 * num;
result = result1 + result2;
cout << “\nThe result is:\t” << result;
Exercise 3.11*
Trace the execution of the following program segment and show its output for each of the following
input values:
a. input: 4 b. input: 20
Line # Statements
1 cin >> num;
2 if (num <10 )
{
3 num = num + 6;
4 cout << endl << “num =\t” << num;
}
else
5 cout << endl << “num / 4 =\t” << (num / 4);
6 cout << endl << “result =\t” << (2 * num);
© 2017 Gilbert Ndjatou Page 80
Exercise 3.12
a. Specify an algorithm (using a flowchart) to read an integer value into variable num1and another
integer value into variable num2 and to do the following: if the value in variable num1 is greater than
the value in variable num2 do the following: add 1 to the value in num1 and 5 to the value in num2
and then print the result of the product of the new value in num1 and the new value in num2;
otherwise, do the following: subtract 1from the value in num1 and 5 from the value in num2 and then
print the result of the product of the new value in num1 and the new value in num2.
b. Write the C++ code segment that corresponds to the algorithm in part a.
Exercise 3.13
a. A department store offers a rebate of 5% if the total price of the purchase is at least 100 and a rebate
of 2% otherwise. A sale tax of 8.25 % is also imposed on the total price of each purchase (after the
rebate). Specify an algorithm (using a flowchart) to read the unit price and the number of items
purchased, and to output the amount of the rebate and the (total) price (plus taxes) of the purchase.
b. Write the C++ code segment that corresponds to the algorithm in part a.
© 2017 Gilbert Ndjatou Page 81
3.5 Counter-Controlled Iteration using the while Structure
The solution of some problems requires the CPU to repeat the execution of one or more statements a
set number of times.
Example:
Suppose that a candy bar costs 70 cents in a candy machine that only accepts dimes. To buy a candy
bar from this machine, a user has to deposit a dime in the machine seven times.
The solutions of these types of problems are written using a counter-controlled iteration (or loop)
which is specified using a flowchart as follows:
False True
Body-of- the- Loop consists of the statements whose executions are repeated by the CPU.
counter is called the loop counter
it is a variable that is used to hold the number of repetitions
Next-Statement is the first statement to be executed after the repetitions.
Initial/Final Value
If the initial value is 0 (no execution is done yet), then the final value must be the number of
executions.
If the initial value is 1 (one execution is about to be done), then the final value must be the number
of execution plus 1.
Loop Increment
After each execution of the body-of-the-loop, the loop counter must be updated to reflect the number
of executions.
The statement that you use to update the loop counter is called the loop increment.
The loop increment is a statement in the body-of-the-loop.
counter = initial-value
Counter < final-value
Body-of-the-Loop
Next-Statement
© 2017 Gilbert Ndjatou Page 82
Algorithm of the Candy Bar Machine (using a flowchart)
False True
Specification of a Counter-Controlled Iteration in Pseudo-Code
A counter-controlled iteration may be specified in pseudo-code as follows:
1. Set the loop-counter to the initial-value.
2. As long as the loop-counter is less than the final-value, do the following:
<Body-of-of the-loop (including the increment-statement)>
3. Execute the next operation.
Start
count = 0
count < 7
Read
coin
count = count + 1
Write
“Thank you”
Stop
total = 0
total = total + coin
© 2017 Gilbert Ndjatou Page 83
Algorithm of the Candy Bar Machine (in pseudo-code)
1. Set the total value of the coins to 0: total = 0.
2. Set the loop counter to 0: count = 0.
3. As long as the loop counter is less than 7, do the following:
3.a. read the value of the coin into the variable coin.
3.b. add the value of the coin read into the total value: total = total + coin.
3.c. increment the loop counter by 1: count = count + 1.
4. Write “Thank You”
Specification of a Counter-Controlled Iteration in C++
A counter-controlled iteration may be specified in C++ using the while structure as follows:
counter = initial-value;
while (counter < final-value)
{
<Body-of-of the-loop (including the increment-statement)>
}
<Next-statement>
Algorithm of the Candy Bar Machine (in C++)
int total, // to hold the total value of the coins
coin, // to hold the value of a coin
count; // to hold the number of repetitions
total = 0;
count = 0;
while ( count < 7 )
{
cin >> coin;
total = total + coin;
count = count + 1;
}
cout << endl << “Thank You”;
© 2017 Gilbert Ndjatou Page 84
Case Study 3.4
Problem Statement
Write a program to read 30 weight measurements in pounds and to convert them into kilograms. Note
that 1 Lb = .454 Kg.
Program Logic
Input: 30 weight measurements (in Lbs).
Output: 30 weight measurements (in Kgs).
Notes:
We use the variable count as the loop counter:
Its initial value is 0 (no weight measurement is read so far) and
Its final value is 30 (30 weight measurements are already read)
Variables:
count (int) to count the weight measurements.
Initial value is 0 - Final value is 30.
pound (double) to hold a weight measurement in Lbs.
Algorithm Specification (using Pseudo-code)
1. Set the loop counter (count) to 0: count = 0
2. As long as the current value of the loop counter (count) is less than 30, do the following:
2.a read a weight measurement into the variable pound.
2.b convert it to kilogram and print the result.
2.c increment the loop counter by 1: count = count + 1
3. Write “Thank you”.
The flowchart follows and the program is provided in figure 3.7.
© 2017 Gilbert Ndjatou Page 85
Algorithm Specification (using a flowchart)
False True
Start
count = 0
count < 30
Read
pound
Write
.454 * pound
count = count + 1
Write
“Thank you”
Stop
© 2017 Gilbert Ndjatou Page 86
Figure 3.7 Counter-Controlled Iteration using the while Structure
Line Number
1 /**********************************************************
2 Program to read 30 weight measurements in pounds and convert
3 them into kilograms
4 **********************************************************/
5 #include <iostream>
6 #include <iomanip>
7 #define MAXCOUNT 30
8 #define COEFICIENT .454
9
10 int main()
11 {
12 int count; // to count weight measurements
13 double pound, // the current weight measurement in Lbs
14
15 cout << setprecision(2) << fixed << showpoint;
16
17 /*read weight measurements (Lb) and convert them to kg*/
18 count = 0; // no weight measurement is read so far
19 while (count < MAXCOUNT) // repeat thirty times
20 {
21 cout << “\nEnter a weight measurement please:\t”;
22 cin >> pound;
23 cout << “\t = ” << (.454 * pound);
24 count = count + 1;
25 }
26
27 cout << endl << “Thank you”;
28 return (0);
29 }
The body of the loop consists of the statements in line 21 to line 24.
The loop-counter is initialized in line 18; and the loop-increment statement is in line 24.
© 2017 Gilbert Ndjatou Page 87
Exercise 3.14*
1. Assuming that all variables are properly defined, indicate what is wrong with each of the following
while structures:
a. b. c.
while( count < 10 ) while(count < 10) count = 0;
{ { while(count < 10 )
cin >> num; count = 0; {
cout << 2 * num; cin >> num; cin >> num;
count = count + 1; cout << 2 * num; cout << 2 * num;
} count = count + 1; }
}
Exercise 3.15
a. Specify an algorithm (in pseudo-code and using a flowchart) to read 50 temperature values in
Fahrenheit and to convert them to Celsius. You convert a Fahrenheit temperature to Celsius by
using the following formula: Celsius = 5.0 / 9 (Fahrenheit - 32).
b. Write the C++ code segment that corresponds to the algorithm in part a.
Using a Running Total
A running total is a variable that is used to compute the sum of values processed at each iteration of
a loop: it is first initialized to 0 and each new value processed in the loop is added to the previous
total.
Case Study 3.5
Problem Statement
Write a program to read 20 integer values and to compute their sum.
Program Logic
Input: 20 integer values.
Output: their sum.
Variable:
count (int) to count the values.
Initial value is 0 (no value is read so far); Final value is 20.
value (int) to hold the integer value read.
totalValue (int) to hold the sum of the integer values read so far: Initial value is 0.
© 2017 Gilbert Ndjatou Page 88
Algorithm Specification (using Pseudo-code)
1. Set the running total value (totalValue) to 0: totalValue = 0
2. Set the loop counter (count) to 0: count = 0
3. As long as the current value of the loop counter (count) is less than 20, do the
following:
3.a read an integer value into the variable value.
3.b add the integer value read to the running total value:
totalValue = totalValue + value
3.c add 1 to the loop counter (count): count = count + 1
4. Print the sum of all values
The flowchart follows and the program is provided in figure 3.8.
Algorithm Specification (using a Flowchart)
False True
Start
totalValue = 0
count = 0
count < 20
totalValue = totalValue + value
Read
value
count = count + 1 Write
totalValue
Stop
© 2017 Gilbert Ndjatou Page 89
Figure 3.8 Counter-Controlled Iteration using the while Structure
Line Number
1 /*************************************************************
2 Program to read twenty integer values and to compute their sum.
3 *************************************************************/
4 #include <iostream>
5 using namespace std;
6 #define MAXCOUNT 20
7
8 int main()
9 {
10 int count; // to count values
11 value, // to hold the value read
12 totalValue; // the hold the sum of the values read so far
13
14 /*------read all values and compute their sum-------*/
15 totalValue = 0;
15 count = 0; // no value has been read so far
16 while (count < MAXCOUNT) // repeat twenty times
17 {
18 cout << “\nEnter an integer value please:\t”;
19 cin >> value;
20 totalValue = totalValue + value;
21 count = count + 1;
22 }
23
24 /*-----print the sum of all the values read----------*/
25 cout << “\n\nThe sum of all the values read is:\t”
26 << totalValue;
27 return (0);
28 }
Exercise 3.16*
Each of the following two code segments is supposed to read and to compute the sum of 10 integer
values. Assuming that all variables are properly defined, indicate what is wrong with each of them.
a. b.
count = 0; count = 0;
while (count < 10 ) while (count < 10 )
{ {
sum = 0; cin >> num;
cin >> num; sum = sum + num;
sum = sum + num; count = count + 1;
count = count + 1; }
}
© 2017 Gilbert Ndjatou Page 90
Exercise 3.17*
a. Specify an algorithm (using a flowchart) to read the test scores of twenty students and to compute
and print their average.
b. Write a C++ code segment that corresponds to the algorithm in part a.
Exercise 3.18
a. A client has purchased 20 products in a store. Specify an algorithm (using a flowchart) to read the
unit price and the number of items of each product and to compute and print the total price of all
these products.
b. Write a C++ code segment that corresponds to the algorithm in part a.
Case Study 3.6
Problem Statement
Write a program to compute the sum of the first 20 positive even integer values (2, 4, . . .).
Program Logic
Input: none.
Output: the sum of the first 20 positive integer values.
Variable:
count (int) to count the values: Initial value is 1; Final value is 21.
totalValue (int) to hold the sum of the integer values processed so far: Initial value is 0.
Algorithm Specification (using Pseudo-code)
1. Set the running total value (totalValue) to 0: totalValue = 0
2. Set the loop counter (count) to 1: count = 1
3. As long as the current value of the loop counter (count) is less than 21, do the following:
3.a multiply the loop counter by 2 and add the result to the running total value:
totalValue = totalValue + 2 * count
3.c add 1 to the loop counter (count): count = count + 1
4. Print the sum of all values
The flowchart follows and the program is provided in figure 3.9.
© 2017 Gilbert Ndjatou Page 91
Algorithm Specification (using a Flowchart)
False True
Figure 3.9 Counter-Controlled Iteration using the while Structure
Line Number
1 /*************************************************************
2 Program to read twenty integer values and to compute their sum.
3 *************************************************************/
4 #include <iostream>
5 using namespace std;
6 #define MAXCOUNT 21
7 int main()
8 {
9 int count, // to count the values
10 totalValue; // the hold the sum of the values so far
11 totalValue = 0;
12 count = 1;
13 while (count < MAXCOUNT) // repeat twenty times
14 {
15 totalValue = totalValue + 2 * count;
16 count = count + 1;
17 }
18 /*-----print the sum of the first 20 positive even values ---*/
19 cout << “\n\nThe sum of the first 20 positive even values is:\t”
20 << totalValue;
21 return (0);
22 }
Start
totalValue = 0
count = 1
count < 21
totalValue = totalValue + 2 * count
count = count + 1
Write
totalValue
Stop
© 2017 Gilbert Ndjatou Page 92
Exercise 3.19
a. Specify an algorithm (using a flowchart) to compute and print the sum of the first 10 positive
multiple of 5.
b. Write a C++ code segment that corresponds to the algorithm in part a.
Using a Running Product and a Counter with the initial value Greater
than the final Value
A running product is a variable that is used to compute the product of values processed at each
iteration of a loop: it is first initialized to 1 and each new value processed in the loop is multiplied to
it.
Case Study 3.7
Problem Statement
For a positive integer value n, n factorial (written n!) is the product of all the integer values from 1 to n
(1 * 2 * 3 * . . . * n).
Write a program to read a positive integer value n, and to compute and print n!
Program Logic
Input: a positive integer value.
Output: the product of all positive integer values less than or equal to the value read.
Variables:
number (int) to hold the value read
factorial (int) to hold the product of the integer values: initial value = 1
After
Iteration Value of number value of factorial
- n 1
1 n - 1 1 x n
2 n - 2 1 x n x (n - 1)
.
.
.
n - 1 1 1 x n x (n - 1) x . . . x 2
© 2017 Gilbert Ndjatou Page 93
Algorithm Specification (in Pseudo-code)
1. Read a positive integer value into variable number.
2. Initialize the variable factorial to 1: factorial = 1
3. As long as the current value of variable number is greater than 1, do the following:
3.a multiply the current value of variable factorial by the current value of variable number: factorial = factorial * number
3.b subtract 1 from the current value of variable number: number = number-1
4. Print the result.
The flowchart follows and the program is provided in figure 3.10.
Algorithm Specification (using a Flowchart)
False True
Start
Read
number
factorial = 1
number > 1
Factorial = factorial * number
number = number - 1
Write
factorial
Stop
© 2017 Gilbert Ndjatou Page 94
Figure 3.10 Counter-Controlled Iteration using the while Structure
Line Number
1 /*************************************************************
2 Program to read a positive integer value and to compute and print
its factorial.
3 *************************************************************/
4 #include <iostream>
5 using namespace std;
6 int main()
7 {
8 int number, //integer value/loop counter
9 factorial = 1; // to hold the product
10
11 /*------------read the integer value --------------------*/
12 cout << endl << “enter a positive integer value:\t”;
13 cin >> number;
14
15 /*-------compute the factorial of the number read -------*/
16 while (number > 1)
17 {
18 factorial = factorial * number;
19 number = number -1;
20 }
21
22 /*------------------print the factorial------------------*/
23 cout << endl << “n factorial is:\t”
24 << factorial;
25 return (0);
26 }
The body of the loop consists of the statements in lines 18 and 19.
The loop-counter is initialized in line 13; and the loop-increment statement is in line 19.
Exercise 3.20*
a. Specify an algorithm (using a flowchart) to read ten integer values and to compute and print their
product.
b. Write the C++ code segment that corresponds to the algorithm in part a.
Exercise 3.21
a. Specify an algorithm (using a flowchart) to generate the squares (n*n) of the integer values 20, 18,
16, 14, . . . 2, starting with 20.
b. Write the C++ code segment that corresponds to the algorithm in part a.
© 2017 Gilbert Ndjatou Page 95
3.6 Logically-Controlled Iteration using the while Structure
The solutions of a class of problems require the CPU to repeat the execution of one or more
statements as long as a certain condition is true (that means, until a certain condition becomes false).
Case Study 3.7
Problem Statement
A can of soda costs $ 1.00 in a soda machine, and a user buys a can of soda by depositing coins (nickels,
dimes or quarters) in the machine until the total value of the coins deposited in the machine is greater
than or equal to $ 1.00.
Write a program to read the value of each coin deposited in the soda machine (5, 10, or 25) until the
total value of the coins deposited in the machine is greater than or equal to 100. The program will then
output the message “Thank you for using the soda machine” and the amount of the change.
Program Logic
input: the value of a coin (5, 10 or 25).
Output: the message “Thank you for using this soda machine” and the amount of change.
Note:
To read the value of each coin deposited in the machine and to compute their sum, we need the
following:
A variable coinValue to hold the input value of a coin.
A variable totalValue to hold the sum of the values of the coins read so far.
It is initialized to 0 before the body-of-the-loop.
The loop condition is: totalValue < 100.
Variables:
coinValue ( int ) to hold the value of a coin.
totalValue ( int ) to hold the total value of the coins deposited so far.
Algorithm Specification (in Pseudo-code)
1. Set the total value of the coins (totalValue) to 0.
2. As long as variable totalValue is less than 100 do the following:
2.a read the next coin value into the variable coinValue.
2.b add the value of the coin read to the total value of the coins:
totalValue = totalValue + coinValue
3. Output the message “Thank you for using the soda machine”.
4. Compute and print the change: totalValue - 100
© 2017 Gilbert Ndjatou Page 96
Algorithm Specification (using a Flowchart)
False True
The program is provided in figure 3.11.
Start
totalValue = 0
totalValue < 100
Read
coinValue
totalValue = totalValue + coinValue
Write
“Thank you”
Write
totalValue - 100
Stop
©2017 Gilbert Ndjatou Page 97
Figure 3.11 Logically-Controlled Iteration using the while Structure
Line Number
1 /*****************************************************************
2 Program to monitor the purchase of a can of soda in a soda machine
3 *****************************************************************/
4 #include <iostream>
5 using namespace std;
6 int main()
7 {
8 const int SODAPRICE = 100; // the price of a can of soda
9 int coinValue, // the value of a coin
10 totalValue = 0; // the total value of the coins
11
12 while( totalValue < SODAPRICE )
13 {
14 /*------------read the value of the next coin------------*/
15 cout << endl << “enter the value of the next coin:\t”;
16 cin >> coinValue;
17
18 /* compute the total value of the coins deposited so far */
19 totalValue = totalValue + coinValue;
20 }
21
22 /*--- say “thank you” and give the change back to the user */
23 cout << “\n\nThank you for using this soda machine”
24 << “\n\nYour change is:\t” << (totalValue - SODAPRICE);
25 return ( 0 );
26 }
The body-of-the-loop consists of the statements in lines 15 to 19.
The loop-initialization statement is the declaration statement in lines 9 and 10; and
The loop-increment statement is in line 19.
Exercise 3.22*
The manager of a store is required to make a deposit of $ 10,000 whenever the total sale in the store is $
10,000 or more.
a. Specify an algorithm (using a flowchart) to repeatedly read the daily sales in that store, and to
compute their sum until the total sale is greater than or equal to $ 10,000. The total sale, the
message “it is time to make a deposit” and the remaining balance (above $10, 000) are then printed.
b. Write a C++ code segment that corresponds to the algorithm in part a.
©2017 Gilbert Ndjatou Page 98
Exercise 3.23
A store has 120 bags of coffee and every day, the amount of bags sold is deducted from the current stock
until it becomes less than or equal to 30. The manager of the store must then place a new order.
a. Specify an algorithm (using a flowchart) to read the number of bags sold daily and to update the
current stock until it becomes less than or equal to 30. The message “place a new order” and the
amount of bags to purchase in order to have 120 bags are then printed.
b. Write a C++ code segment that corresponds to the algorithm in part a.
Case Study 3.7
Problem Statement
Write a program to read a positive integer value and to print its digits in reverse order. That means,
4321 is printed as 1 2 3 4, and 97 is printed as 7 9.
Program Logic
Input: a positive integer value.
Output: the digits of this integer value in reverse order.
Notes:
In order to read a positive integer value and to write its digits in reverse order, we need:
a variable num to hold the integer value.
Its digits are printed in reverse order as follows:
We divide the value of variable num by 10:
The remainder is the right-most digit of this value.
We divide the value of variable num again by 10:
The quotient is this value without its right-most digit.
Example:
345 % 10 = 5
345 / 10 = 34
We now replace the current value of variable num with the above quotient
All the digits of the number will be printed if we repeat the above three operations until the
current value of variable num becomes 0.
Variables:
num ( int ) to hold the positive integer value and the successive quotients in the division by 10.
©2017 Gilbert Ndjatou Page 99
Algorithm Specification (using Pseudo-Code)
1. Read the integer value into variable num.
2. As long as the value in variable num is not 0, do the following:
2.a write num % 10.
2.b set num to num / 10.
Algorithm Specification (using a Flowchart)
False True
The program is provided in figure 3.12.
Start
Read
num
num != 0
Write
num % 10
num = num / 10
Stop
©2017 Gilbert Ndjatou Page 100
Figure 3.12 Logically-Controlled Iteration using the while Structure
Line Number
1 /******************************************************************
2 Program to read a positive integer value and to print its digits in
reverse order.
3 *******************************************************************/
4 #include <iostream>
5 using namespace std;
6 int main()
7 {
8 int num; // to hold the value
9
10 /*--------------read a positive integer value--------------*/
11 cout << “\nEnter an integer value greater than zero:\t”;
12 cin >> num;
13
14 /*---------- print its digits in reverse order -------------*/
15 cout << “\n\nIts digits in reverse order are as follows:\t”;
16 while (num != 0)
17 {
18 cout << ( num % 10 );
19 num = num / 10;
20 }
21 return ( 0 );
22 }
Exercise 3.24
a. Specify an algorithm (using a flowchart) to read an integer value greater than 1 and to compute its
greatest divisor that is less than the value itself. For example, if the value is 15, the answer is 5, and
if the value is 13, the answer is 1.
To compute the greatest divisor of an integer value n greater than 1 that is less than n, repeatedly
divide that value n by i= 2, then 3, then 4, . . . etc., until you get a remainder of 0 or i * i> n. If the
remainder is 0, then the greatest divisor is n/i, otherwise, it is 1.
b. Write the C++ code segment that corresponds to the algorithm in part a.
while Structure with one Statement in the Body-of- the-Loop
When the body-of-the-loop consists of just one statement, the braces may be omitted from the while
structure.
Problem Statement
Write a program to compute the smallest power of 5 greater than 10000 (1, 5, 25, 125, . . . ).
©2017 Gilbert Ndjatou Page 101
Program Logic
Input: none.
Output: the smallest power of 5 greater than 10000.
Note: To compute the smallest power of 5 greater than 10000, we need:
A variable power to hold the powers of 5. It is initialized with 1 before the body-of-the-loop.
The current value of variable power is multiplied by 5 in the body-of-the-loop until it becomes
greater than 10000. The loop condition is therefore: power <= 10000.
After Value of
Iteration variable power
- 1
1 1 x 5 = 5
2 5 x 5 = 25
3 25 x 5 = 125
. . .
Variable: power (int) to hold the powers of 5.
Algorithm Specification (in Pseudo-Code)
1. Set variable power to 1: power = 1
2. As long as the current value of variable power is less than or equal to 10000, do the following:
2.a Multiply the current value of variable power by 5:
power = power * 5
3. Output the result.
Algorithm Specification (using a Flowchart)
False True
The program is provided in figure 3.13.
Start
power = 1
power <= 10000
Power = power * 5 Stop
©2017 Gilbert Ndjatou Page 102
Figure 3.13 while Structure with a single statement in the body-of-the-Loop
Line Number
1 /***************************************************************
2 Program to compute the smallest power of 5 greater than 10000
3 ****************************************************************/
4 #include <iostream>
5 using namespace std;
6 int main()
7 {
8 int power; // to hold the current power of 5
9 power = 1; // first power of 5
10 while ( power <= 10000)
11 power = power * 5;
12
13 /*-----------------print the result-------------------------*/
14 cout << endl << power
15 << “ is the smallest power of 5 greater than 10000";
16 return (0);
17 }
Although the body-of-the-loop consists of just one statement, it could also be specified as a
compound statement as follows:
while (power <= 10000)
{
power = power * 5;
}
Sentinel-Controlled Iteration
When you want to process a list of values and you do not know how many values are in the list, you
can use a sentinel value (dummy value, flag value, or signal value) to mark the end of the list.
A sentinel value is in general chosen in such a way that they can not possibly be one of the data
items in the list.
Example:
For a program to read and process a list of test scores received by students in an exam, a sentinel
value might be -1 or -99. With -99, the list could be:
87 69 95 65 73 86 93 68 -99
©2017 Gilbert Ndjatou Page 103
The data items in the list are accessed and processed one at a time until the sentinel value is
accessed.
However, the sentinel value must not be processed.
The algorithm to perform this type of repetition is specified using a flowchart as follows:
False True
It is specified using the while structure as follows:
<statement-to read/access-the first-value>
While(<value-read/access != sentinel-value>)
{
<processing-statements>
<statement-to-read/access-the-next-value>
}
<processing-statements> consists of one or more statements used to process a data item in the list.
Problem Statement
Write a program to read one or more weight measurements in pounds and to convert them into
kilograms. The dummy value -99.0 is entered to end the input of the weight measurements. Note that 1
Lb = .454 Kgs.
Read/Access the first data item
data item != sentinel
Process a data item
Read/Access the next data item
Next-Statement
©2017 Gilbert Ndjatou Page 104
Program Logic
Input: one or more weight measurement (in Lbs) followed by the sentinel value -99.00.
Output: weight measurements in (Kgs).
Variables: pound (double) to hold a weight measurement in Lbs.
Algorithm Specification (using Pseudo-code)
1. Read the first weight measurement (in pound) or the dummy value -99.0 into variable pound.
2. As long as the current value of variable pound is not the sentinel -99.0 do the following:
2.a convert it to kilogram and print the result.
2.b. Read the next weight measurement or the dummy value -99.0 into variable pound.
3. Write “Thank you”
Algorithm Specification (using a Flowchart)
False True
The program is provided in figure 3.14.
Start
Read
pound
pound != -99
Read
pound Write
“Thank you”
Stop
Write
.454 * pound
©2017 Gilbert Ndjatou Page 105
Figure 3.14 Sentinel-Controlled Iteration using the while Structure
Line Number
1 /*************************************************************
2 Program to read one or more weight measurements in pounds and
3 to convert them into kilograms.
4 *************************************************************/
5 #include <iostream>
6 #include <iomanip>
7 using namespace std;
8 #define COEFICIENT .454
9 #define DUMMYWEIGHT -99.0
10
11 int main()
12 {
13 double pound, // the current weight measurement in Lbs
14
15 /*read the first weight measurement or the dummy value -99.0*/
16 cout << endl
<< “Enter a weight measurement or -99.0 to terminate:\t”;
17 cin >> pound;
18 while (pound != DUMMYWEIGHT)
19 {
20 cout << “\t = ” << (.454 * pound);
21 cout << endl
<< “Enter a weight measurement or -99.0 to terminate:\t”;
22 cin >> pound;
23 }
24 cout << endl << “Thank you”;
25 return (0);
26 }
Exercise 3.25*
The following program that should read a list of integer values and compute their sum until the sentinel
value -99 is read, contains some error(s). Rewrite it with these errors corrected.
#include <iostream>
using namespace std;
int main( )
{
int total, value;
cout << “\nEnter all values to add followed by” << -99 <<“ to stop\n”;
while ( value != -99 )
{
cin >> value;
total = total + value;
}
cout << endl << “The total of these value is:\t” <<total;
return( 0 );
}
©2017 Gilbert Ndjatou Page 106
Note
Lines 15 to 23 of the program in Figure 3.14 could as well be written as follows:
15 /*read the first weight measurement or the dummy value -99.0*/
16 cout << endl
<< “Enter a weight measurement or -99.0 to terminate:\t”;
17 pound = 0;
18 while (pound != DUMMYWEIGHT)
19 {
20 cin >> pound;
21 if( pound != DUMMYWEIGHT )
cout << “\t = ” << (.454 * pound);
22 cout << endl;
23 }
Although this second code segment is correct, it has a problem of efficiency: the test
pound != DUMMYWEIGHT is performed twice in each loop iteration.
Exercise 3.26*
a. Specify an algorithm (using a flowchart) to read one or more temperature values in Fahrenheit and to
convert them to Celsius. The sentinel value -99 marks the end of the input temperatures. You
convert a Fahrenheit temperature to Celsius as follows: Celsius = 5.0 / 9 (Fahrenheit - 32).
b. Write the C++ code segment that corresponds to the algorithm in part a.
Exercise 3.27
a. Specify an algorithm (using a flowchart) to read one or more test scores and to compute their
average. The sentinel value -99 is used to mark the end of the input test scores.
b. Write the C++ code segment that corresponds to the algorithm in part a.
Exercise 3.28
Write the C++ code segment of an algorithm to read the unit price and the quantity of one or more
products that are bought in a store and to do the following:
a. Compute the (total) price of each product.
b. Compute the total price of all the products.
The sentinel -99.0 is used to mark the end of the input unit prices. For example, the unit prices and the
quantities of four products are input as follows: 2.15 8 1.70 15 3.0 4 0.50 25 -99.0.
©2017 Gilbert Ndjatou Page 107
One-Way Selection using the if Structure
A one-way selection structure is used to specify that the execution of one or more actions be
performed only if a test performed on a condition is true.
It is specified using a flowchart as follows:
False True
C-Statement is one or more statements that specify the operations to be performed when condition
evaluates to true.
It is specified in C++ language using the if structure as follows:
if (<condition>)
<Statement>
<Next-Statement>
where <Statement> is a single statement or a compound statement.
Note that when <condition> evaluates to false, no action is performed. Instead, the execution of the
program continues with the execution of <Next-Statement>.
Case Study 3.8
Problem Statement
A rebate of 5% is given in a store only if the total price of the merchandise is at least $100.00. Write a
program to read the unit price and the number of quantity of the merchandise, and to compute the
amount of the purchase after the rebate if applicable.
condition
C-Statement
Next-Statement
©2017 Gilbert Ndjatou Page 108
Program Logic
Input: the unit price and the quantity of the merchandise.
Output: the total amount of purchase.
Variables:
unitPrice ( double ) to hold the unit price.
quantity ( int ) to hold the quantity.
purchase ( double ) to hold the amount of purchase.
Algorithm Specification (using Pseudo-Code)
1. Read the unit price and the quantity of the merchandise into variables unitPrice and quantity
respectively.
2. Compute the total price of the merchandise:
purchase = unitPrice * quantity.
3. If the total price of the merchandise is 100.00 or more, do the following:
3.a compute the rebate and subtract it from the total price:
purchase = purchase - .05 * purchase.
4. Print the amount of purchase.
Algorithm Specification (using a Flowchart)
False True
The program is provided in figure 3.15.
Start
Read
unitPrice, quantity
purchase = unitPrice * quantity
purchase >= 100.00
purchase = purchase - .05 * purchase
Write
purchase
Stop
©2017 Gilbert Ndjatou Page 109
Figure 3.15 One-Way Selection using the if Structure
Line Number
1 /****************************************************************
2 Program to compute the total amount of purchase in a store
3 ****************************************************************/
4 #include <iostream>
5 using namespace std;
6 int main()
7 {
8 const double MINPURCHASE = 100.00; //minimum purchase
9 const double RRATE = 0.05; // rebate rate
10 double unitPrice, // unit price
11 Purchase // amount of purchase
12 int quantity; // number of quantity
13
14 /*--------read in the unit price and the quantity -------*/
15 cout << “\nEnter the merchandise unit price:\t”;
16 cin >> unitPrice;
17 cout << ‘\nEnter its quantity:\t”;
18 cin >> quantity;
19
20 /*-----------compute the amount of purchase --------------*/
21 purchase = unitPrice * quantity;
22 if(purchase >= MINPURCHASE)
23 purchase = purchase - RRATE * purchase;
24
25 /*-------------- print the amount of purchase --------------*/
26 cout << “\nYour total amount of purchase is:\t”
27 << purchase;
28 return( 0 );
29 }
The Null Statement
The null statement is a statement that consists of just the semicolon.
It says to do nothing, but to continue with the next operation.
You may also use the if-else structure and the null statement to specify a one-way selection as
follows:
if (<condition>)
<Statement>
else;
<Next-Statement>
©2017 Gilbert Ndjatou Page 110
Example
The if structure in lines 22 and 23 of the program in Figure 3.15 could be written as follows:
if (purchase >= 100.00 )
purchase = purchase - RRATE * purchase;
else;
/*-------------- print the amount of purchase --------------*/
cout << “\nYour total amount of purchase is:\t”
<< purchase;
Exercise 3.29*
1. What is the output of the following program segment for each of the following input values?
a. input value: 4 b. input value: 20
cin >> num;
if( num >= 5)
{
pnum = num + 7;
cout << endl << “pnum=\t” << pnum;
}
cout << “result=\t” << (num - 1);
Exercise 3.30
a. In a department store, a 10% rebate is given for every purchase of at least $ 20.00. Specify an
algorithm (in pseudo-code and using a flowchart) to read the unit price of a product, the quantity
purchased, and to compute the amount of the purchase after the rebate if applicable.
b. Write the C++ code segment that corresponds to the algorithm in part a.
©2017 Gilbert Ndjatou Page 111
3.8 Multiple-Way Selection using if-else Structures
A multiple-way selection structure is used to specify that the action to be performed be chosen from
a list of three or more actions based on the true values of two or more conditions.
A multiple-way selection with four actions and three conditions is specified as follows:
True False
True False
True False
Condition1 is first tested, and if it is true, Action-1 is executed, followed by Next-Action;
Otherwise, condition2 is tested, and if it is true, Action-2 is executed, followed by Next-Action;
Otherwise, condition3 is tested, and if its true, Action-3 is executed, followed by Next-Action;
Otherwise, Action-4 is executed, followed by Next-Action.
Note that only one of the actions, Action-1, Action-2, Action-3, or Action-4 is executed.
In some situations, Action-4 may also be the null action.
condition1
condition2
condition3
Action-1
Action-2
Action-3 Action-4
Next-Action
©2017 Gilbert Ndjatou Page 112
This behavior is specified in C/C++ using if-else structures as follows:
if ( <condition1> )
<Statement-1>
else if ( <condition2> )
<Statement-2>
else if ( <condition3> )
<Statement-3>
else
<Statement-4>
<Next-Statement>
<Statement-1>, <Statement-2>, <Statement-3>, and <Statement-4> are single or compound
statements that specify respectively, Action-1 , Action-2 , Action-3 , and Action-4 .
<Next-Statement> is a statement that specifies the Next-Action.
In the case that <Statement-4> is the null statement, this behavior may also be specified as follows:
if ( <condition1> )
<Statement-1>
else if ( <condition2> )
<Statement-2>
else if ( <condition3> )
<Statement-3>
<Next-Statement>
©2017 Gilbert Ndjatou Page 113
Case Study 3.9
Problem Statement
Four letters M, S, D, and W are used to encode the marital status of an individual as follows: M (married), S
(single), D (divorced), and W (widowed). Any other character is considered invalid. Write a program to read a
marital code and to output the corresponding marital status.
Program Logic
Input: a marital code (capital M, S, D, or W).
Output: a marital status. Any other character is considered invalid.
Variables:
mcode (char ) to hold the marital code.
The flowchart of the algorithm is provided below and the program is provided in figure 3.16.
©2017 Gilbert Ndjatou Page 114
Algorithm Specification (using a Flowchart)
True False
True False
True False
True False
mcode = ‘M’
mcode = ‘S’
mcode = ‘D’
Start
Read
mcode
Write
“married”
Write
“single”
Mcode = ‘W’ Write
“divorced”
Stop
Write
“invalid
”
Write
“Widowed”
©2017 Gilbert Ndjatou Page 115
Figure 3.16 Multiple-Way Selection using if-else Structures
Line Number
1 /****************************************************************
2 Program to read a marital code and to output the corresponding
3 marital status.
4 ****************************************************************/
5 #include <iostream>
6 using namespace std;
7 int main()
8 {
9 char mcode; // to hold a marital code
10
11 /*------------------read in a marital code------------------*/
12 cout << “\nEnter a marital code:\t”;
13 cin >> mcode;
14
15 /*---determine and print the corresponding marital status --*/
16 if (mcode == ‘M’)
17 cout << “\nThis individual is married”;
18 else if (mcode == ‘S’)
19 cout << “\nThis individual is single”;
20 else if (mcode == ‘D’)
21 cout << “\nThis individual is divorced”;
22 else if (mcode == ‘W’)
23 cout << “\nThis individual is a widow”;
24 else
25 cout << “\nThe marital code is invalid”;
26 return( 0 );
27 }
Exercise 3.31
A florist sells four different types of bouquets of flowers that he has numbered 101, 202, 303, and 404.
The unit price of each of these bouquets of flowers is given as follows:
ITEM NUMBER UNIT PRICE
101 $ 5.25
202 $ 3.10
303 $ 9.75
404 $ 6.50
a. Specify an algorithm (using a flowchart) to read an item number and the number of bouquets of that
type purchased and to compute and print the total price of those bouquets.
b. Write the C++ code segment that corresponds to the algorithm in part a.
©2017 Gilbert Ndjatou Page 116
Case Study 3.10
Problem Statement
Write a program to read a test score and to determine and print the corresponding letter grade as follows:
A for a score >= 90.00, B for 80.00 <= score < 90.00, C for 70.00 <= score <80.00, D (60.00 <= score
< 70.00, and F for score < 60.00. It is assumed that the input value is a valid test score.
Program Logic
Input: a test score (floating-point value in the range 0.00 to 100.00).
Output: the corresponding letter grade.
Variables: score (double ) to hold a test score.
Algorithm Specification Using a Flowchart
True False
True False
True False
True False
The program is provided in figure 3.17.
score >= 90.00
score >= 80.00
Score >= 70.00
Start
Read
score
Write
‘A’
Write
‘B’
score >= 60.00 Write
‘C’
Stop
Write
‘F’ Write
‘D’
©2017 Gilbert Ndjatou Page 117
Figure 3.17 Multiple-Way Selection using if-else structures
Line Number
1 /****************************************************************
2 Program to read a test score and to determine and output the
3 corresponding letter grade.
4 ****************************************************************/
5 #include <iostream.h>
6 using namespace std;
7 int main()
8 {
9 double score; // to hold a test score
10
11 /*------------------read in a test score--------------------*/
12 cout << “\nEnter a test score:\t”;
13 cin >> score;
14
15 /*----determine and print the corresponding letter grade ---*/
16 if ( score >= 90.00)
17 cout << “\nThe letter grade is:\t” << ‘A’;
18 else if (score >= 80.00)
19 cout << “\nThe letter grade is:\t” << ‘B’;
20 else if (score >= 70.00)
21 cout << “\nThe letter grade is:\t” << ‘C’;
22 else if (score >= 60.00)
23 cout << “\nThe letter grade is:\t” << ‘D’;
24 else
25 cout << “\nThe letter grade is:\t” << ‘F’;
26 return ( 0 );
27 }
The multiple-way selection specified in line 16 to line 25 could also be written as follows:
if ( score < 60.00)
cout << “\nThe corresponding letter grade is:\t” << ‘F’;
else if (score < 70.00)
cout << “\nThe corresponding letter grade is:\t” << ‘D’;
else if (score < 80.00)
cout << “\nThe corresponding letter grade is:\t” << ‘C’;
else if (score < 90.00)
cout << “\nThe corresponding letter grade is:\t” << ‘B’;
else
cout << “\nThe corresponding letter grade is:\t” << ‘A’;
©2017 Gilbert Ndjatou Page 118
Exercise 3.32*
a. What is the output of the following program segment for each of the following input values:
i. input value: 3 ii. input value: 7 iii. input value: 12
cin >> num;
if (num < 5)
cout << "Red\t";
else if (num < 10)
cout << "Yellow\t";
else
cout << "Green\t";
cout << “blue”
b. For what range of values is the output respectively:
i. Red Blue. ii. Yellow Blue. iii. Green Blue.
Exercise 3.33
The fines imposed for speeding violations are specified as follows:
$0.00 for a speed <= 50 mph; $15.00 for a speed such that 50 < speed <= 70; $30.00 for a speed
such that 70 < peed <= 80; and $60.00 for a speed such that speed > 80.
a. Specify an algorithm (using a flowchart) to read the speed of a car and to output the corresponding
fine.
b. Write the C++ code segment that corresponds to the algorithm in part a.
Case Study 3.11
Problem Statement
A car dealer offers a rebate on three different types of car as follows:
Mid-size cars: $ 300.00; Sedans: $ 500.00; and Trucks: $ 700.00.
And each type of car is encoded by an integer value as follows:
Small cars 1
Mid-size cars 2
Sedans 3
SUVs 4
Trucks 5
Write a program to read the list price of a car and the code representing its type, and to do the following:
Determine if there is a rebate on that car:
if there is a rebate, print the rebate and compute the price of the car with the rebate.
Compute the sale tax (8.25 % of the price after the rebate).
Compute the total price (prix + sale tax) of the car and print it.
It is assumed that the user of the program always enters a valid code for the type of car.
©2017 Gilbert Ndjatou Page 119
Program Logic
Input: the price of a car and the code of its type.
Output: the total price of the car.
variables:
price (double) to hold the price of the car.
saleTax (double) to hold the sale tax on the car.
carType (int) to hold the code of the type of the car.
Algorithm Specification (using a Flowchart)
True False
True False
True False
carType = 2
carType = 3
carType = 5
Start
Read
price, carType
Write
300
Write
500
Stop
Write 700
price = price - 300
price = price - 500
price = price - 700
saleTax = .0825 * price
Write
price + saleTax
©2017 Gilbert Ndjatou Page 120
The program is provided in figure 3.18.
Figure 3.18 Implementing a Multiple-way Selection without default-Action
Line Number
1 /****************************************************************
2 Program to compute the total price of a car with the dealer’s
3 rebate.
4 ****************************************************************/
5 #include <iostream>
6 using namespace std;
7 #define TAXRATE 0.0825 /* tax rate of 8.25 % */
8 #define MIDREBATE 300.00 /* rebate on mid-size cars */
9 #define SEDANREBATE 500.00 /* rebate on sedans */
10 #define TRUCKREBATE 700.00 /* rebate on trucks */
11
12 int main()
13 {
14 double price, // to hold the car price
15 saleTax; // to hold the sale tax on the car
16 int carType; // to hold the code of the type of the car
17
18 /*– read the list price and the code of the type of the car */
19 cout << “\nEnter the list price and ”
<< “ the code of the type of the car in this order:\t”;
20 cin >> price >> carType;
21
22 /*------------ find out if the car has a rebate ----------*/
23 if ( carType == 2)
24 {
25 cout << “\n This car rebate is:\t$” << MIDREBATE;
26 price = price - MIDREBATE;
27 }
28 else if ( carType == 3)
29 {
30 cout << “\n This car rebate is:\t$” << SEDANREBATE;
31 price = price - SEDANREBATE;
32 }
33 else if ( carType == 5)
34 {
35 cout << “\n This car rebate is:\t$” << TRUCKREBATE;
36 price = price - TRUCKREBATE;
37 }
38
39 /*------ compute and print the total price of the car ------*/
40 saleTax = price * TAXRATE;
41 cout << “\n The price of the car is:\t$” <<(price + saleTax);
42 return( 0 );
43 }
©2017 Gilbert Ndjatou Page 121
Exercise 3.34
A game consists of selecting a positive integer value and rewarding bonuses to the player according to
the remainder in the division of that integer value by 5 as follows:
REMAINDER BONUS
0 200
1 350
2 400
3 500
4 750
a. Specify an algorithm (using a flowchart) to read a positive integer value and to output the bonus
received by the user.
b. Write the C++ code segment that corresponds to the algorithm in question a.
3.9 Tracing the Execution of a Program
Example 1:
Given the following definitions of variables: int num1 = 5, num2, result = 0;
Trace the execution of the following program segment for each of the following input values:
a. input value: 8 b. input value: 3
Line Number Statement
1 cin >> num2;
2 if(num1 > num2)
3 result = num1 + 4;
4 if (num2 < 7)
5 num1 = num2 + num1;
6 else if (num2 > 10)
7 num1 = 2 * num1;
8 result = result + num1 + num2;
9 cout << result;
a. Trace for input value: 8
Line Number Variables
num1 num2 result Output:
- 5 ? 0 13
1 5 8 0
2 5 8 0
4 5 8 0
6 5 8 0
8 5 8 13
9 5 8 13
©2017 Gilbert Ndjatou Page 122
b. Trace for input value: 3
Line Number Variables
num1 num2 result Output:
- 5 ? 0 20
1 5 3 0
2 5 3 0
3 5 3 9
4 5 3 9
5 8 3 9
8 8 3 20
9 8 3 20
Exercise 3.35*
Trace the execution of the code segment in the example above for each of the following input values:
a. input value: 2 b. input value: 6
Example 2: Given the following definitions of variables: int ndx = 10, num, result = 0;
Trace the execution of the following program segment:
Line Number Statement
1 num = 0;
2 while( ndx > 7 )
3 {
4 num = num + 3;
5 result = result + num + ndx;
6 ndx = ndx - 2;
7 }
8 cout << “\nndx =\t” << ndx;
9 cout << “\nresult=\t” << result;
©2017 Gilbert Ndjatou Page 123
Trace:
Line Number Variables Output:
ndx num result ndx = 6
- 10 ? 0 result = 27
1 10 0 0
2 10 0 0
4 10 3 0
5 10 3 13
6 8 3 13
2 8 3 13
4 8 6 13
5 8 6 27
6 6 6 27
2 6 6 27
8 6 6 27
9 6 6 27
Exercise 3.36*
Trace the execution of the following program segments:
1 ndx = 1;
2 pnum = 60;
3 while(ndx < 5)
{
4 pnum = pnum / ndx;
5 ndx = ndx + 2;
}
6 cout << “\npnum=” << pnum
<< “\nndx=” << ndx;
©2017 Gilbert Ndjatou Page 124
Exercises 1. a. Specify an algorithm (using a flowchart) to read an integer value and to determine if it is a multiple of 7.
If it is a multiple of 7, print it with the message “MULTIPLE OF 7”, otherwise, print it with the message
NOT MULTIPLE OF 7.”
b. Write the C++ code segment that corresponds to the algorithm in part a.
2. A department store awards bonuses to customers according to the price of the items purchased as follows:
If the price is greater than $100.00, then the bonus is 10 %; of the price; otherwise, it is 5 % of the price.
a. Specify an algorithm (using a flowchart) to read the unit price and the number of items of a product that a
customer has purchased and to compute and print the price of that product and the bonus awarded.
b. Write the C++ code segment that corresponds to the algorithm in part a.
3 a. Specify an algorithm (using a flowchart) to read two integer values and to do the following: if the first
value is greater than the second, add 3 to the first value, and compute the sum and the difference of the new first
value minus the second, and print the results; otherwise, subtract 2 from the first value, and compute the product
of the new first value and the second, and the quotient in the division of the second value by 2, and print the
results. Regardless of the values read, compute two times the new first value minus the second value, and print
the result.
b. Write the C++ code segment that corresponds to the algorithm in part a.
4. a. Specify an algorithm (using a flowchart) to read a character value and to determine if it is a letter of the
alphabet. If it is, print it with the message “LETTER”; otherwise print it with the message “NOT A LETTER.”
b. Write the C++ code segment that corresponds to the algorithm in part a.
5. a. A client has purchased 20 products in a store. Specify an algorithm (using a flowchart) to read the unit
price and the number of items of each product and to compute its (total) price (number items times the unit
price). Also compute and print the total price of all these products.
b. Write the C++ code segment that corresponds to the algorithm in part a.
6. a. Specify an algorithm (using a flowchart) to add the first 20 positive integer values ( 1 + 2 + 3 + . . . + 20)
and to output the result.
b. Write the C++ code segment that corresponds to the algorithm in part a.
7. a. Specify an algorithm (using a flowchart) to read a double precision floating-point value, to calculate its
6th power ( n * n * n * n * n * n), and to output the result.
b. Write the C++ code segment that corresponds to the algorithm in part a.
8. a. Specify an algorithm (using a flowchart) to read 20 non zero integer values and to count the number of
positive values and the number of negative values, and to output the results.
b. Write the C++ code segment that corresponds to the algorithm in part a.
9. a. Specify an algorithm (using a flowchart) to read 20 non zero integer values and to compute the average of
positive values and the average of negative values, and to output the results.
b. Write the C++ code segment that corresponds to the algorithm in part a.
10. a. Specify an algorithm (using a flowchart) to read the prices of one or more books, and to compute their
average price. Book prices are input one after another, and terminated with the sentinel value -99.00.
b. Write the C++ code segment that corresponds to the algorithm in part a.
11. a. Specify an algorithm (using a flowchart) to read one or more positive integer values and to compute their
product. The sentinel value 0 marks the end of the input values.
b. Write the C++ program that corresponds to the algorithm in part a.
©2017 Gilbert Ndjatou Page 125
12. a. Specify an algorithm (using a flowchart) to read the test scores of one or more students (until the sentinel
value -99 is read) and to compute their average.
b. Write the C++ code segment that corresponds to the algorithm in part a.
13. a. greatt, smallt, and somet are integer variables with some initial values. Specify an algorithm (using a
flowchart) to read an integer value into variable num and to do the following: add 1 to smallt if the value read is
less than 5; then add 2 to greatt if the value read is greater than 20, otherwise subtract 3 from smallt. Then,
regardless of the value read add 7 to somet.
b. Write the C++ code segment that corresponds to the algorithm in part a.
14. a. small_ct, middle_ct, large_ct, and sum are integer variables with some initial values. Specify an
algorithm (using a flowchart) to carry out the following tasks: read a value into the integer variable num and if
the value read is greater than 100, add 1 to variable large_ct; if it is less than 50, add 2 to variable small_ct;
otherwise, add 3 to variable middle_ct; regardless of the value read, add it to variable sum.
b. Write the C++ code segment that corresponds to algorithm in part a.
15. a. Specify an algorithm (using a flowchart) to read 50 integer values and determine and print the number of
even values.
b. Write the C++ code segment that corresponds to the algorithm in part a.
16. a. Specify an algorithm (using a flowchart) to read 50 integer values and to compute and print the average of
positive values. If there are no positive values, print an appropriate message.
b. Write the C++ program that corresponds to the algorithm in part a.
17. a. Specify an algorithm (using a flowchart) to read an integer value, an operator ( +, -, *, %, or / ), and
another integer value in this order (for example, 23 + 5), and to compute the expression consisting of the first
value, followed by the operator, which is followed by the second value, and to output the result. Note that in the
division of the first value by the second, you must make sure that the second value is not zero.
b. Write the C++ code segment that corresponds to the algorithm in part a.
18. A department store offers rebates to customers according to the price of the items purchased as follows:
Price >= $ 100.00 Rebate = $ 10.00
$ 50 <= Price < $ 100.00 Rebate = $ 5.00
$ 20 <= price < $ 50.00 Rebate = $ 2.00
price < $ 20.00 No rebate
A sale tax of 8.25% is also imposed on the price of each purchase (after the rebate, if any).
a. Specify an algorithm (using a flowchart) to read the unit price and the number of items purchased of a
product, and to output the rebate received by the customer, the total price (including the rebate), and the amount
due (including taxes).
b. Write the C++ code segment that corresponds to the algorithm in part a.
19. Write a C++ code segment to read a character from the keyboard and to determine if it is a letter of the
alphabet (‘a’ - ‘z’ or ‘A’ - ‘Z’), a digit (‘0' - ‘9'), or a special character (any other character). If it is a letter, print
the message “letter”; if it is a digit, print the message “digit”; and if it is a special character, print the message
“special character”.
©2017 Gilbert Ndjatou Page 126
Solutions of the Exercises
Exercise 3.1*
a
Variables: len (double) to hold the length of the rectangle
width (double) to hold its width
Pseudo code
1. Read the length of the rectangle into the variable len.
2. Read the width of the rectangle into the variable width.
3. Compute and print the perimeter of the rectangle.
4. Compute and print the area of the rectangle.
Flowchart
b. C++ Code Segment
double len, // to hold the length of the rectangle
width; // to hold its width
/*---------- read the width and the length of the rectangle ----------*/
cout << endl << “Enter the width of the rectangle (in inches):\t”;
cin >> width;
cout << endl << “Enter its length (in inches):\t”;
cin >> len;
/*------------ compute and print its perimeter -----------------------*/
Cout << endl << “Its perimeter is:\t”
<< 2 * ( len + width ) << “ inches”;
/*------------compute and print its area ----------------------------*/
cout << endl << “Its area is:\t” << len * width
<< “ square inches”;
Start
Read
len, width
Write
2 * (len + width)
Stop
Write
len * width
©2017 Gilbert Ndjatou Page 127
Exercise 3.3*
a. num1 <= 5 c. 3 * num 2 > fnum + 2 e. num1 + 3 != num1 * 4 f. ch – ‘M’ = = 5
9 <= 5 3 * 5 > 12.50 + 2 9 + 3 != 9 * 4 3 = = 5
False 15 > 14.50 12 != 36 False
True True
b. 3 * num1 + 4 < num3 * 2 d. 2 * num1 + 12 = = 3 * num3
3 * 9 + 4 < 10 * 2 2 * 9 + 12 = = 3 * 10
27 + 4 < 20 18 + 12 = = 30
31 < 20 30 = = 30
False True
Exercise 3.6*.
Variables num (int) to hold the integer value
a. Algorithm using Pseudo-Code
1. read the integer value into variable num.
2. If num > 0 then do the following:
2.a. print it with the message “POSITIVE”
3. Otherwise, do the following:
3.a. print it with the message “NEGATIVE”
Flowchart
False True
Start
Read
num
num > 0
Write
num,
“POSITIVE”
Write
num,
“NEGATIVE”
Stop
©2017 Gilbert Ndjatou Page 128
b. C++ Language Code Segment:
int num;
cin >> num;
if ( num > 0 )
cout << endl << num << “POSITIVE”;
else
cout << endl << num << “NEGATIVE”;
Exercise 3.7*
Variables symb (char) to hold the character value
a. Algorithm using Pseudo-Code
1. read the character value into variable symb.
2. If (symb >= ‘0’ AND symb <= ‘9’) then do the following:
2.a. print it with the message “DIGIT”
3. Otherwise, do the following:
3.a. print it with the message “NOT A DIGIT”
Flowchart
False True
Start
Read
symb
(symb >= ‘0’ && symb <= ‘9’)
Write
symb,
“DIGIT”
Write
symb, “NOT A
DIGIT”
Stop
©2017 Gilbert Ndjatou Page 129
b. C++ Language Code Segment:
char symb;
cin >> symb;
if (symb >= ‘0’ && symb <= ‘9’)
cout << endl << symb << “\t is a digit”;
else
cout << endl << symb << “\t is not a digit”;
Exercise 3.9*
Variables num (int) to hold the integer value
a. Algorithm using Pseudo-Code
1. read the integer value into variable num.
2. If num % 5 = 0 then do the following:
2.a. print it with the message “MULTIPLE OF 5”
3. Otherwise, do the following:
3.a. print it with the message “NOT MULTIPLE OF 5”
Flowchart
False True
Start
Read
num
num % 5 = 0
Write
num,
“MULTIPLE OF 5”
Write
num,
“NOT MULTIPLE of 5”
Stop
©2017 Gilbert Ndjatou Page 130
b. C++ Language Code Segment:
int num;
cin >> num;
if ( num % 5 == 0 )
cout << endl << num << “MULTIPLE OF 5”;
else
cout << endl << num << “NOT MULTIPLE OF 5”;
Exercise 3.10*
a) cin >> num;
if (num = 5) ---------------------> num == 5
sum = num + 4;
else
sum = num + 10;
b) cin >> num;
if (num > 5 && <= 10) ---------------> num > 5 && num <= 10
cout << num + 15;
else
cout << num - 3;
c) cin >> num; cin >> num;
if (num < 15) if (num < 15)
result1 = 2 * num; ----------------> {
result2 = num + 20; result = 2 * num;
else ---------------- > result2 = num + 20;
result1 = 5 * num; }
result = result1 + result2; else
cout << “\nThe result is:\t” << result; reult1 = 5 * num;
result = result1 + result2;
cout << “\nThe result is:\t” << result;
©2017 Gilbert Ndjatou Page 131
Exercise 3.11*
Input: 4 input: 20
Line # num Line # num
1 4 1 20
2 4 2 20
3 10 5 20
4 10 6 20
6 10
Output: num = 10 Output: num / 4 = 5
result = 20 result = 40
Exercise 3.14* a. b. c.
count = 0; count = 0;
while( count < 10 ) while(count < 10) count = 0;
{ { while(count < 10 )
cin >> num; count = 0; {
cout << 2 * num; cin >> num; cin >> num;
count = count + 1; cout << 2 * num; cout << 2 * num;
} count = count + 1; count = count + 1;
} }
Exercise 3.16*
a. b.
sum = 0; sum = 0;
count = 0; count = 0;
while (count < 10 ) while (count < 10 )
{ {
sum = 0; cin>>num;
cin >> num; sum = sum + num;
sum = sum + num; count = count + 1;
count = count + 1; }
}
Exercise 3.17*
a. Variables
testCount (int) to count the test scores
score (double) to hold a test score
totalScore (double) to hold the current total of the test scores
©2017 Gilbert Ndjatou Page 132
Pseudo-Code
1. Set the test score counter testCount to 0: testCount = 0.
2. set the current total of the test scores to 0: totalScore = 0.
3. As long testCount is less than 20, do the following:
3.a. Read a test score into variable score.
3.b. add the test score read to the current total of the test scores: totalScore = totalScore + score.
3.c. increment the test score counter by 1: testCount = testCount + 1.
4. Compute and print the average score, totalScore / 20.
Flowchart
False True
Start
totalScore = totalScore + score
testCount < 20
Stop
testCount = 0
Read
score
totalScore = 0
testCount = testCount + 1 Write
totalScore / 20
©2017 Gilbert Ndjatou Page 133
b. C++ Language Code Segment
int testCount = 0;
double score,
totalScore = 0;
while ( testCount < 20 )
{
cout << endl << “enter a test score:\t” ;
cin >> score;
totalScore = totalScore + score;
testCount = testCount + 1;
}
cout << endl << “the average test score is:\t” << totalScore / 20;
Exercise 3.20*
a Variables:
value (int) to hold a value
product (int) to hold the product.
count (int) to count the values.
Pseudo-Code
1. Set the current product to 1: product = 1.
2. Set the loop counter count to 0.
1. As long count < 10 do the following:
3.a. read a value into the variable value.
3.b. compute: product = product * value
3.c. Increment the loop counter count by 1.
2. Print the product.
©2017 Gilbert Ndjatou Page 134
Flowchart
False True
b. C++ Language Code Segment
int product = 1, value,
count = 0;
while ( count < 10)
{
cin >> value;
product = product * value;
count = count + 1;
}
cout << product;
Start
count = 0
count = count + 1
count < 10
Stop
product = 1
product = product * value
Write
product
Read
value
©2017 Gilbert Ndjatou Page 135
Exercise 3.22*
Variables
TotalSale (double) to hold the total sale in the store
DailySale (double) to hold a daily sale in the store
Pseudo-Code
1. set the total sale TotalSale to 0
2. As long as the total sale TotalSale is less than 10000 do the following:
2.a. Read a daily sale into the variable DailySale.
2.b. Add the daily sale to the total sale.
3. print the total sale and the message “it is time to make a deposit”.
Flowchart
False True
Start
TotalSale = TotalSale + DailySale
TotalSale < 10000
Stop
TotalSale = 0
Read
DailySale
Write
TotalSale - 10000
“time to make deposit”
©2017 Gilbert Ndjatou Page 136
b. C++ Language Code Segment
int totalSale = 0,
dailySale;
while (totalSale < 10000)
{
cin >> dailySale;
totalSale = totalSale + dailySale;
}
cout << endl << totalSale - 10000 << “\tIt is time to make a deposit”;
Exercise 3.25*
#define DUMMYVALUE -99
int main ( )
{
int total = 0, value;
cout << “\nEnter all values to add followed by”
<< DUMMYVALUE << “to stop\n”;
cin >> value; // add this statement here
while ( value != DUMMYVALUE )
{
cin >> value; // remove this statement
total = total + value;
cin >> value; // add this statement here
}
cout << endl << “The total of these values is:\t” << total;
return ( 0 );
}
Exercise 3.26*
a Variables
ftemp (double) to hold a temperature in Fahrenheit
Pseudo-Code
1. Read a temperature (in Fahrenheit) into variable Ftemp.
2. As long as the temperature in the variable Ftemp is not –99.00 do the following:
2.a. Convert it to Celsius and print the result..
2.b. Read the next temperature (in Fahrenheit) into variable Ftemp.
©2017 Gilbert Ndjatou Page 137
Flowchart
False True
b. C++ Language Code Segment
int ftemp;
cin >> ftemp;
while ( ftemp != -99.00 )
{
cout << endl << ftemp << “\t” << 5.0 / 9 * (Ftemp – 32);
cin >> ftemp;
}
Exercise 3.29*
a. Input value: 4 b. Input Value: 20
Output Output
Result= 3 pnum= 27
Result= 19
Exercise 3.32*
a. i. Input value: 3 ii. Input value: 7 iii. Input value: 12
Output Output Output
Red Yellow Green
blue blue blue
.b. i. the output is Red Blue for num < 5
ii. the output is Yellow Blue for 5 <= num < 10
iii. the output is Green Blue for num >= 10
Start
ftemp != -99.00
Stop
Read
ftemp
Write
5.0 / 9 * (ftemp – 32)
Read
ftemp
©2017 Gilbert Ndjatou Page 138
Exercise 3.35*
a. Input value: 2
Line Numbers Variables OUTPUT
num1 num2 result 18
- 5 ? 0
1 5 2 0
2 5 2 0
3 5 2 9
4 5 2 9
5 7 2 9
8 7 2 18
9 7 2 18
b. Input value: 6
Line Numbers Variables OUTPUT
num1 num2 result 17
- 5 ? 0
1 5 6 0
2 5 6 0
4 5 6 0
5 11 6 0
8 11 6 17
9 11 6 17
Exercise 3.36*
Line Numbers Variables OUTPUT
ndx pnum pnum = 20
- ? ? ndx = 5
1 1 ?
2 1 60
3 1 60
4 1 60
5 3 60
3 3 60
4 3 20
5 5 20
3 5 20
6 5 20