C Program Take Hours Minutes Seconds And Print It In 24 Hours Standard Format

Time representation is fundamental in many applications, but different contexts require different formats. Often, it's necessary to convert between military (24-hour) time and standard (12-hour AM/PM) time. In this article, you will learn how to create a C program that takes hours, minutes, and seconds as input and displays them in both 24-hour and standard (12-hour AM/PM) formats.

Problem Statement

Users often provide time information in a particular format, but applications might need to display or process it in another. The core problem is accurately converting between the 24-hour clock (where 1 PM is 13:00) and the 12-hour clock (where 1 PM is 01:00 PM), correctly handling special cases like midnight (00:00 in 24-hour, 12:00 AM in 12-hour) and noon (12:00 in 24-hour, 12:00 PM in 12-hour). Ensuring correct validation for time components (hours 0-23, minutes 0-59, seconds 0-59) is also crucial.

Example

Consider the input time 14:35:20. The program should produce an output similar to this:

24-Hour Format: 14:35:20
Standard Format: 02:35:20 PM

Background & Knowledge Prerequisites

To understand and implement the C program effectively, readers should be familiar with the following:

• Basic C syntax: Variables, data types (int, char*).
• Input/Output functions: printf() for printing output and scanf() for reading user input.
• Conditional statements: if, else if, else for logic control and validation.
• Arithmetic operators: Modulo operator (%) and subtraction for time conversions.
• The stdio.h header: Essential for standard input and output operations.

Use Cases or Case Studies

Converting between 24-hour and standard time formats is a common requirement in various scenarios:

• Scheduling and Calendar Applications: Displaying event times in a user's preferred format, whether 24-hour or 12-hour AM/PM.
• Digital Clocks and Timers: Building a clock that can toggle between different display modes based on user settings.
• International Communication: Ensuring clarity when communicating time across regions where different formats are prevalent; often, 24-hour format is preferred for ambiguity reduction.
• Data Logging and System Timestamps: While backend systems often use 24-hour or Unix timestamps for consistency, presenting this data to users typically requires conversion to a more readable standard format.
• User Interface Design: Providing flexibility in how time inputs are accepted and displayed to accommodate diverse user preferences.

Solution Approaches

This section presents a robust approach to take hours, minutes, and seconds as input, validate them, and then display them in both 24-hour and standard 12-hour formats.

Converting Time Formats

This approach outlines a C program that reads hours, minutes, and seconds, performs basic validation, and then calculates and prints the time in both 24-hour and 12-hour AM/PM formats.

// Time Converter (24-hour & Standard)
#include <stdio.h>

int main() {
    int hours, minutes, seconds; // Variables to store input time
    char *am_pm;                 // Pointer to store "AM" or "PM" string
    int display_hour;            // Variable to store hour in 12-hour format

    // Step 1: Prompt user for time input
    printf("Enter time (hours minutes seconds, e.g., 14 35 20): ");
    scanf("%d %d %d", &hours, &minutes, &seconds);

    // Step 2: Validate input
    if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59 || seconds < 0 || seconds > 59) {
        printf("Invalid time input. Hours must be 0-23, minutes 0-59, seconds 0-59.\\n");
        return 1; // Indicate error
    }

    // Step 3: Print time in 24-hour format
    printf("24-Hour Format: %02d:%02d:%02d\\n", hours, minutes, seconds);

    // Step 4: Determine AM/PM and convert hour for 12-hour format
    if (hours < 12) {
        am_pm = "AM";
        display_hour = hours;
        if (display_hour == 0) { // Special case for midnight (00:xx:xx -> 12:xx:xx AM)
            display_hour = 12;
        }
    } else {
        am_pm = "PM";
        display_hour = hours - 12;
        if (display_hour == 0) { // Special case for noon (12:xx:xx -> 12:xx:xx PM)
            display_hour = 12;
        }
    }

    // Step 5: Print time in standard (12-hour) format
    printf("Standard Format: %02d:%02d:%02d %s\\n", display_hour, minutes, seconds, am_pm);

    return 0; // Indicate success
}

Run

Sample Output

Let's test with different time inputs:

Input: 14 35 20

Enter time (hours minutes seconds, e.g., 14 35 20): 14 35 20
24-Hour Format: 14:35:20
Standard Format: 02:35:20 PM

Input: 0 0 0 (Midnight)

Enter time (hours minutes seconds, e.g., 14 35 20): 0 0 0
24-Hour Format: 00:00:00
Standard Format: 12:00:00 AM

Input: 12 30 15 (Noon)

Enter time (hours minutes seconds, e.g., 14 35 20): 12 30 15
24-Hour Format: 12:30:15
Standard Format: 12:30:15 PM

Input: 6 5 55 (Morning)

Enter time (hours minutes seconds, e.g., 14 35 20): 6 5 55
24-Hour Format: 06:05:55
Standard Format: 06:05:55 AM

Stepwise Explanation for Clarity

1. Include Header: The #include line imports the standard input/output library, providing functions like printf and scanf.
2. Declare Variables:

• hours, minutes, seconds: Integer variables to store the time components provided by the user.
• am_pm: A character pointer (char *) to store "AM" or "PM" strings.
• display_hour: An integer to hold the hour value specifically for the 12-hour format after conversion.

1. Get User Input: The program prompts the user to enter hours, minutes, and seconds, then uses scanf() to read these values into the respective integer variables.
2. Validate Input: An if statement checks if the entered hours are within 0-23, minutes are 0-59, and seconds are 0-59. If any input is out of range, an error message is printed, and the program exits.
3. Display 24-Hour Format: printf() is used to display the time directly in 24-hour format. The %02d format specifier ensures that numbers less than 10 are padded with a leading zero (e.g., 5 becomes 05).
4. Convert to 12-Hour Format:

• An if-else block determines if the time is "AM" (hours 0-11) or "PM" (hours 12-23).
• For "AM" times:
• If hours is 0 (midnight), display_hour is set to 12 (12 AM).
• Otherwise, display_hour remains the same as hours.
• For "PM" times:
• If hours is 12 (noon), display_hour is set to 12 (12 PM).
• Otherwise (hours 13-23), 12 is subtracted from hours to get the 12-hour equivalent (e.g., 14 - 12 = 2 PM).

1. Display Standard Format: Finally, printf() is used again to display the display_hour, minutes, seconds, and the am_pm string in the standard 12-hour format.

Conclusion

Converting time between 24-hour and 12-hour formats is a practical programming task that involves careful conditional logic, especially around midnight and noon. The C program presented demonstrates a clear, step-by-step method to handle user input, validate time components, and accurately display the time in both common formats. This foundational logic can be adapted for various applications requiring flexible time representations.

Summary

• The program takes hours, minutes, and seconds as input from the user.
• Input validation ensures that hours are within 0-23, and minutes/seconds are within 0-59.
• The 24-hour format is printed directly using the input values with leading zeros.
• For the 12-hour (standard) format, the program determines "AM" or "PM" based on the hour.
• Hours are converted for the 12-hour display:
• Midnight (00:xx) becomes 12 AM.
• Noon (12:xx) remains 12 PM.
• Hours greater than 12 (e.g., 13:xx) have 12 subtracted (e.g., 01:xx PM).
• Hours less than 12 (e.g., 01:xx to 11:xx) remain as they are for AM.
• The final output presents both the 24-hour and standard time representations.