Exercise 5.1 (Completed)

1. (Modify) Rewrite Program 5.1 to print the numbers 2 to 10 in increments of 2. The output
of your program should be the following:
2  4  6  8  10

#include <iostream>
using namespace std;

int main()
{
	int count;
			count = 2;
			while (count <= 10)
			{
				if ((count % 2) == 0){
					cout << count << " ";
				}
				count++;
			}
return 0;
}

2. (Modify) Rewrite Program 5.4 to produce a table starting at a Celsius value of -10 and ending
with a Celsius value of 60, in increments of 10 degrees.
#include <iostream>
#include <iomanip>
#include <math.h>       /* pow & sqrt */ 
using namespace std;
int main()
{
		const int MAXCELSIUS = 60;
		const int STARTVAL = -10;
		const int STEPSIZE = 10;
		int celsius;
		double fahren;
		cout << "DEGREES   DEGREES\n"
			<< "CELSIUS  FAHRENHEIT\n"
			<< "------ - ----------\n";
		celsius = STARTVAL;

		// set output formats for floating-point numbers only
		cout << setiosflags(ios::showpoint) << setiosflags(ios::fixed)
			<< setprecision(2);
		while (celsius <= MAXCELSIUS)
		{
			fahren = (9.0 / 5.0) * celsius + 32.0;
			cout << setw(4) << celsius
				<< setw(13) << fahren << endl;
			celsius = celsius + STEPSIZE;
		}

	system("PAUSE");
	return 0;
}
3. (Desk check) a. For the following program, determine the total number of items displayed
as well as the first and last numbers printed:
#include <iostream>
using namespace std;
int main()
{
  int num = 0;
  while (num <= 20)
  {
    num++;
    cout << num << “ “;
  }
  return 0;
}

21 numbers are displayed, with 1 being the first and 21 being the last.

b. Enter and run the program from Exercise 3a on a computer to verify your answers to the
exercise.

Done!!

c. How would the output be affected if the two statements in the compound statement were
reversed (that is, if the cout statement were placed before the num++ statement)?

21 numbers would still be printed, but the first number would be 0 and the last would be 20.

4. (Program) Write, compile, and run a C++ program that converts gallons to liters. The program
should display gallons from 10 to 20 in 1-gallon increments and the corresponding liter equivalents.
Use the relationship that 1 gallon = 3.785 liters.
#include <iostream>
using namespace std;
int main()
{
		const int MAXCELSIUS = 20;
		const int STARTVAL = 10;
		const int STEPSIZE = 1;
		int gallons;
		double liters;
		cout << "GALLONS   LITERS\n"
			<< "------ - ----------\n";
		gallons = STARTVAL;

		// set output formats for floating-point numbers only
		cout << setiosflags(ios::showpoint) << setiosflags(ios::fixed)
			<< setprecision(2);
		while (gallons<= MAXCELSIUS)
		{
			liters = (gallons * 3.78541178);
			cout << setw(4) << gallons
				<< setw(13) << liters << endl;
			gallons = gallons + STEPSIZE;
		}

	system("PAUSE");
	return 0;
5. (Program) Write, compile, and run a C++ program that converts feet to meters. The program
should display feet from 3 to 30 in 3-foot increments and the corresponding meter equivalents.
Use the relationship that 3.28 feet = 1 meter.
#include <iostream>
using namespace std;
int main()
{
		const int MAXCELSIUS = 30;
		const int STARTVAL = 3;
		const int STEPSIZE = 3;
		int FEET;
		double METERS;
		cout << "FEET    METERS\n"
			<< "------ - ----------\n";
		FEET = STARTVAL;

		// set output formats for floating-point numbers only
		cout << setiosflags(ios::showpoint) << setiosflags(ios::fixed)
			<< setprecision(2);
		while (FEET<= MAXCELSIUS)
		{
			METERS = (FEET * .3048);
			cout << setw(4) << FEET
				<< setw(13) << METERS << endl;
			FEET = FEET + STEPSIZE;
		}

	system("PAUSE");
	return 0;
}
6. (Program) A machine purchased for $28,000 is depreciated at a rate of $4000 a year for 7 years.
Write, compile, and run a C++ program that computes and displays a depreciation table for
7 years. The table should have this form:
                       END-OF-YEAR    ACCUMULATED
YEAR   DEPRECIATION      VALUE        DEPRECIATION
----   ------------    -----------    ------------
1        4000            24000            4000
2        4000            20000            8000
3        4000            16000           12000
4        4000            12000           16000
5        4000             8000           20000
6        4000             4000           24000
7        4000                0           28000

#include <iostream>
using namespace std;
int main()
{
		const int MAX = 7;
		const int STARTVAL = 1;
		const int STEPSIZE = 1;
		int year, End_year_value;
		double depreciation, Accumulated_Depreciation;
		cout << "YEAR    DEPRESCIATION     END-OF-YEAR VALUE     ACCUMULATED DEPRECIATION \n"
			<< "------ - ------------- - ------------- - -------------- \n";
		year = STARTVAL;
		// set output formats for floating-point numbers only
		cout << setiosflags(ios::showpoint) << setiosflags(ios::fixed)
			<< setprecision(2);
		while (year<= MAX )
		{
			int End_year_value = 28000;
			depreciation = 4000;
			Accumulated_Depreciation = year * depreciation;
			End_year_value = End_year_value - Accumulated_Depreciation;
			cout << setw(4) << year
				<< setw(15) << depreciation
				<< setw(15) << End_year_value

<< setw(15) << Accumulated_Depreciation << endl;
			year = year + STEPSIZE;
			
		}

	system("PAUSE");
	return 0;
}
7. (Program) An automobile travels at an average speed of 55 mph for 4 hours. Write, compile,
and run a C++ program that displays the distance, in miles, the car has traveled after 0.5, 1.0,
1.5, and so on hours until the end of the trip.
#include <iostream>
using namespace std;
int main()
{
		 double MAX = 4;
		 double STARTVAL = .5;
		 double STEPSIZE = .5;
		 double hours,distance;
		 double speed = 55;
		cout << "HOURS    DISTANCE TRAVELED \n"
			<< "------ - -------------\n";
		hours = STARTVAL;
		// set output formats for floating-point numbers only
		cout << setiosflags(ios::showpoint) << setiosflags(ios::fixed)
			<< setprecision(2);
		while (hours <= MAX )
		{
			
			distance = speed * hours;
			cout << setw(4) << hours
				<< setw(15) << distance
				<< endl;
			hours = hours + STEPSIZE;
			
		}

	system("PAUSE");
	return 0;
}

8. (Program) a. The following is an approximate conversion formula for converting Fahrenheit
to Celsius temperatures:
Celsius = (Fahrenheit - 30) / 2
Using this formula, and starting with a Fahrenheit temperature of 0 degrees, write a C++ program
that determines when the approximate equivalent Celsius temperature differs from the
exact equivalent value by more than 4 degrees. (Hint: Use a while loop that terminates when
the difference between approximate and exact Celsius equivalents exceeds 4 degrees.)

#include <iostream>
using namespace std;
int main()
{
		 const int  MAX = 100;
		 const int  STARTVAL = 0;
		 const int  STEPSIZE = 1;
		 double Fahrenheit = 0;
		 double Celsius, realCelsius;
		cout << "REALCELSIUS      CELSIUS      \n"
			<< " ----------- - ------------- \n";
		Fahrenheit = STARTVAL;
		// set output formats for floating-point numbers only
		cout << setiosflags(ios::showpoint) << setiosflags(ios::fixed)
			<< setprecision(2);
		
		while (Fahrenheit <= MAX &&  (Celsius - realCelsius) < 4 )
		{
			Celsius = (Fahrenheit - 30) / 2;
			realCelsius = ((Fahrenheit - 32) * (.55555555555));
			cout << setw(4) << realCelsius
				<< setw(15) << Celsius				
				<< endl;
			Fahrenheit = Fahrenheit + STEPSIZE;	
		}

	system("PAUSE");
	return 0;
	}

b. Using the approximate Celsius conversion formula given in Exercise 8a, write a C++ program
that produces a table of Fahrenheit temperatures, exact Celsius equivalent temperatures,
approximate Celsius equivalent temperatures, and the difference between the exact
and approximate equivalent Celsius values. The table should begin at 0 degrees Fahrenheit,
use 2-degree Fahrenheit increments, and terminate when the difference between exact and
approximate values is more than 4 degrees.

#include <iostream>
using namespace std;
int main()
{
	const int  MAX = 100;
	const int  STARTVAL = 0;
	const int  STEPSIZE = 2;
	double Fahrenheit = 0;
	double Celsius, realCelsius, difference;
	cout << "REALCELSIUS      CELSIUS     FAHRENHEIT      DIFFERENCE \n"
		<< " ----------- - ------------- - ---------------- - ---------------\n";
	Fahrenheit = STARTVAL;
	// set output formats for floating-point numbers only
	cout << setiosflags(ios::showpoint) << setiosflags(ios::fixed)
		<< setprecision(2);
	difference = Celsius - realCelsius;
	while (Fahrenheit <= MAX && difference < 4)
	{
		Celsius = (Fahrenheit - 30) / 2;
		realCelsius = ((Fahrenheit - 32) * (.55555555555));
		cout << setw(4) << realCelsius
			<< setw(15) << Celsius
			<< setw(15) << Fahrenheit
			<< setw(15) << difference
			<< endl;
		Fahrenheit = Fahrenheit + STEPSIZE;
	}
        system("PAUSE");
        return 0;
        }