Question

Introduction: Programmers for a Better Tomorrow

Programmers for a Better Tomorrow is an organization dedicated to helping charities, medical societies, and scholarship organizations manage various tasks so that they can focus on making the world a better place!  They have asked you and your classmates to help them develop some new programs to benefit their organizations.

Problem: Run For Charity (charityrun.c)
Charity Runs are a popular way for organizations to raise awareness and get fit at the same time.  However, these events can be tough to organize.  The Princess Half Marathon Weekend, for example, has as many as 40,000 runners raising money and awareness for the Children’s Miracle Network Hospitals.  People can run both 5ks and 10ks and there’s even a children’s race.
After nearly a semester of C programming, you've decided that you'd like to donate your skills to create a program that organizes the typical activities for charity run weekend. In particular, your program will help manage the following:

-Individual Registration
-Team Registration
-Running Events
-Donation Totals

Your program will log the number of teams and individual who are signed up for the different races, process the racing events to see who has the fastest times and track the total amount of money raised by teams and individuals for charity.

Program Details
Individual Registration Details
There are two registration windows: early registration and regular registration.  Prices for registering early and regularly will be given.  Each individual will have a unique number and must be processed separately to record their name, age, running event, and donations raised.  The maximum number of runners for our program will be 10000.  

Team Registration Details
Teams may be created and registered to sign up several participators at once.  Teams may only sign up during early registration, have between 3 and 50 members, and must pay the team registration fee for every member on the team.  Teams should be recorded with their name and number of members.  Each member of the team still needs to be recorded with their name, age, running event, and donations raised.  We can organize at most 200 teams.   

Running Events Details
There will be three running events: a 5k race, a 10k race, and a marathon race.  For each race, your program will receive the running time for each participant in the race.  For the 5k and the 10k you should print the runner with the fastest time.  For the marathon, your program will need to check times against the required qualifying times to see which runners qualify for more marathon races.  These qualifying times vary by age group.

Total Donation Details
After all the races are run we want to recognize the participants who raised the most money for charity.  Print the team that raised the most money for the event along with the amount raised.   Then for each team, print the team member who raised the most money along with the amount raised.  For the individuals, print the top individual who raised the most money along with the amount raised.  Finally, print the total amount raised for the event.  All donations and registration fees will be donated directly to charity.

Implementation Restrictions
You must use the following constants:
   #define TEAMS 200
   #define RUNNERS 10000
   #define LENGTH 20
   #define TEAMSIZE 50
You must use the following structures to store information:          
   struct person {
       char name[LENGTH];  
       int number;                               
       int age;
       int event;   
       float money;
       float time;
   };
   struct team {
       char name[LENGTH];      
       int nummembers;                  
       float money;
       struct person members[TEAMSIZE];
   };

Input Specification
The first line of the file contains the following three values, separated by spaces:  Cost of early registration for individuals (in dollars), Cost of regular registration for individuals (in dollars), and the cost of team registration (in dollars). These will be positive real numbers to two decimal places.  

The second line of the file will contain one positive integer representing the number of early individuals and teams who are registering. Every registration will start with either TEAM or INDV for a team registration or individual registration respectively.

Lines that begin with INDV will be followed by four values, separated by spaces:

The individual’s name, their age, their chosen running event, and the amount of donations they have raised.  The first is a string, the second is a positive integer, the third is an integer from the set {5, 10, 42}, and the fourth is a positive real number.

Lines that begin with TEAM will be followed by two values, separated by spaces: the name of the team and the number of team members (k).  This will be followed by k lines organized the same as the individual registration above.

After early registration completes, normal registration can begin.  This will be represented by one positive integer (m) representing the number of regular registrations.  All teams must use early registration.  This will be followed by m lines each with four values.  These are the same values that are present in individual registration: The team member’s name, their age, their chosen running event, and the amount of donations they have raised.  The first is a string, the second is a positive integer, the third is an integer from the set {5, 10, 42}, and the fourth is a positive real number.

After registration, the running events can occur.  Every registered participant will be listed with their number (assigned as part of registration) and the time it took them to run the race in minutes represented as a real number.

This will be followed by 10 lines of qualifying times based on age groups.  They will be specified:

STARTINGAGE            ENDINGAGE           TIME

where starting age and ending age are integers, and the qualifying time is a real number representing minutes.

Output Specification
For an individual registering for an event print a line of the form:  
X registered for the Y race!  They have been assigned the number Z.
where X is their name and Y is the event they are registering for.  Y is represented by an integer {5, 10, 42} in the input file.  Replace it with “5k” for the first integer, “10k” for the second integer, and “marathon” for the third integer in this print statement.  Z is their unique runner number.  These numbers should start at 1 and count up to a max of 10000.   

For a team registering print a line with one of the form:  
X team registered for the event.  They have Y members:
where X is the team name and Y is their number of members.  Follow this with Y lines of the same form as the individuals: one for each member of the team.

For the 5k race and the 10k race, output a single line of the following form:  
Xk race: Y had the fastest time with Z.Z minutes!
where X is either 5 or 10 respectively, Y represents the name of the fastest runner and Z represents their time.

For the marathon race, print out all the runners who times meet the qualifying times:
X qualified in the marathon run with a time of Y.Y minutes!
where X represents the name of the fastest runner and Y represents their time.

For the team that raised the most money, output a single line of the following form:  
The X team raised the most money with a team donation of $Y.YY!
where X is the team name and Y is the amount they raised.

For each team, print out the person that raised the most with a single line of the following form:
X raised the most money on team Y with a donation of $Z.ZZ!
where X is the person’s name, Y is the team name, and Z is the amount they raised.

For the individual that raised the most money, output a single line of the following form:
X raised $Y.YY!
where X is the person’s name and Y is the amount they raised.

End with the total amount raised by the event:
The runners raised $X.XX for charity!

Sample Input/Output
A set of input and output are provided below. Save the input data as race01.txt to use for the data for the program. The sample provided should match what is printed out in the console when the program is run.

Input  File: (race01.txt)
25.5 35.75 21
7
INDV Emily 30 5 10
INDV Karla 27 10 25.6
INDV Martin 45 5 33.75
TEAM OATS 5
Maria 22 5 15.62
Caleb 41 10 20.5
Michael 30 42 18.75
Lily 33 10 31.15
Charlotte 29 5 25.8
INDV Lucas 23 42 100
INDV Hayley 34 42 27.43
TEAM RAINBOW 3
Lawrence 56 5 33.75
David 55 5 30.15
Josie 60 5 13.79
7
George 50 10 90.3
Evelyn 47 5 15.4
Linus 55 10 22.8
Charlie 40 42 150.75
Lucy 24 10 14.89
Leah 42 5 23.45
Thomas 29 5 10.6
1 40
2 75
3 35
4 30
5 80
6 200
7 82
8 32
9 230
10 213
11 37
12 25
13 33
14 78
15 31
16 82
17 235
18 77
19 36
20 29
18 34 215
35 39 220
40 44 225
45 49 235
50 54 240
55 59 250
60 64 265
65 69 280
70 74 295
75 79 310

Output Sample 4 Console:
Emily registered for the 5k race! They have been assigned the number 1.
Karla registered for the 10k race! They have been assigned the number 2.
Martin registered for the 5k race! They have been assigned the number 3.

OATS team registered for the event. They have 5 members:
Maria registered for the 5k race! They have been assigned the number 4.
Caleb registered for the 10k race! They have been assigned the number 5.
Michael registered for the marathon race! They have been assigned the number 6.
Lily registered for the 10k race! They have been assigned the number 7.
Charlotte registered for the 5k race! They have been assigned the number 8.

Lucas registered for the marathon race! They have been assigned the number 9.
Hayley registered for the marathon race! They have been assigned the number 10.

RAINBOW team registered for the event. They have 3 members:
Lawrence registered for the 5k race! They have been assigned the number 11.
David registered for the 5k race! They have been assigned the number 12.
Josie registered for the 5k race! They have been assigned the number 13.

George registered for the 10k race! They have been assigned the number 14.
Evelyn registered for the 5k race! They have been assigned the number 15.
Linus registered for the 10k race! They have been assigned the number 16.
Charlie registered for the marathon race! They have been assigned the number 17.
Lucy registered for the 10k race! They have been assigned the number 18.
Leah registered for the 5k race! They have been assigned the number 19.
Thomas registered for the 5k race! They have been assigned the number 20.

5k race: David had the fastest time with 25.0 minutes!
10k race: Karla had the fastest time with 75.0 minutes!
Hayley qualified in the marathon run with a time of 213.0 minutes!
Michael qualified in the marathon run with a time of 200.0 minutes!

The OATS team raised the most money with a team donation of $111.82!
Lily raised the most money on team OATS with a donation of $31.15!
Lawrence raised the most money on team RAINBOW with a donation of $33.75!
Charlie raised $150.75!

The runners raised $1260.23 for charity!

Answer 1

charityrun.c

#include <stdio.h>
#include <string.h>

#define TEAMS 200
#define RUNNERS 10000
#define LENGTH 20
#define TEAMSIZE 50
#define NUMAGEGROUPS 10

struct person { // Our person structure to categorize all runners
    char name[LENGTH];
    int number;
    int age;
    int event;
    float money;
    float time;
};

struct team { // Our team structure to categorize all teams
    char name[LENGTH];
    int nummembers;
    float money;
    struct person members[TEAMSIZE];
};

struct agegroups { // Our agegroups structure to categorize all age groups (custom defined)
    int startAge;
    int endAge;
    int qualTime;
};

// FUNCTION PROTOTYPES

void indvReg(struct person * participant, FILE * ifp, float regCost, int * runnerCount);
void teamReg(struct person * participant, struct team * teams, FILE * ifp, float regCost, int * runnerCount, int * teamCount);
void runEvents(struct person * participant, struct team * teams, FILE * ifp, int * runnerCount, struct agegroups * group);

int main() {
    struct person * participant[RUNNERS]; // Declare our participants of type structure person with a limit of RUNNERS
    struct team * teams[TEAMSIZE]; // Declare our teams of type structure team with a limit of TEAMSIZE
    struct agegroups * group[NUMAGEGROUPS]; // Declare our group of type structure with a limit of NUMAGEGROUPS
    float earlyCost, lateCost, teamCost; // Declare some usable floats
    int numReg, numLateReg, i, runnerCount = 0, teamCount = 0; // Declare some usable ints

    char filename[30], regType[4]; // Declare some usable string (character arrays)

    printf("Please input the filename for the race: "); // Prompt the user for the file name to work with
    scanf("%s", &filename); // Scan it in
    FILE * ifp; // Declare a file pointer ifp
    ifp = fopen(filename, "r"); // Open our file

    fscanf(ifp, "%f %f %f", &earlyCost, &lateCost, &teamCost); // Scan the file for the early registration, late registration, and team registration costs
    fscanf(ifp, "%d", &numReg); // Scan the file for how many individuals/teams have registered early

    for(i = 0; i < numReg; i++){ // For each THING registered (INDV or TEAM)
        fscanf(ifp, "%s", &regType); // Scan to see what they registered as
        if(strcmp(regType, "INDV") == 0){ // If they registered as an individual..
            indvReg(participant, ifp, earlyCost, &runnerCount); // Call the indvReg function and pass our participant struct, file pointer, early cost, and address of runnerCount (total number of runners)

        }
        else if(strcmp(regType, "TEAM") == 0){ // If they registered as a team...
            teamReg(participant, teams, ifp, teamCost, &runnerCount, &teamCount); // Call the teamReg function and pass our participant struct, teams struct, file pointer, team cost, address of runnerCount (total number of runners), and address of teamCount (total number of teams)
        }
    }

    printf("\n"); // Newline for tidiness

    fscanf(ifp, "%d", &numLateReg); // Scan to see how many people registered late

    for(i = 0; i < numLateReg; i++){ // For every person (individual) that registered late...
        indvReg(participant, ifp, lateCost, &runnerCount); // Call the indvReg function and pass our participant struct, file pointer, early cost, and address of runnerCount (total number of runners)
    }

    runEvents(participant, teams, ifp, &runnerCount, group); // Call our runEvents function to run our events and pass our participant struct, file pointer, early cost, address of runnerCount (total number of runners), and group struct

    fclose(ifp); // Close our file just to be safe
    return 0; // Return a 0x0 a-ok
}

/*
    Function: indvReg
    Pre-Condition: Should take in participant of type person structure, ifp of type FILE, regCost (cost of registration) of type float, and runnerCount (total number of registered runners) of type int pointer
    Post-Condition: Should return nothing but print when an individual is registered and should add one to the number of registered runners
*/

void indvReg(struct person * participant, FILE * ifp, float regCost, int * runnerCount){ // Individual Registration Function

    char eventName[9]; // Declare a character array (string) to hold our event names
    int counter = *runnerCount; // Declare and Initialize a counter equal to pointer runnerCount (total number of runners) to work with

    if(counter <= RUNNERS){ // While our counter is less than the max number of runners (RUNNERS)

        fscanf(ifp, "%s", &participant[counter].name); // Scan for the runners name and assign it to them
        fscanf(ifp, "%d", &participant[counter].age); // Scan for the runners age and assign it to them
        fscanf(ifp, "%d", &participant[counter].event); // Scan for the runners event type and assign it to them
        fscanf(ifp, "%f", &participant[counter].money); // Scan for the runners donations raised and assign it to them

        if(participant[counter].event == 5){ // If the runner ran the 5k (event type of 5)
            strcpy(eventName, "5k"); // Call and assign their event type "5k"
        }else if(participant[counter].event == 10){ // If the runner the 10k (event type of 10)
            strcpy(eventName, "10k"); // Call and assign their event type "10k"
        }else if(participant[counter].event == 42){ // If the runner ran the marathon (event type of 42)
            strcpy(eventName, "marathon"); // Call and assign their event type "marathon"
        }

        *runnerCount += 1; // Add one to our runner count pointer after we've registered them

        printf("%s registered for the %s race! They have been assigned the number %d.\n", participant[counter].name, eventName, *runnerCount); // Print out who was registered, for what race, and what number they were assigned

    }
    else{ // If the number of registered runners is greater than 10,000
        printf("We can only have at most 10,000 runners, sorry!\n"); // Give them a nice little error
    }

}

/*
    Function: teamReg
    Pre-Condition: Should take in participant of type person structure, teams of type team structure, ifp of type FILE, regCost (cost of registration) of type float, runnerCount (total number of registered runners) of type int pointer, and teamCount (total number of registered teams) of type int pointer
    Post-Condition: Should return nothing but print when a team is registered, should register each runner in each team, and should add one to the number of registered teams
*/

void teamReg(struct person * participant, struct team * teams, FILE * ifp, float regCost, int * runnerCount, int * teamCount){ // Team Registration Function

    char teamName[LENGTH]; // Declare a character array (string) to hold our teamName with max length of LENGTH
    int numMembers, i; // Declare two integers to use

    if(*teamCount <= TEAMS){ // If the number of teams registered is less than our max (TEAMS)
        fscanf(ifp, "%s", &teamName); // Scan for our team name
        fscanf(ifp, "%d", &numMembers); // Scan for our number of members for the team

        for(i = 0; i < *teamCount; i++){ // For i is less than the number of teams
            strcpy(teams[i].name, teamName); // Assign each team their team name
            teams[i].nummembers = numMembers; // Assign each team their number of members
        }

        printf("\n"); // Newline for tidiness
        printf("%s team registered for the event. They have %d members:", teamName, numMembers); // Print that we've registered the team
        printf("\n"); // Newline for tidiness

        for(i = 0; i < numMembers; i++){ // For i < the number of members in the team
            indvReg(participant, ifp, regCost, runnerCount); // Call indvReg to register each teammate
        }

        *teamCount += 1; // Add one to our team count pointer
        printf("\n"); // Newline for tidiness

    }
    else{ // Else, if the number of teams is greater than 200
        printf("We can only have at most 200 teams registered, sorry!\n"); // Give them a nice little error
    }
}

/*
    Function: teamReg
    Pre-Condition: Should take in participant of type person structure, teams of type team structure, ifp of type FILE, regCost (cost of registration) of type float, runnerCount (total number of registered runners) of type int pointer, and group of type structure agegroup containing all age groups and qualifying times
    Post-Condition: Should return nothing but assign each runner their event time, start with a random "lowest event time" for each event, grab every age group and its qualifying time, see who got the lowest time in each event, print out who qualified for their marathons, and print who got the lowest event times in each event
*/

void runEvents(struct person * participant, struct team * teams, FILE * ifp, int * runnerCount, struct agegroups * group){ // Run Events Function

    int i, j, runnerNum, eventTime; // Declare some integers
    float short5k, short10k; // Declare some floats
    char winner5k[20], winner10k[20]; // Declare two strings

    // Assign the time everyone got for their event
    for(i = 0; i < *runnerCount; i++){ // For i is less than the number of total runners
        fscanf(ifp, "%d %d", &runnerNum, &eventTime); // Scan for each runner's number and their event time
        participant[i].time = eventTime; // Assign event times by runner's number
    }

    //Make sure that we have a number to start off our lowest time comparison
    for(i = 0; i < *runnerCount; i++){ // For i is less than the number of runners
        if(participant[i].event == 5){ // If the person ran a 5k
            short5k = participant[i].time; // Assign the shortest 5k time to them
        }
        else if(participant[i].event == 10){ // If the person ran a 10k
            short10k = participant[i].time; // Assign the shortests 10k time to them
        }
    }

    // Get every age group and their qualifying times
    for(i = 0; i < NUMAGEGROUPS; i++){ // For i is less than the number of age groups (NUMAGEGROUPS defined by the instructions as 10)
        fscanf(ifp,"%d %d %d", &group[i].startAge, &group[i].endAge, &group[i].qualTime); // Scan for the age group's starting age, ending age, and qualifying time
    }

    printf("\n"); // Newline for tidiness

    //See who got the lowest time in every event
    for(i = 0; i < *runnerCount; i++){ // For i is less than the number of runners
        if(participant[i].event == 5){ // If the person ran a 5k
            if(participant[i].time < short5k){ // If the person's 5k time is shorter than the shortest 5k time
                short5k = participant[i].time; // Make their time the new shortest 5k time
                strcpy(winner5k, participant[i].name); // Assign their name to the winner
            }
        }
        else if(participant[i].event == 10){ // If the person ran a 10k
            if(participant[i].time < short10k){ // If the person's 10k time is shorter than the shortest 10k time
                short10k = participant[i].time; // Make their time the new shortest 10k time
                strcpy(winner10k, participant[i].name); // Assign their name to the winner
            }
        }
        else if(participant[i].event == 42){ // If the person ran a marathon
            for(j = 0; j < NUMAGEGROUPS; j++){ // For j is less than the number of age groups (10)
                if((participant[i].age >= group[j].startAge) && (participant[i].age <= group[j].endAge)){ // Find which age group the person is
                    if(participant[i].time <= group[j].qualTime){ // If they qualified...
                        printf("%s qualified in the marathon run with a time of %.1f minutes!\n", participant[i].name, participant[i].time); // Say that they qualified
                    }
                }
            }
        }
    }

    printf("5k race: %s had the fastest time with %.1f minutes!\n", winner5k, short5k); // Print who got the shortest 5k time and what that time was
    printf("10k race: %s had the fastest time with %.1f minutes!\n", winner10k, short10k); // Print who got the shortest 10k time and what that time was

}

race01.txt

25.5 35.75 21
5
INDV Emily 30 5 10
INDV Karla 27 10 25.6
INDV Martin 45 5 33.75
INDV Lucas 23 42 100
INDV Hayley 34 42 27.43
7
George 50 10 90.3
Evelyn 47 5 15.4
Linus 55 10 22.8
Charlie 40 42 150.75
Lucy 24 10 14.89
Leah 42 5 23.45
Thomas 29 5 10.6