Count Number Of Even And Odd Elements In An Array In C

In this article, you will learn how to efficiently count the number of even and odd elements within an array using the C programming language. This skill is fundamental for various data analysis and manipulation tasks.

Problem Statement

When working with numerical data, a common requirement is to categorize numbers based on certain properties. One such property is parity—whether a number is even or odd. Given an array of integers, the challenge is to determine how many elements are even and how many are odd, providing a clear count for each category. This can be critical in scenarios like data preprocessing, statistical analysis, or algorithm design where distinct handling for even or odd numbers is necessary.

Example

Consider an array [12, 7, 24, 3, 10, 5]. The desired output would be: Number of even elements: 3 (12, 24, 10) Number of odd elements: 3 (7, 3, 5)

Background & Knowledge Prerequisites

To understand and implement the solutions effectively, readers should have a basic understanding of:

• C Language Basics: Variables, data types (especially int), and basic input/output.
• Arrays: How to declare, initialize, and access elements of an array.
• Loops: Specifically, for loops, to iterate through array elements.
• Conditional Statements: if-else statements for decision-making.
• Modulo Operator (%): Understanding its use to find the remainder of a division. An integer n is even if n % 2 == 0 and odd if n % 2 != 0.

Use Cases or Case Studies

Counting even and odd elements in an array is a foundational task with several practical applications:

• Data Validation and Filtering: In datasets, quickly identify and separate records based on numerical parity for further processing or error checking.
• Algorithmic Challenges: Many competitive programming problems involve partitioning arrays or performing operations selectively on even or odd numbers.
• Game Development: In simple games, game logic might depend on whether a randomly generated number is even or odd (e.g., player 1 acts on even turns, player 2 on odd).
• Statistical Analysis: Understanding the distribution of even versus odd numbers in a sample can reveal underlying patterns or biases.
• Resource Allocation: In some specialized systems, tasks might be queued or processed differently based on an identifier's parity.

Solution Approaches

For counting even and odd elements in an array, the most direct and efficient approach involves iterating through the array once and using the modulo operator to check each element's parity.

Approach 1: Simple Iteration with Modulo Operator

This approach involves traversing the array from the beginning to the end, checking each element's remainder when divided by 2.

• One-line summary: Iterate through the array, using the modulo operator to determine if each element is even or odd, and increment respective counters.

// Count Even and Odd Elements
#include <stdio.h>

int main() {
    // Step 1: Declare and initialize an array of integers.
    int numbers[] = {12, 7, 24, 3, 10, 5, 8, 15, 20};
    int size = sizeof(numbers) / sizeof(numbers[0]); // Calculate array size

    // Step 2: Initialize counters for even and odd numbers.
    int even_count = 0;
    int odd_count = 0;

    // Step 3: Iterate through the array elements.
    printf("Array elements: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
        // Step 4: Check if the current element is even or odd using the modulo operator.
        if (numbers[i] % 2 == 0) {
            even_count++; // Increment even counter if remainder is 0
        } else {
            odd_count++;  // Increment odd counter if remainder is not 0
        }
    }
    printf("\\n");

    // Step 5: Print the final counts.
    printf("Number of even elements: %d\\n", even_count);
    printf("Number of odd elements: %d\\n", odd_count);

    return 0;
}

Run

• Sample output:

Array elements: 12 7 24 3 10 5 8 15 20 
Number of even elements: 6
Number of odd elements: 3

• Stepwise explanation:

1. Array and Size Initialization: An integer array numbers is declared and initialized with sample values. The size of the array is calculated using sizeof(numbers) / sizeof(numbers[0]) to make the code flexible for arrays of different sizes.
2. Counter Initialization: Two integer variables, evencount and oddcount, are initialized to 0. These variables will store the total count of even and odd numbers, respectively.
3. Iteration: A for loop is used to iterate through each element of the array, from the first element (index 0) to the last (index size - 1).
4. Parity Check: Inside the loop, for each numbers[i]:
   • The modulo operator (%) is used: numbers[i] % 2. This operation returns the remainder when numbers[i] is divided by 2.

1. Result Output: After the loop completes, evencount and oddcount hold the final tallies, which are then printed to the console.

Conclusion

Counting even and odd elements in an array is a fundamental programming task easily solved using a single pass through the array combined with the modulo operator. This technique is both efficient and straightforward, forming a building block for more complex data processing and analytical challenges in C programming.

Summary

• Problem: Categorize and count numbers in an array as even or odd.
• Key Tool: The modulo operator (%) is central to determining parity.
• Even Check: A number n is even if n % 2 == 0.
• Odd Check: A number n is odd if n % 2 != 0.
• Approach: Iterate through the array once, applying the modulo check to each element and incrementing dedicated counters.
• Efficiency: The solution is efficient as it requires only a single pass (O(n) time complexity) through the array.