Extra Credit Pre-Lab
Assignment , CSE 1320 Fall 2009
Due Date: See class website for due date
(see instructions on website for how to turn this in)
Grade value; Extra credit 3% (out of 100% for all grades) added to total of lab grades.
Topic objectives: Arithmetic and relational operators
Control structures
Functions
Arrays
Data types
Global constants
Pre-processor directives
Searching
Program design
Modular programming structure
Error checking
Programming style
The goal for this lab is to provide an opportunity for practice of program development and the C programming topics covered in Chapters 1-3 and parts of later chapters in Foster and Foster. These chapters will not be covered in detail in the 1320 class and it is assumed that the student is familiar with and can use all the concepts in those chapters. This assignment is designed to practice those concepts by creating a program. The format of this assignment is similar to the assignments that will be required for the rest of the semester so a student who is unsure of their skills can use this assignment to refresh them and to ask the instructor or TA about any concepts they are unsure of.
This assignment has an overview section, a task description section, an implementation requirements section, a grading scale, and a deductions section. If there is additional info needed it will be in a miscellaneous section at the end of this lab assignment. Read ALL of the assignment before you start trying to develop the program. Be sure to check the DEDUCTIONS section at the end of this assignment to avoid penalties. You may NOT use global variables, the exit command, goto, break (except in a switch), continue, structs, multiple dimension arrays, strings, passing by reference (except arrays), or linked lists.
* -- * -- * -- * -- * -- * -- * -- * -- * -- * -- * -- * -- * -- * -- * -- * -- * -- * -- * -- * -- * -- * -- * -- * --
At the start of any new school year, you and other students have the opportunity to get involved in campus activities. However, UTA has lots of activities that other students may not know about. Your goal for this program will be to develop a computer system that helps students learn about activities and groups on campus that they might want to get involved in. We'll call this system the "Campus Activities System" or CAS for short.
Throughout the course of this semester you will work on your CAS. Each lab assignment will build on the previous assignments and will also implement changes to make the system more efficient and so on. For this pre-lab you will be creating the beginning components of the CAS. You will implement a program that can hold data about student activities and groups such as group name, purpose, meeting time, and so on. You will write functions that can retrieve data that matches certain criteria, that can modify the data, that can output the data, and other tasks.
The tasks
for this pre-lab assignment will be:
+ Introduce the Campus Activities System to a new user.
+ Create one-dimensional arrays to store each type of the CAS data in and then populate the arrays with data.
+ Create and display a screen menu of the following choices for the user.
1) Using the data in the arrays,
A) Search for activity and group choices and data by
i. Number
ii. Meeting day
iii. Purpose
B) Count how many groups/activities have a specific purpose
C) List all the groups/activities that meet a certain criteria
i. Member type
ii. Size
D) Calculate cost to join all groups/activities
2) Update the data in the arrays-this will take the user to a submenu for doing updates
3) End the program
Each of these tasks is described in more detail below. There are also a number of simplifying assumptions for this pre-lab. Many of these simplifications will be eliminated in later labs.
Simplifying assumptions for the pre-lab:
a) Various constants will be given for use in the pre-lab.
b) All groups and activities meet on the UTA campus. Next lab will include this data.
c) All groups/activities will have a unique number. No strings will be needed for input in this pre-lab. (Later all groups and activities will be uniquely named, i.e. there will not be a "Volunteer" activity and a "Volunteer" group, they would be "Volunteer with Habitat for Humanity" and "UTA Volunteers" for example.)
Task Descriptions:
+
Introduce
the Campus Activity System to a new user.
For this task your system must provide an introduction/welcome screen to the user. The screen should briefly describe what the system will do. You may have the welcome screen stay up for a fixed period of time or you may let the user press a key to continue on with the program. Make sure you tell the user what to do if you want them to press a key.
+
Create
one-dimensional arrays to store each type of the group or activity data in and
then populate the arrays with data.
For the pre-lab, the following data will be used:
1. Number representing the group or activity - later labs will use group names
2. Meeting time consisting of
a. time of day given as hour and minute and then an 'a' for a.m. or a 'p' for p.m.
b. day of the week given as one letter (MTWRFSN)
c. week of the month given as '1' for first week, '2' for second week, '3' for third, '4' for fourth
3. Purpose of the group. The purpose must be one of the following as denoted by the letter preceding it:
F - fun and social organization/activity just to meet like minded people
V - volunteer organization/activity that does service activities of any type
A - academic; offers some sort of academic focused purpose such as tutoring, mentoring, study group, etc.
S - sports; opportunities to play or support teams
P - professional; focused on providing support to student for future professions
M - fine arts; music, dance, art, theatre and other types of arts activities
L - leadership; opportunities for leadership on campus or learning skills for leadership
C - cultural; offers support and education related to a specific culture or group of cultures
O - other
4. Member type. Specifies what types of students are eligible to be members. If more than one of these categories applies, then for the pre-lab select the category that includes the largest number of potential members. Member types are;
A - all students
G - graduate students only
M - Master's level graduate students only
P - Doctoral level graduate students only
U - undergraduate students only
4 - seniors only
3 - juniors only
2 - sophomores only
1 - freshmen only
E - engineering majors only
B - business majors only
L - liberal arts majors only
S - science majors only
R - architecture students only
N - nursing students only
S - social work students only
5. Size. Gives number of group members or activity participants
6. Cost. Gives cost to participate in the group or activity for one year
For the pre-lab, the data above will be stored in a set of one-dimensional arrays. Each array will have 10 elements in it for a maximum of ten groups/activities being described. (Use constants for these numbers.) Do NOT use multi-dimensional arrays for this pre-lab. The arrays are described below:
o Group/activity number - an integer array of ten elements that holds the numeric code associated with a specific group or activity. For this lab we aren't using strings so we will simply have a fixed set of groups/activities that are coded by number (ex. The Big Event = 004, SWE = 132, Student Senate = 488, etc.) and that list would be displayed in the output as described below. For all the other pieces of data, the index [n] for some group/activity code will refer to the same activity/group for all other info as well. (See the group/activity code list at the end of this assignment and you can add to it if desired.)
o Meeting hour - an integer array of ten elements that holds the hour info for the meeting time of the associated group/activity. The meeting hour [n] corresponds to group/activity code [n]. Make sure that the meeting hour that is entered is valid.
o Meeting minute - an integer array of ten elements that holds the minute info for the meeting time of the associated group/activity. The meeting minute [n] corresponds to group/activity code [n]. Make sure that the meeting minute that is entered is valid.
o Meeting half day - an character array of ten elements that holds the a.m. or p.m. info for the meeting time of the associated group/activity. The meeting half day [n] corresponds to group/activity code [n]. Make sure that the character that is entered is valid.
o Meeting day - an character array of ten elements that holds the day of the week info for the meeting time of the associated group/activity. Make sure that the character that is entered is valid, i.e. that it is one of the allowed characters.
o Meeting week - an integer array of ten elements that holds the week info for the meeting of the associated group/activity. The meeting week [n] corresponds to group/activity code [n]. Make sure that the meeting week that is entered is valid, e.g. how many weeks could there be in a month?
o Group/activity purpose - an character array of ten elements that holds the code of the purpose of the associated group/activity. Make sure that the character that is entered is valid, i.e. that it is one of the allowed characters.
o Group/activity member type - an character array of ten elements that holds the code of the types of students allowed to be members of the associated group/activity. Make sure that the character that is entered is valid, i.e. that it is one of the allowed characters.
o Group/activity size - an integer array of ten elements that holds the number of people involved in the associated group/activity.
o Group/activity cost - an float array of ten elements that holds the amount it costs to participate in the associated group/activity. Make sure this amount is not negative but it can be free to participate.
For the pre-lab, you must implement at least two of the following three methods of input. The first method will prompt the user for each piece of data about an activity/group individually, the second method will allow the user to input all needed pieces of data about one activity/group on one line, and the third method is to read lines of activity/group data from a data file. The three forms of the input and the input data file are described below. (Just FYI, it is expected that most people will do the first two, but if you already know how to use files, than you are welcome to do that. We will talk about files later in the semester.)
For this pre-lab the user must enter at least 7 activity/groups and no more than 10 activity/groups. Since the user has a choice, then the first piece of data that the program needs from the user is a count of how many activity/groups they are entering. The program should check to make sure this count is between 7 and 10. [Note for development: start with a smaller number of activity/groups then increase to 7 when program is working well ] If the user's number exceeds 10, the program should inform the user that 10 is the maximum number of inputs allowed and have them reenter the count. Then your program must loop for count number of times (index= 0, 1, …count-1) to read and store input in one of the three following ways: Individual data method, line of data input method, or file of lines input method.
Individual data method:
a. Ask the user for the activity/group code (don't forget to supply a list of names and codes for them.) Read in their number, make sure it is a valid code and then store it in the Group/activity number array at [index]
b. Ask the user for the hour that the activity/group meets. Make sure it is a valid number and then store it in the Meeting hour array at [index].
c. For the meeting minutes and meeting week do the same things making sure to check that the input values are meaningful. Store them in the appropriate arrays at [index].
d. For the remaining data values that are letter codes (Meeting half day, Meeting day, Purpose, Activity/group member type), ask the user for the data using the single character descriptions (don't forget to supply a list of abbreviations for them.) Read in their char, make sure it is a valid abbreviation and then store it in the appropriate array at [index]
e. For the remaining data values that are integers ( Activity/group size), ask the user for the data using the code descriptions where appropriate (don't forget to supply a list of codes for them.) Read in their int, make sure it is a valid code, if appropriate, and then store it in the appropriate array at [index]. [Note: checking validity where appropriate means to check the value IF there is something to check against. For meeting hours there is a clock to check against. For group size, there isn't anything to check against for this lab.)
f. Ask the user for the cost of participating in that activity/group. Make sure it is a valid value and then store it in the Group/activity cost array at [index].
Line of data input method:
Your program may ask the user to enter all the information for one activity/group on the same line. This data would be an integer for activity/group code, ints for meeting hour and meeting minute, chars for half day and day of week, an int for week of the month, chars for purpose and member type, an int for size and a float for cost. You must tell the user exactly how to enter the line of data. The data for a single activity/group will be entered by the user as values on one line as follows {there must be one space only between the values}:
> 132 12 0 p M 1 P E 43 15.00
which represents the Society of Women Engineers - SWE (132), meeting at 12:00pm (which is noon), on the 1st Monday of the month. It is a professional organization for engineering students with 43 members and the yearly cost is $15.00.
Your program will read the first number and store it in the activity/group code array at some location index, then read and store the hour int into the corresponding location index in the activity/group meeting hour array, then read and store the third number into location index in the meeting minute array, and so on. Your program should read all the numbers and chars within a single input command. Your program should read in as many lines of input for activity/groups as were originally specified by the count up to the maximum of ten lines of input (activity/groups).
File of lines input method
You may create a file that contains between 7 and 10 lines of activity/group data and you may read the data from this file. To do this will requires creating file variables, opening the file and linking it to the file variable, and then reading the data from the file variable in the same way that a line of data would be read from the screen. The first line of data in the file should have only one integer on it which is the count of the number of lines of activity/group data which follow in the file. (File input may or may not be covered in class prior to this lab's due date so you might have to learn this on your own if you wish to use it in the pre-lab. It will be covered and required for later labs in the class.)
Input verification:
When the user has entered count number of activity/groups, print out all the input
activity/group data in an easily readable form, ex. use a table with headings,
or columns with headings or rows with labels.
It is strongly suggested that this printing be written as a separate function
that can be called at any time in the program to print the current contents of
the arrays. It is also suggested that a
small function be written which will print the name of an activity/group given
the activity/group code as input. The
function could have a switch or a bunch of if statements in it.
+
Create
and display a screen menu of the following choices for the user.
Once all the data is read into the arrays your program should give the user a screen menu with the following choices: (use any number scheme you wish)
i. Search for a type of activity/group by number
ii. Search for a type of activity/group by meeting day
iii. Search for a type of activity/group by purpose
iv. Count how many groups/activities have a specific purpose
v. List all the activity/groups that accept a certain member type
vi. List all the activity/groups that are equal or greater than a certain size
vii. Calculate cost to join all groups/activities
viii. List all the activity/groups
ix. Update the data in the arrays
x. End the program
The search functions should let the user choose the code number or meeting day or purpose code and then look through the list to find the first activity/group that matches that type, then print a sentence stating that matching code/day was or was not found and if found, it should also print the code and the name of the group/activity.
The count function should let the user choose a purpose code and then go through the data and count (#) how many groups/activities have that purpose. The output should be a sentence stating that the number of groups/activities with that purpose is #.
The member type list function should let the user choose a member type (using the codes your program gives them) and then should print all the groups/activities that allow that member type. This one is a little tricky in that some groups are subgroups of others, e.g. if the user chooses type 3 for juniors then any group that accepts U undergrads also accepts juniors and any group that accepts A all students also accepts juniors. Make sure to print a message at the top of the list explaining what is being printed.
The size list functions should let the user choose a size value and then should print all the groups/activities that are of that size or larger. Make sure to print a message at the top of the list explaining what is being printed.
The calculate function simply goes through and sums up all the costs for all the groups/activities. Print this sum with a message.
The list activity/groups function is the same as the print function described for input verification.
The update option should take the user to a second screen to allow them to update information in the arrays. This screen should ask for a activity/group code from the user and search for that activity/group. Once the correct activity/group is determined save its [index] and give the user a menu of the following options:
o Change Meeting hour, minute, half day, day, or week array at [index]
o Change Purpose array at [index]
o Change Member type array at [index]
o Change Size array at [index]
o Change Cost array at [index]
o Return to main menu
For any change the user wishes to make, do the same error checking as in the original data entry section. After each change is made, print all of the activity/group info for the activity/group at [index]. [Hint: If you write your data entry section with little functions for each input check then you can reuse them all here.]
When the user chooses "End the program" from the main menu, print a concluding message and then gracefully end the program.
Implementation
requirements:
WRITE A DESIGN ON PAPER FIRST. The design should include a list of the functions you expect to write with brief (one line) descriptions and a diagram showing what function calls what other functions. This diagram should start with the main function at the top and all others below it. Each function should accomplish one main purpose and each function at a lower level should have a more specific purpose than the function that calls it. This design documentation will not be turned in for the pre-lab but a design will be required to be turned in for Lab 1.
The program should use the following data structures:
One dimensional integer, character, and floating point arrays
Global CONSTANTS for specific and/or maximum values given in this assignment. Constants can be done with
#define or with the const declaration. Examples:
#define GROUPMAX 10
const int GROUPMAX = 10;
The program should use the following control structures:
Function calls to perform tasks
A while or for loop to read the input data
If, if-else, nested ifs, or switches to error check and implement the menu options
The program should NOT use:
structs
multiple dimension arrays
any topic not covered in class before the lab DUE date unless approved by the instructor
The program should be implemented as a set of functions with a main routine and at least one function for menu operations, two for getting input, one for printing, one for a search function, and one for calculating. You may use many more functions than this but you must use at least this many.
The program should perform the following actions in the given order:
Declare and initialize the variables
Print a welcome screen for the user that introduces the system
Get the needed input values from the keyboard
Print the appropriate outputs
Let the user enter additional values until the user indicates that they are finished.
The program should have a program header which gives, at least, your name, the number of the lab assignment, your class and section, the assignment date, the due date, and a description of the program. If multiple files are used, each file should contain a similar header. See your instructor's website for SPECIFIC instructions about the program header.
Each programmer-defined function, i.e. each function you write, should have a function header similar to those used in the examples in the textbook. This header should include at least the function name, the purpose of the function, and its inputs and outputs.
This program must be run with two different sets of test data for the team member constant data. You must create one data set in addition to the one that I will give you and run your program with both of them. You may run it two times within a single execution or you may execute the program two different times so that you have a total of two different data sets. The sample data set that you create must meet the guidelines given in the problem definition.
The program must be run and the output recorded in a script file from OMEGA using the gcc compiler. If you do not know how to create a script file, it is your responsibility to ask the TA, look for help on the class website, or OIT how to use this function.
Programs turned in for credit must compile and run without any compilation errors or runtime errors. Programs may be partially complete but all completed functions must run without any errors. A program has a runtime error if it runs but then crashes in any situation, i.e. if there is any set of choices the user can make that will make the program crash.
Grading scale:
Code: (59%)
Program header and function headers for all
functions (6 points)
Comments (line comments and block comments) (6 points)
Modularity (division of the problem into small
tasks, each one assigned to its own function and called from main() or from
another function when appropriate--do not code the entire program in
main!) (10 points)
Style (indentation, consistency, meaningful
identifiers, lateral separation of code from line comments, etc.) (8 points)
Correct manipulation of the 1-dimensional
arrays (9 points)
Correct use of required control structures (6
points)
Correct function structure as required (6 points)
Proper implementation of data input and input
error checking (8 points)
Output: (41%)
User clearly understands what is being requested for input (5 points)
Search (find) tasks perform
correctly (6 points)
List tasks perform correctly (4
points)
Calculate tasks perform correctly (3
points)
Update tasks perform correctly (6
points)
Input verification shows valid
values and list of inputs correctly saved and printed (4 points)
Output gives clear information to explain the values to the user (8 points)
Output contains all the given test data and one additional data set (5 points)
Grading Deductions:
Use of global variables will
result in an overall grade of 0 (zero)
Use of the exit,
break, or continue command will result in an overall grade of 0 (zero)
Labs which have errors in them and do not terminate normally
will receive an overall grade of 0
(zero)
Use
of structs, multiple dimension arrays, strings, or linked lists will result in 50
(fifty) point deduction per use
Late submission of softcopy of
code and/or script file to appropriate TA will result in an overall grade
of 0 (zero) without prior instructor
approval
Use of C language elements not yet
discussed in class by the lab due date will result in potential deduction of
points - discuss with instructor before using.
Miscellaneous:
Activity/group
code list:
The Big Event = 004
Oozeball = 008
Bed Races = 010
JCEO/ESC = 130
SWE = 132
SHPE = 133
NSBE = 134
TSPE = 135
ACM = 140
GDC = 141
IEEE = 150
IIE = 160
BMESS = 170
BMES = 171
SACNAS = 221
Concert choir = 512
Marching band = 525
Student Senate = 488
FLOC = 490
UTA Volunteers = 491
BSA = 610
FSI = 630
Sample data:
008 6 0 p F 3 S A 120 15.00
132 12 0 p M 1 P E 43 15.00
490 12 0 p W 3 V A 88 0.0