Count equal element pairs in the given array - GeeksforGeeks

25 May, 2021
Given an array arr[] of N integers representing the lengths of the gloves, the task is to count the maximum possible pairs of gloves from the given array. Note that a glove can only pair with a same-sized glove and it can only be part of a single pair.
Examples: 
Input: arr[] = {6, 5, 2, 3, 5, 2, 2, 1} Output: 2 (arr[1], arr[4]) and (arr[2], arr[5]) are the only possible pairs.
Input: arr[] = {1, 2, 3, 1, 2} Output: 2 
Simple Approach: Sort the given array so that all the equal elements are adjacent to each other. Now, traverse the array and for every element if it equal to the element next to it then it is a valid pair and skip these two elements. Else the current element doesn’t make a valid pair with any other element and hence only skip the current element.
Below is the implementation of the above approach:  
C++14
Java
Python3
C#
Javascript
// C++ implementation of the approach#include <bits/stdc++.h>using namespace std; // Function to return the maximum// possible pairs of glovesint cntgloves(int arr[], int n){    // To store the required count    int count = 0;     // Sort the original array    sort(arr, arr + n);     for (int i = 0; i < n - 1;) {         // A valid pair is found        if (arr[i] == arr[i + 1]) {            count++;             // Skip the elements of            // the current pair            i = i + 2;        }         // Current elements doesn't make        // a valid pair with any other element        else {            i++;        }    }    return count;} // Driver codeint main(){    int arr[] = { 6, 5, 2, 3, 5, 2, 2, 1 };    int n = sizeof(arr) / sizeof(arr[0]);     // Function call    cout << cntgloves(arr, n);     return 0;}
// Java implementation of the approachimport java.util.*; class GFG {     // Function to return the maximum    // possible pairs of gloves    static int cntgloves(int arr[], int n)    {                 // Sort the original array        Arrays.sort(arr);        int res = 0;        int i = 0;         while (i < n) {                         // take first number            int number = arr[i];            int count = 1;            i++;             // Count all duplicates            while (i < n && arr[i] == number) {                count++;                i++;            }                         // If we spotted number just 2            // times, increment            // result            if (count >= 2) {                res = res + count / 2;            }        }        return res;    }     // Driver code    public static void main(String[] args)    {         int arr[] = {6, 5, 2, 3, 5, 2, 2, 1};        int n = arr.length;         // Function call        System.out.println(cntgloves(arr, n));    }} // This code is contributed by Lakhan murmu
# Python3 implementation of the approach # Function to return the maximum# possible pairs of gloves  def cntgloves(arr, n):     # To store the required count    count = 0     # Sort the original array    arr.sort()    i = 0    while i < (n-1):         # A valid pair is found        if (arr[i] == arr[i + 1]):            count += 1             # Skip the elements of            # the current pair            i = i + 2         # Current elements doesn't make        # a valid pair with any other element        else:            i += 1     return count  # Driver codeif __name__ == "__main__":     arr = [6, 5, 2, 3, 5, 2, 2, 1]    n = len(arr)     # Function call    print(cntgloves(arr, n))     # This code is contributed by AnkitRai01
// C# implementation of the approachusing System; class GFG {     // Function to return the maximum    // possible pairs of gloves    static int cntgloves(int[] arr, int n)    {        // To store the required count        int count = 0;         // Sort the original array        Array.Sort(arr);         for (int i = 0; i < n - 1;) {             // A valid pair is found            if (arr[i] == arr[i + 1]) {                count++;                 // Skip the elements of                // the current pair                i = i + 2;            }             // Current elements doesn't make            // a valid pair with any other element            else {                i++;            }        }        return count;    }     // Driver code    public static void Main(String[] args)    {        int[] arr = { 6, 5, 2, 3, 5, 2, 2, 1 };        int n = arr.Length;         // Function call        Console.WriteLine(cntgloves(arr, n));    }} // This code is contributed by Princi Singh
<script>     // Javascript implementation of the approach     // Function to return the maximum    // possible pairs of gloves    function cntgloves(arr, n)    {                  // Sort the original array        arr.sort();        let res = 0;        let i = 0;          while (i < n) {                          // take first number            let number = arr[i];            let count = 1;            i++;              // Count all duplicates            while (i < n && arr[i] == number) {                count++;                i++;            }                          // If we spotted number just 2            // times, increment            // result            if (count >= 2) {                res = res + Math.floor(count / 2);            }        }        return res;    }          // Driver code         let arr = [6, 5, 2, 3, 5, 2, 2, 1];        let n = arr.length;          // Function call        document.write(cntgloves(arr, n));   // This code is contributed by susmitakundugoaldanga.</script>
2
 
Efficient Approach 1) Create an empty hash table (unordered_map in C++, HashMap in Java, Dictionary in Python) 2) Store frequencies of all elements. 3) Traverse through the hash table. For every element, find its frequency. Increment the result by frequency/2 for every element,
ankthon
princiraj1992
princi singh
lakhanmurmu
ashwinrajrao
susmitakundugoaldanga
Arrays
Hash
Sorting
Arrays
Hash
Sorting
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Stack Data Structure (Introduction and Program)
Top 50 Array Coding Problems for Interviews
Introduction to Arrays
Linear Search
Multidimensional Arrays in Java
Internal Working of HashMap in Java
Hashing | Set 1 (Introduction)
Hashing | Set 3 (Open Addressing)
Hashing | Set 2 (Separate Chaining)
Most frequent element in an array