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.

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:

1) Individual Registration

2) Team Registration

3) Running Events

4) 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.

Header Specification

To facilitate grading, include in your header comment which portions of the assignment you have completed. You must complete all portions in order to earn full credit, but partial credit is available for completing some of the steps. The primary steps are as follows:

(1) Processing Individual Registrations

(2) Processing Team Registrations

(3) Processing the running events

(4) Calculating total donations

If your comment is accurate, meaning that you pass the appropriate tests cases corresponding to your choice, you'll earn 10 points. If your comment is roughly accurate, meaning that you sincerely attempted the items you listed, and most of them work minus a tiny bug, then you'll get 5 of these points. If your comment isn't accurate to a reasonable degree, you'll get 0 of these points.

The reason this is here is because it's very important to communicate to others accurately what you've accomplished and what is left to accomplish. This sort of honesty and ability to appraise your own work is a critical skill in a job.

Program Details

Individual Registration Details

There are a 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];

};

           

It is not sufficient to simply have the structures in your program, you must use them store information and process operations for the program.

Though function prototypes will not be provided, it is expected that you follow good programming design and create several functions with well-specified tasks related to the solution of this problem. Make sure to pay very careful attention to parameter passing.

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

Four sets of input and output are provided with the assignment, showing the different portions of the assignment. You should try to complete race01 first, then proceed to race02, and so forth.

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

race02.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 33.75
Josie 60 5 33.75
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

race03.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

race04.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

Answer 1

main.c

/* Included libraries*/

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

/*Constants*/

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

/*Structures*/

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];
};

struct members {
    char name[LENGTH];
    int number;
    int age;
    int event;
    float money;
    float time;
};

/* Function prototypes */

void determineWinner5k (char [], float, char[], float);
void determineWinner10k (char [], float, char[], float);
void calculateTotal (float registration, float teams, float individuals);

int main () {

    /* Variable declarations and initializations.*/

    int i, j, k, t, header_1, header_2, header_3, runner_id;
    int runner_count = 1, team_count = 1, counter = 1;
    float early_registrants = 0, regular_registrants = 0, team_registrants = 0;
    float runner_time, fastest_time_5 = 5000, fastest_time_10 = 5000, fastest_time_42 = 5000, fastest_time_5_team = 5000, fastest_time_10_team = 5000, fastest_time_42_team = 5000;
    char winner_5[LENGTH], winner_10[LENGTH], winner_42[LENGTH];
    char winner_5_team[LENGTH], winner_10_team[LENGTH], winner_42_team[LENGTH];
    char file_name [30], name[LENGTH], team_name[LENGTH], label[5];
    char test_INDV [5], test_TEAM[5];
    float early_registration_cost, regular_registration_cost, team_registration_cost, total_money_from_registration, total_raised_from_teams, total_raised_from_indv_donations, total_team_money[TEAMS];
    float max, max_2, max_3;
    int location, location_2, location_3, start_age, end_age, qualifying_time;

    struct person runner[RUNNERS];
    struct team running_team[TEAMS];

    /* Used to compare data when being read from a file, to allow for data to be assigned to either an individual or team. */

    strcpy(test_INDV, "INDV");
    strcpy(test_TEAM, "TEAM");

    printf("What is the name of the file that you would like to open?\n");
    scanf("%s", &file_name);

    FILE * ifp;
    ifp = fopen(file_name, "r");

    /* Checks to ensure that a valid file is opened.*/

    while (ifp == NULL) {
        printf("Please enter the name of the file.\n");
        scanf("%s", &file_name);
        ifp = fopen (file_name, "r");
    }

    /*Scans in the registration costs, as well as the first header*/

    fscanf(ifp,"%f",&early_registration_cost);
    fscanf(ifp,"%f",&regular_registration_cost);
    fscanf(ifp,"%f",&team_registration_cost);
    fscanf(ifp, "%d", &header_1);

    /* Scans first label. Label is then compared to two previously defined strings (INDV, TEAM) to determine whether this
       data is for an individual or a member of a team. The data is then read in and assigned. */

    for(i=1; i<header_1+1; i++) {
        fscanf(ifp,"%s", &label);
            if (strcmp(test_INDV, label) == 0) {
                fscanf(ifp,"%s", name);
                runner[runner_count].number = runner_count;
                strcpy(runner[runner_count].name, name);
                fscanf(ifp, "%d", &runner[runner_count].age);
                fscanf(ifp, "%d", &runner[runner_count].event);
                fscanf(ifp, "%f", &runner[runner_count].money);

                if (runner[runner_count].event == 42)
                    printf("%s registered for the marathon race! They have been assigned the number %d.", runner[runner_count].name, runner[runner_count].number);
                else
                    printf("%s registered for the %dk race! They have been assigned the number %d.", runner[runner_count].name, runner[runner_count].event, runner[runner_count].number);
                /* The runner counter is incremented after every individual or team member is added. Registration type for each is also incremented to later determine cost.*/
                runner_count++;
                early_registrants++;
            }

            if (strcmp(test_TEAM, label) == 0) {
                fscanf(ifp, "%s", team_name);
                running_team[team_count].nummembers = team_count;
                strcpy(running_team[team_count].name, team_name);
                fscanf(ifp, "%d", &header_2);
                printf("\n%s team registered for the event. They have %d members:\n", running_team[team_count].name, header_2);
                    for(j=1; j<header_2 + 1; j++) {
                        fscanf(ifp,"%s", name);
                        running_team[team_count].members[j].number = runner_count;
                        strcpy(running_team[team_count].members[j].name, name);
                        fscanf(ifp, "%d", &running_team[team_count].members[j].age);
                        fscanf(ifp, "%d", &running_team[team_count].members[j].event);
                        fscanf(ifp, "%f", &running_team[team_count].members[j].money);

                        if (running_team[team_count].members[j].event == 42)
                            printf("%s registered for the marathon race! They have been assigned the number %d.\n", running_team[team_count].members[j].name, running_team[team_count].members[j].number);
                        else
                            printf("%s registered for the %dk race! They have been assigned the number %d.\n", running_team[team_count].members[j].name, running_team[team_count].members[j].event, running_team[team_count].members[j].number);

                        runner_count++;
                        team_registrants++;
                    }
                team_count++;
              }
            printf("\n");
     }

    fscanf(ifp, "%d", &header_3);
    for (i=1; i<header_3 + 1; i++) {
         fscanf(ifp,"%s", name);
                runner[runner_count].number = runner_count;
                strcpy(runner[runner_count].name, name);
                fscanf(ifp, "%d", &runner[runner_count].age);
                fscanf(ifp, "%d", &runner[runner_count].event);
                fscanf(ifp, "%f", &runner[runner_count].money);

                if (runner[runner_count].event == 42)
                   printf("%s registered for the marathon race! They have been assigned the number %d.\n", runner[runner_count].name, runner[runner_count].number);
                else
                printf("%s registered for the %dk race! They have been assigned the number %d.\n", runner[runner_count].name, runner[runner_count].event, runner[runner_count].number);

                runner_count++;
                regular_registrants++;
    }

    /* Scanning in the running times, and then assigning them to each runner.*/

    for (i=1; i < runner_count; i++) {
        fscanf(ifp, "%d", &runner_id);
        fscanf(ifp, "%f", &runner_time);

        if (runner[i].number == runner_id) {
            runner[i].time = runner_time;
            continue;
        }

        else
            for (j=1; j<TEAMS + 1; j++)
                for (k=1; k<TEAMSIZE; k++)
                    if (running_team[j].members[k].number == runner_id)
                        running_team[j].members[k].time = runner_time;
                        continue;
    }

    /* Two loops are run to find out which individuals were the fastest in the 5k for team members and individuals.
       The determineWinner5k function is then called to evaluate the data and make a final determination on the winner.*/

    for (i=1; i<runner_count + 1; i++) {
        if (runner[i].event == 0)
            continue;
        if (runner[i].event == 5)
            if (runner[i].time < fastest_time_5) {
                fastest_time_5 = runner[i].time;
                strcpy(winner_5, runner[i].name);
            }
    }

    for (i=1; i<runner_count+1; i++)
        for (j=0; j<TEAMS; j++)
            for (k=0; k<TEAMSIZE; k++)
                if (running_team[j].members[k].event == 5)
                    if (running_team[j].members[k].time < fastest_time_5_team) {
                        fastest_time_5_team = running_team[j].members[k].time;
                        strcpy(winner_5_team, running_team[j].members[k].name);
                    }

    determineWinner5k (winner_5, fastest_time_5, winner_5_team, fastest_time_5_team);

    /* This section runs two for loops - one for the individuals, and one for the team members.
       It will determine the fastest runner in each group.
       Then, the determineWinner10k function is called to compare each person and declare a winner. */

    for (i=1; i<runner_count + 1; i++) {
        if (runner[i].event == 0)
            continue;
        if (runner[i].event == 10)
            if (runner[i].time < fastest_time_10) {
                fastest_time_10 = runner[i].time;
                strcpy(winner_10, runner[i].name);
            }
    }

    for (i=1; i<runner_count+1; i++)
        for (j=0; j<TEAMS; j++)
            for (k=0; k<TEAMSIZE; k++)
                if (running_team[j].members[k].event == 10)
                    if (running_team[j].members[k].time < fastest_time_10_team) {
                        fastest_time_10_team = running_team[j].members[k].time;
                        strcpy(winner_10_team, running_team[j].members[k].name);
                    }

    determineWinner10k (winner_10, fastest_time_10, winner_10_team, fastest_time_10_team);

    /* This loop scans in the age ranges and qualifying time for the marathon. With each iteration,
       it cycles through the runners and team runners to determine who qualifies.*/

    for (i=0; i<9; i++) {

        fscanf(ifp, "%d", &start_age);
        fscanf(ifp, "%d", &end_age);
        fscanf(ifp, "%d", &qualifying_time);

        for (t=1;t<runner_count+1; t++)
            if (runner[t].event == 42)
                if (runner[t].age >= start_age)
                    if (runner[t].age <= end_age)
                        if (runner[t].time < qualifying_time)
                            printf("%s qualified in the marathon run with a time of %.1f minutes!\n", runner[t].name, runner[t].time);

        for (j=1; j<TEAMS; j++)
            for (k=1; k<TEAMSIZE; k++)
                if (running_team[j].members[k].event == 42)
                    if (running_team[j].members[k].age >= start_age)
                        if (running_team[j].members[k].age <= end_age)
                            if (running_team[j].members[k].time < qualifying_time)
                                printf("%s qualified in the marathon run with a time of %.1f minutes!\n", running_team[j].members[k].name, running_team[j].members[k].time);
    }

    /*Finds which team raised the most money. A new array is initialized to store the
      donation totals for each team. A nested loop is then used to load the total donations
      from each team into the array. The final loop finds which team donated the most money,
      and then the information is printed to the screen.*/

    for (i=0;i<TEAMS;i++)
        total_team_money[i] = 0;

    for (j=1; j<TEAMS; j++)
        for (k=1; k<TEAMSIZE; k++)
            total_team_money[j] += running_team[j].members[k].money;

    for (i=1; i<TEAMS; i++)
        if (total_team_money[i] > max) {
            max = total_team_money[i];
            location = i;
        }

    printf("\nThe %s team raised the most money with a team donation of $%.2f!\n", running_team[location].name, max);

    /* This loop evaluates all team members and prints out the person that raised the most money on each team.*/

   for (i=1; i<TEAMS+1; i++) {
        for (j=1; j<TEAMSIZE+1; j++)
            if (running_team[i].members[j].money > max_2) {
                max_2 = running_team[i].members[j].money;
                location_2 = j;
            }
        printf("%s raised the most money on team %s with a donation of $%.2f!\n", running_team[i].members[location_2].name, running_team[i].name, max_2);
        max_2 = 0;
        if (running_team[i+1].nummembers == 0)
            break;
    }

    /* Finds the individual runner that made the largest donation, then prints the name and the amount to the screen.*/

    for (i=1; i<runner_count + 1; i++) {
        if (runner[i].money > max_3) {
            max_3 = runner[i].money;
            location_3 = i;
        }
        if (runner[i+1].name == NULL)
            break;
    }

    printf("%s raised $%.2f!\n", runner[location_3].name, max_3);

    /* Calculating total raised from individual donations. */

    for (i=1; i<runner_count+1; i++) {
        if (runner[i].money > 0)
            total_raised_from_indv_donations += runner[i].money;
    }

    /* Calculating total raised from team donations.*/

    for (i=1;i<TEAMS;i++) {
        if (total_team_money[i] > 0)
            total_raised_from_teams += total_team_money[i];
    }

    /* Calculates the total amount of money generated from registrations, and then calls the calculateTotal function to give a final amount for all money raised.*/

    total_money_from_registration = (early_registrants*early_registration_cost) + (regular_registrants*regular_registration_cost) + (team_registrants*team_registration_cost);

    calculateTotal(total_money_from_registration, total_raised_from_teams, total_raised_from_indv_donations);

    return 0;

}

/*This function takes in a string, float, string, and a final float. The values represent the names and times of the fastest
individuals in the 5k race from the individuals and teams. This function determines the winner of the 5k race based on those values.*/
void determineWinner5k (char winner_5[], float fastest_time_5, char winner_5_team[], float fastest_time_5_team) {

    if (winner_5 < winner_5_team)
        printf("\n\n5k race: %s had the fastest time with %.1f minutes!\n", winner_5, fastest_time_5);
    else if (winner_5_team < winner_5)
        printf("\n\n5k race: %s had the fastest time with %.1f minutes!\n", winner_5_team, fastest_time_5_team);
    return;
}

/* This function takes in a string, float, string, and a float. These items are previously determined from the results of the 10k.
This function will take in and evaluate these items to make a final determination on the winner of the 10k. */
void determineWinner10k (char winner_10[], float fastest_time_10, char winner_team_10[], float fastest_time_10_team) {

    if (fastest_time_10 < fastest_time_10_team)
        printf("10k race: %s had the fastest time with %.1f minutes!\n", winner_10, fastest_time_10);
    else if (fastest_time_10_team < fastest_time_10)
        printf("10k race: %s had the fastest time with %.1f minutes!\n", winner_team_10, fastest_time_10_team);
    return;
}

/* This function takes in three previously calculated float values, and then sums the floats to generate the total amount of money raised from the charity run.
   The function then prints the results to the screen. */
void calculateTotal (float registration, float teams, float individuals) {

    float total_raised;
    total_raised = (registration + teams+ individuals);
    printf("\nThe runners raised $%.2f for charity!\n", total_raised);
    return;
}

one.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

race02.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 33.75
Josie 60 5 33.75
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

race03.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

race04.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