Open In App

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

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: 
 

Input: A[] = {9, 14, 6, 2, 11}, B[] = {8, 4, 7, 20} 
Output: 4 
{9, 7}, {14, 8}, {6, 4} and {2, 20} are the valid pairs.
Input: A[] = {2, 4, 6}, B[] = {8, 10, 12} 
Output: 3 
 



 

Approach: Count the number of odd and even numbers in both the arrays and the answer to the number of pairs will be min(odd1, odd2) + min(even1, even2) because (odd + odd) = even and (even + even) = even.
Below is the implementation of the above approach: 
 






// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return count of required pairs
int count_pairs(int a[], int b[], int n, int m)
{
 
    // Count of odd and even numbers
    // from both the arrays
    int odd1 = 0, even1 = 0;
    int odd2 = 0, even2 = 0;
 
    // Find the count of odd and
    // even elements in a[]
    for (int i = 0; i < n; i++) {
        if (a[i] % 2 == 1)
            odd1++;
        else
            even1++;
    }
 
    // Find the count of odd and
    // even elements in b[]
    for (int i = 0; i < m; i++) {
        if (b[i] % 2 == 1)
            odd2++;
        else
            even2++;
    }
 
    // Count the number of pairs
    int pairs = min(odd1, odd2) + min(even1, even2);
 
    // Return the number of pairs
    return pairs;
}
 
// Driver code
int main()
{
    int a[] = { 9, 14, 6, 2, 11 };
    int b[] = { 8, 4, 7, 20 };
    int n = sizeof(a) / sizeof(a[0]);
    int m = sizeof(b) / sizeof(b[0]);
    cout << count_pairs(a, b, n, m);
 
    return 0;
}
 





                        























                                    



                                    




                                    




                                    


                                



















// Java implementation of the approach



import java.io.*;



 



class GFG



{


 


// Function to return count of required pairs



static int count_pairs(int a[], int b[], int n, int m)



{


 



    // Count of odd and even numbers




    // from both the arrays




    int odd1 = 0, even1 = 0;




    int odd2 = 0, even2 = 0;



 



    // Find the count of odd and




    // even elements in a[]




    for (int i = 0; i < n; i++) 




    {




        if (a[i] % 2 == 1)




            odd1++;




        else




            even1++;




    }



 



    // Find the count of odd and




    // even elements in b[]




    for (int i = 0; i < m; i++)




    {




        if (b[i] % 2 == 1)




            odd2++;




        else




            even2++;




    }



 



    // Count the number of pairs




    int pairs = Math.min(odd1, odd2) + Math.min(even1, even2);



 



    // Return the number of pairs




    return pairs;



}


 


// Driver code



public static void main (String[] args) 



{



     



    int a[] = { 9, 14, 6, 2, 11 };




    int b[] = { 8, 4, 7, 20 };




    int n = a.length;




    int m = b.length;




    System.out.println (count_pairs(a, b, n, m));



 


}


}


 


// This code is contributes by ajit 


















                        






                        























                                    



                                    




                                    




                                    


                                



















# Python 3 implementation of the approach


 


# Function to return count of required pairs



def count_pairs(a,b,n,m):




     



    # Count of odd and even numbers




    # from both the arrays




     



    odd1 = 0




    even1 = 0




    odd2 = 0




    even2 = 0




     



    # Find the count of odd and




    # even elements in a[]




    for i in range(n):




        if (a[i] % 2 == 1):




            odd1 += 1




        else:




            even1 += 1



 



    # Find the count of odd and




    # even elements in b[]




     



    for i in range(m):




        if (b[i] % 2 == 1):




            odd2 += 1




        else:




            even2 += 1




             



    # Count the number of pairs




    pairs = min(odd1, odd2) + min(even1, even2)




     



    # Return the number of pairs




    return pairs



 


# Driver code



if __name__ == '__main__':




    a = [9, 14, 6, 2, 11]




    b = [8, 4, 7, 20]




    n = len(a)




    m = len(b)




    print(count_pairs(a, b, n, m))



 


# This code is contributed by


# Surendra_Gangwar


















                        






                        























                                    



                                    




                                    




                                    


                                



















// C# implementation of the approach



using System;



 



class GFG



{


 


// Function to return count of required pairs



static int count_pairs(int []a, int []b, int n, int m)



{


 



    // Count of odd and even numbers




    // from both the arrays




    int odd1 = 0, even1 = 0;




    int odd2 = 0, even2 = 0;



 



    // Find the count of odd and




    // even elements in a[]




    for (int i = 0; i < n; i++) 




    {




        if (a[i] % 2 == 1)




            odd1++;




        else




            even1++;




    }



 



    // Find the count of odd and




    // even elements in b[]




    for (int i = 0; i < m; i++)




    {




        if (b[i] % 2 == 1)




            odd2++;




        else




            even2++;




    }



 



    // Count the number of pairs




    int pairs = Math.Min(odd1, odd2) + Math.Min(even1, even2);



 



    // Return the number of pairs




    return pairs;



}


 


// Driver code



public static void Main () 



{



     



    int []a = { 9, 14, 6, 2, 11 };




    int []b = { 8, 4, 7, 20 };




    int n = a.Length;




    int m = b.Length;




    Console.WriteLine (count_pairs(a, b, n, m));



 


}


}


 


// This code is contributes by anuj_67..


















                        






                        























                                    



                                    




                                    




                                    


                                



















<?php


// PHP implementation of the approach 


 


// Function to return count of required pairs 



function count_pairs($a, $b, $n, $m) 



{ 


 



    // Count of odd and even numbers 




    // from both the arrays 




    $odd1 = 0; $even1 = 0; 




    $odd2 = 0; $even2 = 0; 



 



    // Find the count of odd and 




    // even elements in a[] 




    for ($i = 0; $i < $n; $i++)




    { 




        if ($a[$i] % 2 == 1) 




            $odd1++; 




        else




            $even1++; 




    } 



 



    // Find the count of odd and 




    // even elements in b[] 




    for ($i = 0; $i < $m; $i++) 




    { 




        if ($b[$i] % 2 == 1) 




            $odd2++; 




        else




            $even2++; 




    } 



 



    // Count the number of pairs 




    $pairs = min($odd1, $odd2) + min($even1, $even2); 



 



    // Return the number of pairs 




    return $pairs; 



} 


 


// Driver code 



$a = array( 9, 14, 6, 2, 11 ); 




$b = array( 8, 4, 7, 20 ); 




$n = count($a); 




$m = count($b); 



 



echo count_pairs($a, $b, $n, $m); 



 


// This code is contributes by AnkitRai01


?>


















                        






                        























                                    



                                    




                                    




                                    


                                



















<script>


 


// Javascript implementation of the approach


 



    // Function to return count of required pairs




    function count_pairs(a , b , n , m) 




    {



 



        // Count of odd and even numbers




        // from both the arrays




        var odd1 = 0, even1 = 0;




        var odd2 = 0, even2 = 0;



 



        // Find the count of odd and




        // even elements in a




        for (i = 0; i < n; i++) {




            if (a[i] % 2 == 1)




                odd1++;




            else




                even1++;




        }



 



        // Find the count of odd and




        // even elements in b




        for (i = 0; i < m; i++) {




            if (b[i] % 2 == 1)




                odd2++;




            else




                even2++;




        }



 



        // Count the number of pairs




        var pairs = Math.min(odd1, odd2) +




                    Math.min(even1, even2);



 



        // Return the number of pairs




        return pairs;




    }



 



    // Driver code




     


 



        var a = [ 9, 14, 6, 2, 11 ];




        var b = [ 8, 4, 7, 20 ];




        var n = a.length;




        var m = b.length;




        document.write(count_pairs(a, b, n, m));



 


 


// This code contributed by umadevi9616 


 


</script>


















                        






                        








Output: 

4


 


Time Complexity: O(n + m)
Auxiliary Space: O(1)

	

        Article Tags : 
        

            Arrays
DSA
Mathematical
Misc        


	


      

      

          
Recommended Articles

      

      

          
          
1. Count even sum pairs possible by selecting two integers from two given ranges respectively

          
2. Count pairs with Even Product from two given arrays

          
3. Minimize sum of product of same-indexed elements of two arrays by reversing a subarray of one of the two arrays

          
4. Maximum of even or odd product pairs count from given arrays

          
5. Maximize count of pairs whose bitwise XOR is even by replacing such pairs with their Bitwise XOR

          
6. Check if two arrays can be made equal by swapping pairs of one of the arrays

          
7. Count pairs from two arrays having sum equal to K

          
8. Count distinct pairs from two arrays having same sum of digits

          
9. Given two  arrays count all pairs whose sum is an odd number

          
10. Count pairs from two sorted arrays whose sum is equal to a given value x

          
11. Count of possible arrays from prefix-sum and suffix-sum arrays

          
12. Check if a number has an odd count of odd divisors and even count of even divisors

          
13. Count of even set bits between XOR of two arrays

          
14. Count ways to express even number ‘n’ as sum of even integers

          
15. Minimum swaps of same-indexed elements required to make sum of two given arrays even

          
16. Divide array into two arrays with their sum as both odd or both even

          
17. Character pairs from two strings with even sum

          
18. Count pairs from an array with even product of count of distinct prime factors

          
19. Count pairs from two arrays with difference exceeding K | set 2

          
20. Count of equal value pairs from given two Arrays such that a[i] equals b[j]

          
21. Count pairs from two arrays whose modulo operation yields K

          
22. Count of pairs between two arrays such that the sums are distinct

          
23. Maximize count of pairs (i, j) from two arrays having element from first array not exceeding that from second array

          
24. Count pairs from two arrays with difference exceeding K

          
25. Count Pairs with Specific Bit Set in two Arrays