COMP 122 Entire Course NEW

COMP 122 Entire Course
Check this A+ tutorial guideline at
http://www.uopassignments.com/comp-122/comp-
122-entire-course
For more classes visit
http://www.uopassignments.com
COMP 122 Entire Course
COMP 122 Lab 1 Lab Report and Source Code

122-lab-1-lab-report-and-source-code
COMP 122 Week 1 iLab - Part 1
Follow the instructions in COMP
122_W1_iLab_Part1_instructions.docx.
COMP 122 Week 1 iLab - Part 2
Complete the following two programs:
Programming Problem 1

John wants to know the values of the area and perimeter
of a rectangle. John can take measurements of the length
and width of the rectangle in inches. John's
measurements are expected to be accurate to within 0.1
inch.
1. Identify the inputs and outputs of the problem.
2. Identify the processing needed to convert the inputs
to the outputs.
3. Design an algorithm in pseudo code to solve the
problem. Make sure to include steps to get each input
and to report each output.
4. Identify two test cases, one using whole number
values, and one using decimal number values. For each
of the two test cases show what inputs you will use and
what your expected outputs should be.
5. Write the program to implement your algorithm. Test
your program using your test cases. Did your program
produce the values predicted in your test cases? Explain.

COMP 122 Week 2 iLab
Write a program that calculates and outputs the
monthly paycheck information for an employee,
including all the amounts deducted from an employee’s
gross pay, and the net pay that is due to the employee.
The user of your program will know the employee’s
name and the gross pay for the employee. Each

employee has the following deductions taken from his
gross pay:
Federal Income Tax: 15%
State Tax: 3.5%
Social Security + Medicare Tax: 8.5%
Health Insurance $75
The output from your program should be structured as
is displayed below:
Bill Robinson
Gross Amount: ............ $3575.00
Federal Tax: ............. $ 536.25
State Tax: ............... $ 125.13
Social Sec / Medicare: ... $ 303.88
Health Insurance: ........ $ 75.00
Net Pay: ................. $2534.75
Your program should deal with erroneous input values.
Gross salary should always be a positive number. Make
sure that you deal with the possibility that the user may
have entered a non-numeric input value. Have your
program output appropriate error messages in these
cases.
to the outputs.

3. Design an algorithm in pseudo code to solve the
and to report each output. Include steps to deal with
error cases.
4. Identify three test cases, one using a positive number,
and one using a negative number, and one using
incorrect input (ie. Input a letter rather than a digit for
the numeric input). For each of the three test cases show
what inputs you will use and what your expected
outputs should be.
your program using your test cases.
In a right triangle, the square of the length of one side is
equal to the sum of the squares of the lengths of the
other two sides. Stephanie has the integer lengths of
three sides of a triangle and needs to know if it is a right
triangle.
Write a program to solve this problem. NOTE: The user
must be allowed to input the values of the sides in ANY
ORDER!
to the outputs.

3. Design an algorithm in pseudocode to solve the
4. Identify five significant test cases including one for
incorrect input (ie. Input a letter rather than a digit for
the numeric input). (Think about what impact changing
the order of the input values should have on your
program!) For each of the five test cases show what
inputs you will use and calculate what your expected
outputs should be.

Write a program that generates all the factors of a
number entered by the user. For instance, the number
12 has the factors 2 * 2 * 3. This program has the
following requirements:
A. The user must enter a positive integer. If the user
enters something else, your program should output an

error message and let the user enter a new value. Use a
do/while loop to make sure the user input is successful.
B. The factors must be output in increasing order. The
lowest factor your program should report is 2.
C. Your program should output 4 factors per line, each
factor in a field of 10 characters. (Hint: the number of
factors output determines when to output endl!)
D. You will need a while loop to report the factors. Here
are some helpful hints:
1. If (a % b == 0) then a is a factor of b.
2. When you have found a factor, output the factor and
then reduce the number you are working with by
dividing the number by the factor… ie) / a;
and to report the output. Include steps to deal with
error cases as specified above.
2. Identify three test cases, one using a number with 4
factors, one using a negative number, and one using a
number with more than 4 factors. For each of the three
test cases show what inputs you will use and what your
expected outputs should be.

This program is designed to analyze the growth of two
cities. Each city has a starting population and annual
growth rate. The smaller city has the larger growth rate
(required). Show the comparative populations of each
city year by year until the smaller city has grown larger
than the bigger city.
As an example, Dogville has a population of 5000
growing at 20% annually while Cattown has a
population of 7000 growing at 10% annually. The
projected populations are:
Year DogvilleCattown
1 6000 7700
2 7200 8470
3 8640 9317
4 10368 10249
to the outputs
4. Identify three significant test cases including one for
incorrect input (ie Small town has lower growth rate).
For each of the three test cases show what inputs you

will use and calculate what your expected outputs
should be.

COMP 122 Week 4 Lab Part 1
Part 1 of this week’s lab will give you an opportunity to
use the debugging capabilities of Visual Studio. Part 2
will present a problem for which you will need to create
a test plan and actually test an executable program to
determine if it behaves correctly.
Part 1 – Using the Debugger
To begin this exercise, create a VC++ project and copy
the following code into your project. Make sure that the
project compiles successfully.

#include
using namespace std;
int main()
{
int input;
int , ;
int ;
cout< "enter="" which="" number="" in="" the=""
fibonacci="" number="" sequence="" you="" want=""
to="" find."=""><endl;="">
cout< "the="" first="" and="" second="" fibonacci=""
numbers="" are="" 1."=""><endl;="">
cin>> input;
while (input < 1)="">
{
cout< "you="" must="" enter="" a="" value="" greater=""
than="" 0,="" try="" again."=""><endl;="">
cin>> input;
}
if (input > 2)
{
for(int ; i < input;="" i++)="">
{
;
;
+ back2;
}
}
cout< "the="" value="" of="" fibonacci="" number=""
"="">< input="">< "="" is="" "=""><

current=""><endl;="">
cin.ignore(2);
return 0;
}
Part 2 – Black Box Testing
A customer has requested a program be developed to
meet the following criterion:
1. The program needs to convert from celcius
temperatures to fahrenheit temperatures.
2. The user should be able to enter temperatures
containing fractional degrees (ie. 12.3)
3. The converted temperatures should be accurate to
within 1/10th of a degree.
4. The user should be able to enter the number of
temperatures to be converted up to a maximum of 10.
5. The output should be tabular with each row including
the input and converted temperature.
Write a test plan to thoroughly test this program. The
executable for this program is included in with this lab.
You should have test cases which verify that the
program does all of what is required in the problem
specification above. You should also test to see how
robust the program is, that is, how does it handle inputs
outside the expected ranges.

Document your test plan in a table. For each test case,
document the expected program behavior and the
actual program behavior. If the program does not
behave according to your prediction, write a brief
explanation of what the program did wrong.

Objectives
Apply structured and modular design principles to write
programs that meet written specifications and
requirements. Develop a pseudo-code design using
appropriate program structure (sequence, selection,
repetition and nesting) to solve a given programming
problem. Use appropriate selection and repetition
statements to implement the design. Create user-
defined functions to implement a modular design. Use

appropriate parameter passing mechanisms for passing
data into and getting data back from functions. Use
ostream and iomanip formatting manipulators to
display tabulated data. Design and implement a menu-
driven interface.
Problem Description
This program is to give the user the option of converting
a set of temperatures either from Celsius to Fahrenheit
(C to F) or vice versa, from Fahrenheit to Celsius (F to C),
or to quit the program. If the user selects either C to F or
F to C, the program will prompt the user to enter three
integer values, a starting temperature, an ending
temperature, and an increment. After these values have
been entered the program will display a table of
equivalent C and F (or F and C) temperatures, from the
starting temperature to the ending temperature and
incrementing by the increment value each row.
The table must meet all of the following criteria:
The table's column headings should display the degree
symbol, e.g., °C and °F. The first column must be the
"from" temperature (C for C to F or F for F to C) and the
second column the "to" temperature (F for C to F or C for
F to C). The calculated "to" temperatures are to be
displayed to the nearest tenth of a degree (display
exactly one decimal place, even if there is no fractional
part, i.e., 75° should display as 75.0°). Temperatures in
both columns must be number-aligned (right-justified

for the integer "from" values and decimal point aligned
right for the "to" values). Assume the user enters correct
data, e.g., the start temperature, end temperature and
increment are all integers and the ending temperature
is greater than the starting temperature.
The formula to convert Celsius to Fahrenheit is
The formula to convert Fahrenheit to Celsius is
Function Requirements
You must create and use the following functions:
displayMenu( ) displays a menu. getMenuSelection ( )
gets the menu selection from the user, upper or lower
case 'C' for Celsius to Fahrenheit, upper or lower case 'F'
for Fahrenheit to Celsius, and upper or lower case 'Q' to
quit. Any other input should get an error message
"Invalid selection: try again" and re-prompt for the
menu selection. getStartEndAndIncrement( ) gets the
start, end and increment values for the table from the
user. CtoF( ) converts a Celsius temperature to
Fahrenheit. FtoC( )converts a Fahrenheit temperatures
to Celsius. displayTable( ) displays a C to F or F to C table
given start, end and increment values and the
conversion character the user selected.
Additional Requirements
Absolutely NO GLOBAL VARIABLES can be used to
implement this program! Any program using global

variables will NOT be accepted! Use a switch statement
to respond to the user's menu selection in the
getMenuSelection function. After the user selects a valid
temperature table option, ask the user to enter start,
end, and increment values, then display the table and
stop until the user presses the ENTER key to continue
(prompt the user, of course). When the user presses
ENTER to continue the menu should be redisplayed,
allowing the user to make another menu selection
(either to display another temperature conversion table
or quit). Make sure that your code is properly formatted
(indentation, etc) and that you have provided suitable
documentation of all your functions (comment blocks
for program and functions!).
How to print the degree symbol
It is easy enough to find out how to do this by searching
the web. The short answer is:
cout< (char)248;="">
Test Plan
Test cases are generally selected by analyzing the
program and determining categories of inputs and
outputs, then specifying at least one specific input value
(or set of input values) for each category. Inputs for this
program include the "selection," or menu input, and
integer values to generate a table (start temperature,
stop temperature and increment value). Here is an
outline of the categories:

Menu test cases should include all possible valid menu
selections and at least one invalid menu selection. Table
test cases should include
2.1. Inputs that create tables with various numbers of
rows
2.2. At least one temperature that calculates to an exact
whole number of degrees (e.g., 0 degrees degrees F).
2.3. Negative starting and ending temperatures.
2.4. At least one temperature that calculates to a
fractional number of degrees (e.g., -50 degrees degrees
C).
2.5. Some common, easy to verify conversions, for
example
2.5.1. 0 degrees degrees F (and vice versa)
2.5.2. 100 degrees degrees F (and vice versa)
2.5.3. -40, the only temperature that is the same in both.
Given these categories, use the table on the next page to
record the specific input values you will use for your test
plan. Note that you must predict and document what the
output will be for each of your test cases, including the
calculated values for each row of the temperature tables
produced. Test your program using your selected test
cases and record the actual observed output from your
test cases by pasting screen shots into your report

document. Make sure everything works correctly before
submitting.

You are to design a program that will allow some
number of grades (up to a max of 100) to be input by the
user. After the data has been collected, your program
should calculate and output the mean and median of the
collected data, as well as the sorted grade information.
Design Constraints
Use an integer constant of 100 to specify the number of
elements in the array you will use to collect the grade

information. Do not use any global variables in your
program. Declare any arrays you need in your main
function and pass the arrays as needed into the
functions described below. The main function is the only
function permitted to do any output to the console!!! Do
not do cout operations inside of any other function.
Your data collection loop in your main function must
allow the user to enter less than 100 grades. It must also
make sure that the user does not try to enter more than
100 grades. Each data value entered should be checked
to make sure it is between 0 and 100. Any other value
entered should be considered invalid and ignored (ie.
not counted as a valid input and not stored in an array).
Once the data is collected, the array and the number of
grades collected must be passed to a function called
mean. The mean function must loop through the values
in the array, summing them together.
The result of the function is the sum divided by the
number of grades collected. The result must be returned
from the mean function to the main function, where is it
output in an appropriate manner (two digits after the
decimal point). The main function should then pass the
array and the number of grades collected to the median
function. The median of a set of numbers is the number
in the set where half the numbers are above it and half
the numbers are below it. In order to find the median,
this function will need to sort the original data. The
simplest sorting procedure is called bubble sorting. The
following pseudocode describes bubble sorting for X

valid array elements.
for ; outer < x;="" outer++="">
for ; inner < x-1;="" inner++="">
if array[inner] > array[inner+1]
swap(array[inner], array[inner+1]);
After the data has been sorted, the median value can be
found. If the array has an odd number of elements the
median is the value of the middle element (Hint:
arraySize/2 is the middle element). If the array has an
even number of elements then the median is the average
of the middle two elements (Hint: arraySize/2 and (
arraySize/2) - 1 are the two middle elements). The
median value should be returned by the median
function. The main routine should output the median
value in an appropriate manner. The main routine
should also output the sorted array with 5 grades per
line.
Carefully develop test cases for your program. Most of
your test cases do not need to contain lots of values.
Make sure to include incorrect inputs such as negative
grade values. Calculate what your mean and median
values should be for your test cases. Document your test
cases in a Word document. Run your test cases with your
program to see if your program generates the expected
output. If not, troubleshoot your program and fix the
problem. When your program executes a test case
correctly, take a screen shot of the program output and
paste it into your Word document to prove that your test
case executed correctly with your program. Make sure

that your code is properly formatted! You also need to
make sure you include a comment block for each
function which documents the purpose, inputs, and
outputs of each function!
Create a program using Visual C++.Net. Make sure to
capture a screen shot of your program running your test
cases! The best way to do this is to click on the console
window you want to capture and then press the Alt and
PrintScreen keys at the same time. Then paste your
captured screen image into your Word document. Your
Word document should contain your test cases, the
screen shots documenting your test cases, followed by a
copy of your source code.

The focus of this lab is on using strings. You will have an
opportunity to work with both C style strings and the
string data type. This lab also gives you an opportunity
to use what you have learned previously, including using
functions, array processing, repetition, and selection.
You will also have an opportunity to work with file input
and output.
You are to design and implement a program which does
encryption and decryption of data from files. Encryption

is the process of taking plain lines of text and
performing some algorithmic transformation on the
data to create an encrypted line of text which looks
nothing like the original. Decryption is the process of
taking an encrypted line of text and performing some
algorithmic transformation on the data to recover the
original line of plain text.
Encryption and Decryption Approach
Our approach to encryption and decryption involves two
strings. The first is an encryption / decryption string
which we will allow to be up to 128 lower case
alphabetical characters in length. The second string is a
line of text from a file that is to be encrypted or
decrypted.
Our basic strategy for encrypting data is based on
mapping alphabetical characters to specific values, then
doing some simple mathematical operations to create a
new value. First of all, every character in either the
encryption string or the input string is mapped to a
number between 0 and 25 based on its position in the
alphabet.
= 0
= 1
= 25
The mapped value of a character is easily obtained by
doing the following:
For lower case characters, subtract 'a' from the
character.

For upper case characters, subtract 'A' from the
character.
To calculate the modified value of the first character of
input we add its mapped value to the mapped value
from the first character of the encryption string. This
modified value is then adjusted using % 26 to make sure
that the final modified value is within the 0 - 25 range.
To create the final encrypted character value for the
first character, simply do the following:
For lower case characters, add 'a' to the modified value.
For upper case characters, add 'A' to the modified value.
This is done for each alphabetic character in the input
string. Non-alphabetic characters simply maintain their
present value. If the input string is longer than the
encryption string, simply reuse mapped values from the
encryption string. For instance, if the encryption string
has 10 characters (index values 0 - 9), when processing
the 11th input character (index 10), simply use the input
character index % length of encryption string (in this
case 10 % 10 is 0) to select the value from the
encryption string to use for mapping.
The decryption process is basically the same as the
encryption process. The only difference is the value of
the mapped character from the encryption string.
For lower case encryption, the mapped from encryption
string - 'a'
For upper case encryption, the mapped from encryption
string - 'A'
For lower case decryption, the mapped - (character from

encryption string - 'a')
For upper case decryption, the mapped - (character
from encryption string - 'A')
Program Requirements
Your program must meet the following requirements:
1. You must ask the user if they want to perform an
encryption or decryption operation.
2. You must ask the user to enter the name of the file
they want to encrypt or decrypt.
3. You must get an encryption key from the user which
can be up to 128 characters. The key must be all lower
case alphabetic characters.
4. You must have a function which takes the encryption
key and creates an encryption map from it. For each
character in the encryption key string, subtract the
lower case letter 'a' and store the result in the
corresponding encryption map array.
5. You must have a function which takes the encryption
key and creates a decryption map from it. For each
character in the encryption key string, subtract the
lower case letter 'a' from it. Then subtract that result
from 26 and store the value in the corresponding
decryption map array.

6. You must have a function which will do the encryption
or decryption transformation. This function takes the
following parameters:
A constant C string containing the line of text to be
transformed.
A constant C character array which contains the
encryption or decryption map.
An integer which contains the length of the encryption
map.
A string reference (output) which will contain the
encrypted or decrypted string upon completion.
The core of the encryption / decryption algorithm is as
follows:
For each character (the ith character) in the text input
line do the following:
if the character is not alphabetical, add it to the end of
the output string
if the character is lower case alphabetical
subtract the character 'a' from the character
get the ith % map length element from the map and add
it to the character

adjust the value of the character % 26 to keep it within
the alphabet
add the character 'a' to the character
add the encrypted character value to the end of the
output string
if the character is upper case alphabetical
do the same thing as for lower case except use 'A'
instead of 'a'
7. For decryption, the main program should create an
ifstream for the file to be decrypted. It should use the
getline method of the ifstream to read lines from the file,
call the encryption / decryption function with the line to
be decrypted, and display the string which contains the
result of the encryption / decryption function call.
Repeat until the ifstream reaches the end of the file, then
close the ifstream.
8. For encryption, the main program should create an
ifstream for the file to be encrypted. It should also create
an ofstream for the file where the encrypted result will
be stored. The file name for this file can be gotten from
the user or can be the input file name with a special
extension added at the end. The getline method of the
ifstream is used to read lines from the input file. Then
the encryption / decryption function is called to encrypt
the line. Display the string containing the result and

write the string to the ofstream. Close the ifstream and
ofstreams when finished.
9. Make sure that your program allows the user to
encrypt / decrypt more than one file per session. This
means adding a loop which allows the entire program to
repeat until the user has nothing more to do.
Hints
1. Use C strings for the encryption string and the file
names. Use char arrays for the encryption and
decryption maps. You cannot treat these as C strings
because the maps can contain 0 as a valid data item
rather than the end of string marker.
2. Use a string type variable to hold the encrypted and
decrypted strings. The string type allows you to add
characters to the end of a string using thepush_back
method, and it allows you to dump the contents of the
string using the erase method.
3. For input streams, you can use the eof method to
determine when you have reached the end of a file.
4. Use a character array to read data from the files. Set
the maximum length for this buffer to be 256 characters.
Development Strategy
I would recommend that you build this project in two
phases. The first phase should concentrate on getting
the encryption and decryption map functions and the

encryption / decryption function working. You can test
this by using fixed C strings for the input line and the
encryption string. Call the map functions, then encrypt
the fixed input string, output the result, then decrypt the
encrypted string and output the result. When your final
output is the same as the original input, your encryption
/ decryption functions are working. The second phase
adds the file operations.
Testing and Deliverables
When you think you have a working program, use
Notepad to create a file with plain text in it. You should
enter some different length lines containing a variety of
characters. Your file should have at least 10 lines. You
should try using short and long encryption keys. Using
your program, encrypt the file, then decrypt the
encrypted file. Take a screen shot of your decrypted
output and paste it into a Word document. Also copy the
contents of your original file and the encrypted file into
the Word document. Clearly label the contents of the
Word document. Then copy your source code into your
document. Make sure that you have used proper coding
style and commenting conventions!

COMP 122 Entire Course NEW

More Related Content

What's hot (17)

Similar to COMP 122 Entire Course NEW (17)

More from shyamuopeight (20)

Recently uploaded (20)

COMP 122 Entire Course NEW