GeeksforGeeks App
Open App
Browser
Continue

# Count pairs with Even Product from two given arrays

Given two arrays, arr[] and brr[] of size N and M respectively, the task is to find the count of pairs (arr[i], brr[j]) such that the product of elements of the pairs is an even number.

Examples:

Input: arr[] = { 1, 2, 3 }, brr[] = { 1, 2 }
Output:
Explanation:
Pairs with even product are: { (arr[0], brr[1]), (arr[1], brr[0]), (arr[1], brr[1]), (arr[2], brr[1]) }.
Therefore, the required output is 4.

Input: arr[] = { 3, 2, 1, 4, 4}, brr[] = { 1, 4, 2, 3, 1 }
Output: 19

Brute Force Approach:

The brute force approach to solve this problem is to use nested loops to iterate through all possible pairs of elements in the two arrays and check if the product of the pair is even. If the product is even, increment the count of such pairs.

The steps involved in the brute force approach are:

1. Initialize a variable count to 0 to keep track of the count of pairs with even product.
2. Use a nested loop to iterate through all possible pairs of elements in the two arrays.
3. Check if the product of the pair is even using the modulo operator (%). If the product is even, increment the count variable.
4. After all pairs have been checked, return the count variable as the output.

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `int` `countPairs(``int` `arr[], ``int` `n, ``int` `brr[], ``int` `m) {``    ``int` `count = 0;` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``for` `(``int` `j = 0; j < m; j++) {``            ``if` `((arr[i] * brr[j]) % 2 == 0)``                ``count++;``        ``}``    ``}` `    ``return` `count;``}` `int` `main() {``    ``int` `arr[] = {1, 2, 3};``    ``int` `brr[] = {1, 2};``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``int` `m = ``sizeof``(brr) / ``sizeof``(brr[0]);` `    ``cout << countPairs(arr, n, brr, m) << endl;` `    ``return` `0;``}`

## Java

 `import` `java.util.*;` `class` `Main {``  ``public` `static` `int` `countPairs(``int``[] arr, ``int` `n, ``int``[] brr, ``int` `m) {``    ``int` `count = ``0``;``    ``for` `(``int` `i = ``0``; i < n; i++) {``      ``for` `(``int` `j = ``0``; j < m; j++) {``        ``if` `((arr[i] * brr[j]) % ``2` `== ``0``)``          ``count++;``      ``}``    ``}``    ``return` `count;``  ``}` `  ``public` `static` `void` `main(String[] args) {``    ``int``[] arr = {``1``, ``2``, ``3``};``    ``int``[] brr = {``1``, ``2``};``    ``int` `n = arr.length;``    ``int` `m = brr.length;` `    ``System.out.println(countPairs(arr, n, brr, m));``  ``}``}`

## Python3

 `# This function takes two arrays of integers and their sizes as input``def` `count_pairs(arr, n, brr, m):``    ``count ``=` `0` `    ``# Traverse both arrays and check if the product of the current elements``    ``# is even, increment count if true``    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(m):``            ``if` `(arr[i] ``*` `brr[j]) ``%` `2` `=``=` `0``:``                ``count ``+``=` `1` `    ``return` `count` `# Driver program``arr ``=` `[``1``, ``2``, ``3``]``brr ``=` `[``1``, ``2``]``n ``=` `len``(arr)``m ``=` `len``(brr)` `print``(count_pairs(arr, n, brr, m))`

## C#

 `using` `System;` `class` `Program``{``    ``static` `int` `CountPairs(``int``[] arr, ``int` `n, ``int``[] brr, ``int` `m)``    ``{``        ``int` `count = 0;` `        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``for` `(``int` `j = 0; j < m; j++)``            ``{``                ``if` `((arr[i] * brr[j]) % 2 == 0)``                ``{``                    ``count++;``                ``}``            ``}``        ``}` `        ``return` `count;``    ``}` `    ``static` `void` `Main(``string``[] args)``    ``{``        ``int``[] arr = { 1, 2, 3 };``        ``int``[] brr = { 1, 2 };``        ``int` `n = arr.Length;``        ``int` `m = brr.Length;` `        ``Console.WriteLine(CountPairs(arr, n, brr, m));``    ``}``}``// This code is contributed by Prajwal Kandekar`

Output

`4`

Time Complexity: O(N*M)
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized based on the following properties of product of two numbers:

Odd * Odd = Odd
Even * Odd = Even
Even * Even = Even

Follow the steps below to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Function to count pairs (arr[i], brr[j])``// whose product is an even number``int` `cntPairsInTwoArray(``int` `arr[], ``int` `brr[],``                       ``int` `N, ``int` `M)``{``    ``// Stores count of odd``    ``// numbers in arr[]``    ``int` `cntOddArr = 0;` `    ``// Stores count of odd``    ``// numbers in brr[]``    ``int` `cntOddBrr = 0;` `    ``// Traverse the array, arr[]``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// If arr[i] is``        ``// an odd number``        ``if` `(arr[i] & 1) {` `            ``// Update cntOddArr``            ``cntOddArr += 1;``        ``}``    ``}` `    ``// Traverse the array, brr[]``    ``for` `(``int` `i = 0; i < M; i++) {` `        ``// If brr[i] is``        ``// an odd number``        ``if` `(brr[i] & 1) {` `            ``// Update cntOddArr``            ``cntOddBrr += 1;``        ``}``    ``}` `    ``// Return pairs whose product``    ``// is an even number``    ``return` `(N * M) - (cntOddArr * cntOddBrr);``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 2, 3 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `brr[] = { 1, 2 };``    ``int` `M = ``sizeof``(brr) / ``sizeof``(brr[0]);` `    ``cout << cntPairsInTwoArray(arr, brr, N, M);` `    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;` `class` `GFG{` `// Function to count pairs (arr[i], brr[j])``// whose product is an even number``static` `int` `cntPairsInTwoArray(``int` `arr[], ``int` `brr[],``                       ``int` `N, ``int` `M)``{``  ` `    ``// Stores count of odd``    ``// numbers in arr[]``    ``int` `cntOddArr = ``0``;` `    ``// Stores count of odd``    ``// numbers in brr[]``    ``int` `cntOddBrr = ``0``;` `    ``// Traverse the array, arr[]``    ``for` `(``int` `i = ``0``; i < N; i++) {` `        ``// If arr[i] is``        ``// an odd number``        ``if` `(arr[i] % ``2` `== ``1``) {` `            ``// Update cntOddArr``            ``cntOddArr += ``1``;``        ``}``    ``}` `    ``// Traverse the array, brr[]``    ``for` `(``int` `i = ``0``; i < M; i++) {` `        ``// If brr[i] is``        ``// an odd number``        ``if` `(brr[i] % ``2` `== ``1``) {` `            ``// Update cntOddArr``            ``cntOddBrr += ``1``;``        ``}``    ``}` `    ``// Return pairs whose product``    ``// is an even number``    ``return` `(N * M) - (cntOddArr * cntOddBrr);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``1``, ``2``, ``3` `};``    ``int` `N = arr.length;` `    ``int` `brr[] = { ``1``, ``2` `};``    ``int` `M = brr.length;` `    ``System.out.print(cntPairsInTwoArray(arr, brr, N, M));` `}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to count pairs (arr[i], brr[j])``# whose product is an even number``def` `cntPairsInTwoArray(arr, brr, N, M):``    ` `    ``# Stores count of odd``    ``# numbers in arr[]``    ``cntOddArr ``=` `0` `    ``# Stores count of odd``    ``# numbers in brr[]``    ``cntOddBrr ``=` `0` `    ``# Traverse the array, arr[]``    ``for` `i ``in` `range``(N):` `        ``# If arr[i] is``        ``# an odd number``        ``if` `(arr[i] & ``1``):` `            ``# Update cntOddArr``            ``cntOddArr ``+``=` `1` `    ``# Traverse the array, brr[]``    ``for` `i ``in` `range``(M):` `        ``# If brr[i] is``        ``# an odd number``        ``if` `(brr[i] & ``1``):` `            ``# Update cntOddArr``            ``cntOddBrr ``+``=` `1` `    ``# Return pairs whose product``    ``# is an even number``    ``return` `(N ``*` `M) ``-` `(cntOddArr ``*` `cntOddBrr)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``1``, ``2``, ``3` `]``    ``N ``=` `len``(arr)` `    ``brr ``=` `[ ``1``, ``2` `]``    ``M ``=` `len``(brr)` `    ``print``(cntPairsInTwoArray(arr, brr, N, M))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program to implement``// the above approach ``using` `System;``   ` `class` `GFG{``   ` `// Function to count pairs (arr[i], brr[j])``// whose product is an even number``static` `int` `cntPairsInTwoArray(``int``[] arr, ``int``[] brr,``                              ``int` `N, ``int` `M)``{``    ` `    ``// Stores count of odd``    ``// numbers in arr[]``    ``int` `cntOddArr = 0;`` ` `    ``// Stores count of odd``    ``// numbers in brr[]``    ``int` `cntOddBrr = 0;`` ` `    ``// Traverse the array, arr[]``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ` `        ``// If arr[i] is``        ``// an odd number``        ``if` `(arr[i] % 2 == 1)``        ``{``            ` `            ``// Update cntOddArr``            ``cntOddArr += 1;``        ``}``    ``}`` ` `    ``// Traverse the array, brr[]``    ``for``(``int` `i = 0; i < M; i++)``    ``{``        ` `        ``// If brr[i] is``        ``// an odd number``        ``if` `(brr[i] % 2 == 1)``        ``{``            ` `            ``// Update cntOddArr``            ``cntOddBrr += 1;``        ``}``    ``}`` ` `    ``// Return pairs whose product``    ``// is an even number``    ``return` `(N * M) - (cntOddArr * cntOddBrr);``}``   ` `// Driver Code``public` `static` `void` `Main()``{``    ``int``[] arr = { 1, 2, 3 };``    ``int` `N = arr.Length;`` ` `    ``int``[] brr = { 1, 2 };``    ``int` `M = brr.Length;`` ` `    ``Console.Write(cntPairsInTwoArray(``        ``arr, brr, N, M));``}``}` `// This code is contributed by code_hunt`

## Javascript

 ``

Output

`4`

Time Complexity: O(N)
Space Complexity: O(1)

My Personal Notes arrow_drop_up