Count pairs with Even Product from two given arrays
Last Updated :
02 Oct, 2023
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
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:
- Initialize a variable count to 0 to keep track of the count of pairs with even product.
- Use a nested loop to iterate through all possible pairs of elements in the two arrays.
- Check if the product of the pair is even using the modulo operator (%). If the product is even, increment the count variable.
- After all pairs have been checked, return the count variable as the output.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
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;
}
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));
}
}
# 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))
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
// Function to count pairs from two arrays where the product is even
function countPairs(arr, brr) {
let count = 0;
// Iterate through the first array
for (let i = 0; i < arr.length; i++) {
// Iterate through the second array
for (let j = 0; j < brr.length; j++) {
// Check if the product of elements from both arrays is even
if ((arr[i] * brr[j]) % 2 === 0) {
count++;
}
}
}
return count;
}
// Main function
function main() {
const arr = [1, 2, 3];
const brr = [1, 2];
// Call the countPairs function and display the result
const result = countPairs(arr, brr);
console.log(result);
}
// Call the main function
main();
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 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 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# 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
<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>
Time Complexity: O(N)
Space Complexity: O(1)
Similar Reads
Count Pairs from two arrays with even sum Given two arrays A[] and B[] of N and M integers respectively. The task is to count the number of unordered pairs formed by choosing an element from array A[] and other from array B[] in such a way that their sum is an even number. Note that an element will only be a part of a single pair.Examples:
7 min read
Count pairs whose products exist in array Given an array, count those pair whose product value is present in array. Examples: Input : arr[] = {6, 2, 4, 12, 5, 3}Output : 3 All pairs whose product exist in array (6 , 2) (2, 3) (4, 3) Input : arr[] = {3, 5, 2, 4, 15, 8}Output : 2 A Simple solution is to generate all pairs of given array and c
15+ min read
Find the count of even odd pairs in a given Array Given an array arr[], the task is to find the count even-odd pairs in the array.Examples: Input: arr[] = { 1, 2, 1, 3 } Output: 2 Explanation: The 2 pairs of the form (even, odd) are {2, 1} and {2, 3}. Input: arr[] = { 5, 4, 1, 2, 3} Output: 3 Naive Approach: Run two nested loops to get all the poss
7 min read
Count all possible pairs in given Array with product K Given an integer array arr[] of size N and a positive integer K, the task is to count all the pairs in the array with a product equal to K. Examples: Input: arr[] = {1, 2, 16, 4, 4, 4, 8 }, K=16Output: 5Explanation: Possible pairs are (1, 16), (2, 8), (4, 4), (4, 4), (4, 4) Input: arr[] = {1, 10, 20
11 min read
Count pairs from two sorted arrays whose sum is equal to a given value x Given two sorted arrays of size m and n of distinct elements. Given a value x. The problem is to count all pairs from both arrays whose sum is equal to x. Note: The pair has an element from each array.Examples : Input : arr1[] = {1, 3, 5, 7} arr2[] = {2, 3, 5, 8} x = 10 Output : 2 The pairs are: (5,
15+ min read