C Program To Determine Which Player Is Winner According To Time

Determining a winner based on elapsed time is a common task in various applications, from sports events to task completion tracking. In this article, you will learn how to write C programs to compare recorded times and declare a winner, handling both simple two-player scenarios and multiple competitors.

Problem Statement

In competitive scenarios, participants often complete a task or course, and their performance is measured by the time taken. The core problem is to programmatically compare these times to identify the participant who completed the task in the shortest amount of time, thus determining the winner. This requires robust comparison logic, especially when dealing with floating-point numbers for time measurements.

Example

Imagine a simple race between two players, Player A and Player B. If Player A finishes in 10.5 seconds and Player B finishes in 12.0 seconds, Player A is the winner. If both finish in 10.5 seconds, it's a tie. The program should be able to process these times and output the correct winner or indicate a tie.

Background & Knowledge Prerequisites

To follow this guide, readers should have a basic understanding of:

• C Data Types: Especially float or double for handling time values with decimal points.
• Input/Output Operations: Using scanf to read input and printf to display results.
• Conditional Statements: if, else if, and else for making decisions based on time comparisons.
• Loops: for or while loops for iterating through multiple players (in the more advanced approach).
• Arrays and Structures: For storing and managing data for multiple players.

Use Cases or Case Studies

Determining a winner by time has diverse applications:

• Sports Competitions: Track and field races, swimming, cycling, or any timed event where the lowest time wins.
• Gaming: Speedruns in video games, competitive puzzle solving, or racing games where the fastest completion time dictates the winner.
• Task Performance: Benchmarking different algorithms or processes, where the one completing a task in the shortest time is deemed most efficient.
• Manufacturing/Logistics: Identifying the most efficient route or process step based on completion time.
• Academic Competitions: Coding challenges or problem-solving contests where submission time might be a tie-breaker or a primary metric.

Solution Approaches

Here, we present two distinct approaches: a basic comparison for a fixed number of players and a more scalable approach for multiple players.

Approach 1: Basic Comparison for Two Players

This approach directly compares the times of two players using simple conditional statements.

• Summary: Reads times for two players and uses if-else if-else to determine who has the lower time or if it's a tie.

// Two-Player Time Comparison
#include <stdio.h>

int main() {
    float player1Time, player2Time;

    // Step 1: Prompt and read time for Player 1
    printf("Enter Player 1's time (in seconds): ");
    scanf("%f", &player1Time);

    // Step 2: Prompt and read time for Player 2
    printf("Enter Player 2's time (in seconds): ");
    scanf("%f", &player2Time);

    // Step 3: Compare times to determine the winner
    if (player1Time < player2Time) {
        printf("Player 1 wins with a time of %.2f seconds!\\n", player1Time);
    } else if (player2Time < player1Time) {
        printf("Player 2 wins with a time of %.2f seconds!\\n", player2Time);
    } else {
        printf("It's a tie! Both players finished in %.2f seconds.\\n", player1Time);
    }

    return 0;
}

Run

• Sample Output:

Enter Player 1's time (in seconds): 10.5
Enter Player 2's time (in seconds): 12.0
Player 1 wins with a time of 10.50 seconds!

Enter Player 1's time (in seconds): 9.8
Enter Player 2's time (in seconds): 9.8
It's a tie! Both players finished in 9.80 seconds.

• Stepwise Explanation:

1. Declare two float variables, player1Time and player2Time, to store the times.
2. Use printf to prompt the user to enter each player's time.
3. Use scanf to read the entered times into the respective variables.
4. An if statement checks if player1Time is less than player2Time. If true, Player 1 wins.
5. An else if statement checks if player2Time is less than player1Time. If true, Player 2 wins.
6. The final else block handles the scenario where neither of the above conditions is met, meaning the times are equal, resulting in a tie.
7. printf displays the appropriate result, formatted to two decimal places for time.

Approach 2: Multiple Players with Dynamic Input

This approach is more flexible, allowing any number of players and determining the winner among them. It uses a loop and a simple search algorithm to find the minimum time.

• Summary: Prompts the user for the number of players, then iteratively reads each player's name and time, keeping track of the minimum time found so far and the corresponding winner.

// Multiple-Player Time Comparison
#include <stdio.h>
#include <string.h> // Required for strcpy

// Structure to hold player name and time
struct Player {
    char name[50];
    float time;
};

int main() {
    int numPlayers, i;

    // Step 1: Get the number of players from the user
    printf("Enter the number of players: ");
    scanf("%d", &numPlayers);

    // Clear the input buffer after scanf for integer
    while (getchar() != '\\n');

    // Step 2: Declare an array of Player structures
    struct Player players[numPlayers]; // C99 feature: Variable Length Array

    // Initialize variables for tracking the winner
    float minTime = -1.0; // Use a value that will always be greater than any valid time
    char winnerName[50];

    // Step 3: Loop through each player to get their data
    for (i = 0; i < numPlayers; i++) {
        printf("\\nEnter details for Player %d:\\n", i + 1);
        printf("Enter player name: ");
        fgets(players[i].name, sizeof(players[i].name), stdin);
        // Remove trailing newline character from fgets
        players[i].name[strcspn(players[i].name, "\\n")] = 0;

        printf("Enter player time (in seconds): ");
        scanf("%f", &players[i].time);
        while (getchar() != '\\n'); // Clear buffer for next fgets

        // Step 4: Compare current player's time with the minimum time found so far
        if (minTime == -1.0 || players[i].time < minTime) {
            minTime = players[i].time;
            strcpy(winnerName, players[i].name);
        }
    }

    // Step 5: Print the winner
    printf("\\n--- Race Results ---\\n");
    if (numPlayers > 0) {
        printf("The winner is %s with a time of %.2f seconds!\\n", winnerName, minTime);
    } else {
        printf("No players entered to determine a winner.\\n");
    }

    return 0;
}

Run

• Sample Output:

Enter the number of players: 3

Enter details for Player 1:
Enter player name: Alice
Enter player time (in seconds): 10.2

Enter details for Player 2:
Enter player name: Bob
Enter player time (in seconds): 10.5

Enter details for Player 3:
Enter player name: Charlie
Enter player time (in seconds): 9.9

--- Race Results ---
The winner is Charlie with a time of 9.90 seconds!

• Stepwise Explanation:

1. Define a struct Player to logically group a player's name (a character array) and time (a float).
2. Prompt the user for the total numPlayers and read this value.
3. Declare a Player array players of size numPlayers (using C99 Variable Length Array feature).
4. Initialize minTime to a sentinel value (e.g., -1.0) and winnerName to an empty string or placeholder. This sentinel ensures the first player's time will always be set as the initial minimum.
5. Loop from i = 0 to numPlayers - 1:

• For each player, prompt for their name using fgets (safer for strings) and time using scanf. getchar() is used after scanf to clear the newline character from the input buffer, preventing issues with fgets. strcspn and setting to 0 removes the newline from fgets output.
• Inside the loop, compare the current player's players[i].time with minTime. If minTime is still its initial sentinel value, or if the current player's time is less than minTime, update minTime and copy the current player's name into winnerName using strcpy.

1. After the loop, print the winnerName and minTime as the final result. An edge case for no players is also handled.

Conclusion

Determining a winner based on time in C programming is a straightforward task, whether for a fixed small number of competitors or a variable larger set. The fundamental logic involves comparing numerical values and identifying the minimum. For simple scenarios, direct if-else statements suffice, while for more complex cases with many participants, using data structures like struct and iteration with loops provides a scalable and robust solution.

Summary

• Problem: Identify the participant with the shortest elapsed time.
• Basic Comparison: For two players, use if-else if-else to compare times directly and declare a winner or a tie.
• Multiple Players: Utilize a struct to combine player names and times.
• Iterative Search: Loop through all players, keeping track of the minimum time encountered so far and the corresponding player's name.
• Input Handling: Be mindful of scanf and fgets interactions, often requiring buffer clearing (getchar()) to prevent unexpected behavior when mixing them for input.