Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Count pairs with Even Product from two given arrays

  • Difficulty Level : Basic
  • Last Updated : 21 Apr, 2021

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: 4 
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

Naive Approach: The simplest approach to solve this problem is to traverse both the arrays and generate all possible pairs (arr[i], brr[j]) from both the arrays. For every pair, (arr[i], brr[j]), check if their product is an even number or not. If found to be true, then increment the count. Finally, print the count obtained. 



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 <bits/stdc++.h>
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



<script>
 
// JavaScript program for above approach
 
// Function to count pairs (arr[i], brr[j])
// whose product is an even number
function cntPairsletwoArray(arr, brr,
                       N, M)
{
    
    // Stores count of odd
    // numbers in arr[]
    let cntOddArr = 0;
  
    // Stores count of odd
    // numbers in brr[]
    let cntOddBrr = 0;
  
    // Traverse the array, arr[]
    for (let 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 (let 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
 
     let arr = [ 1, 2, 3 ];
    let N = arr.length;
  
    let brr = [ 1, 2 ];
    let M = brr.length;
  
    document.write(cntPairsletwoArray(arr, brr, N, M));
          
</script>
Output: 
4
 
Time Complexity: O(N) 
Space Complexity: O(1)



My Personal Notes
arrow_drop_up
Next

Construct longest possible sequence of unique elements with given LCM
Recommended Articles
Page :
Maximum of even or odd product pairs count from given arrays
16, Dec 20
Minimize sum of product of same-indexed elements of two arrays by reversing a subarray of one of the two arrays
31, May 21
Count Pairs from two arrays with even sum
08, May 19
Count pairs from an array with even product of count of distinct prime factors
22, Feb 21
Count even sum pairs possible by selecting two integers from two given ranges respectively
22, Jan 21
Find prime factors of Z such that Z is product of all even numbers till N that are product of two distinct prime numbers
28, Jun 21
Count number of ordered pairs with Even and Odd Product
01, Nov 18
Count pairs with product of indices equal to the product of elements present at those indices
18, Mar 21
Check if two arrays can be made equal by swapping pairs of one of the arrays
03, Feb 21
Maximize count of pairs whose bitwise XOR is even by replacing such pairs with their Bitwise XOR
22, Feb 21
Count of binary arrays of size N with sum of product of adjacent pairs equal to K
09, Sep 21
Given two arrays count all pairs whose sum is an odd number
26, Apr 19
Count of equal value pairs from given two Arrays such that a[i] equals b[j]
06, Dec 21
Count pairs from two sorted arrays whose sum is equal to a given value x
23, Jun 17
Kth smallest number in array formed by product of any two elements from two arrays
21, Oct 21
Count of even set bits between XOR of two arrays
30, Mar 20
Check if a number has an odd count of odd divisors and even count of even divisors
20, Aug 20
Count pairs from a given array whose product lies in a given range
12, Jul 21
Count unordered pairs (i,j) such that product of a[i] and a[j] is power of two
01, Nov 18
Count pairs from two arrays with difference exceeding K | set 2
02, Nov 20
Count pairs from two arrays having sum equal to K
15, Nov 18
Count pairs from two arrays whose modulo operation yields K
22, Nov 18
Count distinct pairs from two arrays having same sum of digits
23, Nov 18
Count pairs from two arrays with difference exceeding K
29, Oct 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
sohailahmed46khan786
@sohailahmed46khan786
Vote for difficulty
Current difficulty :
Basic





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!