C Program To Calculate Average Lowest And Highest Amount Of Rain Rates

Analyzing rainfall data is crucial for understanding weather patterns, managing water resources, and predicting environmental impacts. Accurate measurement and calculation of key metrics can inform critical decisions.

In this article, you will learn how to write C programs to calculate the average, lowest, and highest rainfall rates from a given set of data.

Problem Statement

Meteorological stations, agriculturalists, and environmental researchers frequently need to summarize rainfall data. A common task involves processing a series of recorded rainfall rates to determine the average rate over a period, identify the lowest rate recorded (which might indicate drought conditions or dry spells), and pinpoint the highest rate (suggesting intense storms or potential flooding risks). Automating this calculation ensures efficiency and accuracy in data analysis.

Example

Consider a scenario where the daily rainfall rates (in mm/hour) for a week are: 2.5, 0.0, 5.1, 1.3, 8.2, 0.0, 3.7. The program should output something similar to:

Average Rainfall Rate: 2.97 mm/hour
Lowest Rainfall Rate: 0.00 mm/hour
Highest Rainfall Rate: 8.20 mm/hour

Background & Knowledge Prerequisites

To understand and implement the solutions in this article, you should have a basic understanding of:

• C Data Types: float for decimal numbers, int for whole numbers.
• Variables: Declaring and initializing variables.
• Input/Output Operations: Using printf for output and scanf for input.
• Control Flow: for and while loops for iteration, if statements for conditional logic.
• Arrays: Storing collections of data (used in one approach).
• Arithmetic Operators: Addition, division, comparison.
• Standard Library: stdio.h for standard input/output functions.

Use Cases or Case Studies

Calculating the average, lowest, and highest rainfall rates has numerous practical applications:

• Agricultural Planning: Farmers can use this data to optimize irrigation schedules, predict crop yields, and plan for potential drought or flood conditions.
• Water Resource Management: Water authorities monitor rainfall to manage reservoir levels, predict water availability, and implement conservation strategies.
• Flood Risk Assessment: Identifying peak rainfall rates helps urban planners and emergency services assess flood risks, design drainage systems, and prepare for disaster response.
• Climate Change Studies: Long-term analysis of these metrics contributes to understanding regional climate patterns, detecting trends, and modeling climate change impacts.
• Weather Forecasting: Meteorologists use historical average, min, and max data to refine weather models and improve the accuracy of future rainfall predictions.

Solution Approaches

We will explore two common approaches to calculate these statistics: one using a fixed-size array for a known number of inputs, and another handling an unknown number of inputs using a sentinel value.

Approach 1: Using a Fixed-Size Array

This approach is suitable when you know the exact number of rainfall rates you need to process beforehand. The rates are stored in an array, and then iterated over to find the required statistics.

Summary: Declare an array of a fixed size, prompt the user to enter that many rainfall rates, store them in the array, then iterate through the array to calculate the sum, find the minimum, and find the maximum.

Code Example:

// Rainfall Statistics (Fixed Array)
#include <stdio.h>

int main() {
    // Step 1: Declare variables for rainfall rates, count, sum, min, and max.
    int numRates;
    printf("Enter the number of rainfall rates to process: ");
    scanf("%d", &numRates);

    if (numRates <= 0) {
        printf("Number of rates must be positive.\\n");
        return 1; // Indicate an error
    }

    float rainRates[numRates]; // Dynamically sized array (C99 feature)
    float sum = 0.0f;
    float lowestRate;
    float highestRate;

    // Step 2: Get rainfall rates from the user and initialize min/max with the first value.
    printf("Enter rainfall rate #1 (mm/hour): ");
    scanf("%f", &rainRates[0]);
    sum = rainRates[0];
    lowestRate = rainRates[0];
    highestRate = rainRates[0];

    // Step 3: Loop to get remaining rainfall rates and update sum, min, max.
    for (int i = 1; i < numRates; i++) {
        printf("Enter rainfall rate #%d (mm/hour): ", i + 1);
        scanf("%f", &rainRates[i]);
        sum += rainRates[i];

        if (rainRates[i] < lowestRate) {
            lowestRate = rainRates[i];
        }
        if (rainRates[i] > highestRate) {
            highestRate = rainRates[i];
        }
    }

    // Step 4: Calculate the average.
    float averageRate = sum / numRates;

    // Step 5: Print the results.
    printf("\\n--- Rainfall Statistics ---\\n");
    printf("Average Rainfall Rate: %.2f mm/hour\\n", averageRate);
    printf("Lowest Rainfall Rate: %.2f mm/hour\\n", lowestRate);
    printf("Highest Rainfall Rate: %.2f mm/hour\\n", highestRate);

    return 0;
}

Run

Sample Output:

Enter the number of rainfall rates to process: 5
Enter rainfall rate #1 (mm/hour): 3.2
Enter rainfall rate #2 (mm/hour): 0.5
Enter rainfall rate #3 (mm/hour): 7.8
Enter rainfall rate #4 (mm/hour): 1.1
Enter rainfall rate #5 (mm/hour): 4.0

--- Rainfall Statistics ---
Average Rainfall Rate: 3.32 mm/hour
Lowest Rainfall Rate: 0.50 mm/hour
Highest Rainfall Rate: 7.80 mm/hour

Stepwise Explanation:

1. Get Number of Rates: The program first asks the user for the total number of rainfall rates they intend to enter. An if statement validates this input to ensure it's positive.
2. Declare Array and Variables: A float array rainRates is declared with the user-specified size. Variables sum, lowestRate, and highestRate are initialized. sum starts at 0.0f. For lowestRate and highestRate, they are initialized with the first input value to ensure correct comparison.
3. Process First Rate: The first rainfall rate is read separately. This is crucial for correctly initializing lowestRate and highestRate to a valid data point. The sum is also updated.
4. Loop for Remaining Rates: A for loop then iterates from the second rate up to the numRates. In each iteration:

• It prompts the user for the next rainfall rate.
• The rate is added to sum.
• It compares the current rate with lowestRate and highestRate, updating them if a new minimum or maximum is found.

1. Calculate Average: After the loop, the averageRate is calculated by dividing sum by numRates.
2. Display Results: Finally, the calculated averageRate, lowestRate, and highestRate are printed, formatted to two decimal places.

Approach 2: Handling Unknown Number of Inputs (Sentinel Value)

This method is useful when you don't know in advance how many rainfall rates the user wants to input. The user signals the end of input by entering a special "sentinel" value.

Summary: Use a while loop that continues to prompt for input until a specific sentinel value (e.g., -1) is entered. Keep track of the sum, count, minimum, and maximum as inputs are received.

Code Example:

// Rainfall Statistics (Sentinel Value)
#include <stdio.h>
#include <float.h> // For FLT_MAX and FLT_MIN

int main() {
    // Step 1: Declare variables for sum, count, min, max, and current input.
    float currentRate;
    float sum = 0.0f;
    int count = 0;
    float lowestRate = FLT_MAX; // Initialize with largest possible float value
    float highestRate = FLT_MIN; // Initialize with smallest possible float value

    // Step 2: Prompt for input with instructions for sentinel value.
    printf("Enter rainfall rates (mm/hour). Enter -1 to stop.\\n");

    // Step 3: Loop to get rainfall rates until the sentinel is entered.
    while (1) { // Infinite loop, will break manually
        printf("Enter rate: ");
        scanf("%f", &currentRate);

        if (currentRate == -1) {
            break; // Exit loop if sentinel value is entered
        }

        // Validate positive rain rate, or allow 0 for no rain
        if (currentRate < 0) {
            printf("Rainfall rates cannot be negative. Please enter a valid rate or -1 to stop.\\n");
            continue; // Skip to next iteration without processing invalid input
        }

        // Step 4: Update sum, count, min, and max.
        sum += currentRate;
        count++;

        if (currentRate < lowestRate) {
            lowestRate = currentRate;
        }
        if (currentRate > highestRate) {
            highestRate = currentRate;
        }
    }

    // Step 5: Check if any valid rates were entered before calculating average.
    if (count > 0) {
        float averageRate = sum / count;
        printf("\\n--- Rainfall Statistics ---\\n");
        printf("Average Rainfall Rate: %.2f mm/hour\\n", averageRate);
        printf("Lowest Rainfall Rate: %.2f mm/hour\\n", lowestRate);
        printf("Highest Rainfall Rate: %.2f mm/hour\\n", highestRate);
    } else {
        printf("\\nNo rainfall rates were entered.\\n");
    }

    return 0;
}

Run

Sample Output:

Enter rainfall rates (mm/hour). Enter -1 to stop.
Enter rate: 1.5
Enter rate: 0.0
Enter rate: 6.2
Enter rate: 2.1
Enter rate: -1

--- Rainfall Statistics ---
Average Rainfall Rate: 2.45 mm/hour
Lowest Rainfall Rate: 0.00 mm/hour
Highest Rainfall Rate: 6.20 mm/hour

Stepwise Explanation:

1. Initialize Variables: sum is 0.0f and count is 0. lowestRate is initialized to FLT_MAX (the largest possible float value from float.h) so that any valid input will be smaller. highestRate is initialized to FLT_MIN (the smallest possible float value) so that any valid input will be larger. This ensures the first valid input correctly sets the initial min and max.
2. Prompt for Input: The user is instructed on how to enter data and how to use the sentinel value (-1) to stop.
3. while Loop for Input: An infinite while(1) loop is used.

• Inside the loop, the program prompts for a rainfall rate and reads it.
• Sentinel Check: It immediately checks if the currentRate is -1. If so, break exits the loop.
• Input Validation: It checks if the currentRate is negative (excluding -1 for the sentinel). If it is, an error message is printed, and continue skips the rest of the current loop iteration, prompting for new input.
• Update Statistics: For valid rates, currentRate is added to sum, and count is incremented.
• The currentRate is compared with lowestRate and highestRate, updating them if necessary.

1. Handle No Input: After the loop, an if (count > 0) check ensures that calculations are only performed if at least one valid rainfall rate was entered.
2. Calculate and Display: If count is greater than zero, the average is calculated, and all statistics (average, lowest, highest) are printed, formatted to two decimal places. Otherwise, a message indicating no rates were entered is displayed.

Conclusion

Analyzing rainfall data by calculating its average, lowest, and highest rates provides fundamental insights for various applications. Whether you have a fixed number of data points or an unknown stream of inputs, C programming offers flexible solutions. Both the fixed-array approach and the sentinel-value approach effectively solve this problem, allowing you to choose the method that best fits your data collection scenario.

Summary

• Problem: Calculate average, lowest, and highest rainfall rates from a given dataset.
• Approach 1 (Fixed Array): Suitable for a known number of data points. Stores data in an array and iterates to find statistics.
• Approach 2 (Sentinel Value): Ideal for an unknown number of data points. Uses a special value to signal the end of input, processing data iteratively without storing all of it in an array (unless explicitly needed).
• Key Techniques: Variable initialization (especially for min/max), loops (for, while), conditional statements (if), and basic arithmetic.
• Robustness: Input validation and handling cases with no valid input are important for reliable programs.