C Program To Find The Frequency Of Odd Even Numbers In The Given Matrix

Understanding data distribution within matrices is fundamental in many programming tasks. In this article, you will learn how to write a C program to efficiently count the occurrences of odd and even numbers within a given matrix.

Problem Statement

Matrices, or 2D arrays, are widely used to represent various forms of data, from images to game boards. Often, it's necessary to analyze the characteristics of the numbers stored within them, such as determining the count of odd and even elements. This analysis can provide insights into data patterns or serve as a preliminary step for further processing. The challenge is to systematically visit each element in a matrix and categorize it as either odd or even.

Example

Consider the following 3x3 matrix:

1  2  3
4  5  6
7  8  9

The expected output for this matrix would be:

• Number of Even Elements: 4 (2, 4, 6, 8)
• Number of Odd Elements: 5 (1, 3, 5, 7, 9)

Background & Knowledge Prerequisites

To understand and implement the C program for finding odd and even numbers in a matrix, readers should be familiar with:

• C Language Basics: Fundamental syntax, variable declaration, and data types.
• Arrays: Specifically, how to declare and manipulate two-dimensional arrays (matrices).
• Loops: for loops are essential for iterating through array elements.
• Conditional Statements: if-else constructs for checking conditions.
• Modulo Operator (%): Used to find the remainder of a division, which is crucial for determining odd/even numbers.
• Input/Output Operations: Using printf for displaying output and scanf for taking user input (optional, for dynamic matrices).

Use Cases or Case Studies

Identifying the frequency of odd and even numbers in a matrix has several practical applications:

• Image Processing: Analyzing pixel values in grayscale images, where pixel intensity can be represented by numbers. Counting odd/even pixels might reveal certain image patterns or characteristics.
• Game Development: Representing game boards or maps as matrices. Counting odd/even cells might be useful for pathfinding algorithms or determining symmetrical patterns.
• Data Analysis: In datasets structured as matrices, knowing the distribution of odd and even values can help in preliminary data exploration, anomaly detection, or feature engineering.
• Cryptography: Some simple cryptographic techniques might involve operations based on the parity (odd/even) of numbers within a data block represented as a matrix.
• Numerical Simulations: In simulations where a grid or matrix stores numerical states, checking the distribution of odd/even states can provide insights into system behavior.

Solution Approaches

Iterating Through the Matrix to Count Odd and Even Numbers

This approach involves traversing every element of the 2D array using nested loops and employing the modulo operator to determine if each number is odd or even, incrementing respective counters.

Code Example

// Find Odd/Even Frequency in Matrix
#include <stdio.h>

int main() {
    int rows, cols;

    // Step 1: Get matrix dimensions from the user
    printf("Enter the number of rows: ");
    scanf("%d", &rows);
    printf("Enter the number of columns: ");
    scanf("%d", &cols);

    int matrix[rows][cols]; // Declare matrix based on user input
    int oddCount = 0;
    int evenCount = 0;

    // Step 2: Get matrix elements from the user
    printf("Enter elements of the matrix:\\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("Enter element at matrix[%d][%d]: ", i, j);
            scanf("%d", &matrix[i][j]);
        }
    }

    // Step 3: Iterate through the matrix and count odd/even numbers
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (matrix[i][j] % 2 == 0) {
                evenCount++; // Increment even counter if remainder is 0
            } else {
                oddCount++;  // Increment odd counter otherwise
            }
        }
    }

    // Step 4: Display the results
    printf("\\nMatrix entered:\\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%4d", matrix[i][j]);
        }
        printf("\\n");
    }

    printf("\\nFrequency of Even Numbers: %d\\n", evenCount);
    printf("Frequency of Odd Numbers: %d\\n", oddCount);

    return 0;
}

Run

Sample Output

Enter the number of rows: 3
Enter the number of columns: 3
Enter elements of the matrix:
Enter element at matrix[0][0]: 1
Enter element at matrix[0][1]: 2
Enter element at matrix[0][2]: 3
Enter element at matrix[1][0]: 4
Enter element at matrix[1][1]: 5
Enter element at matrix[1][2]: 6
Enter element at matrix[2][0]: 7
Enter element at matrix[2][1]: 8
Enter element at matrix[2][2]: 9

Matrix entered:
   1   2   3
   4   5   6
   7   8   9

Frequency of Even Numbers: 4
Frequency of Odd Numbers: 5

Stepwise Explanation

1. Include Header: The stdio.h header is included for standard input/output functions like printf and scanf.
2. Declare Variables:
   • rows and cols: Integers to store the dimensions of the matrix.

1. Get Matrix Dimensions: The program prompts the user to enter the number of rows and columns for the matrix.
2. Populate Matrix: Using nested for loops, the program iterates through each cell of the matrix, prompting the user to input an integer value for matrix[i][j].
3. Count Odd/Even:
   • Another set of nested for loops is used to iterate through the matrix again.

1. Display Results: Finally, the program prints the original matrix and the total evenCount and oddCount found.

Conclusion

Determining the frequency of odd and even numbers within a matrix is a straightforward yet fundamental task in C programming. The provided solution demonstrates an efficient way to achieve this using nested loops and the modulo operator. This approach is clear, easy to implement, and suitable for matrices of varying sizes.

Summary

• Matrices are 2D arrays useful for structured data.
• Counting odd/even numbers helps analyze data distribution.
• The modulo operator (%) is key for checking number parity.
• Nested for loops are used to traverse all matrix elements.
• Separate counters track the frequencies of odd and even numbers.
• The logic involves checking if (element % 2 == 0) for even, else it's odd.