Open In App

Count pairs of equal array elements remaining after every removal

Improve
Improve
Like Article
Like
Save
Share
Report

Given an array arr[] of size N, the task for every array element arr[i], is to count the number of pairs of equal elements that can be obtained by removing arr[i] from the array.

Examples:

Input: arr[] = { 1, 1, 1, 2 } 
Output: 1 1 1 3 
Explanation: 
Removing arr[0] from the array modifies arr[] to { 1, 1, 2 } and count of pairs of equal elements = 1 
Removing arr[1] from the array modifies arr[] to { 1, 1, 2 } and count of pairs of equal elements = 1 
Removing arr[2] from the array modifies arr[] to { 1, 1, 2 } and count of pairs of equal elements = 1 
Removing arr[3] from the array modifies arr[] to { 1, 1, 1 } and count of pairs of equal elements = 3 
Therefore, the required output is 1 1 1 3.

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

Brute Force Approach:

A brute force approach to solve this problem would be to iterate through each element in the array, remove it, and then count the number of pairs of equal elements in the modified array. This can be done using a nested loop. The outer loop iterates through each element of the array, and the inner loop iterates through the remaining elements to count the number of pairs of equal elements. 

Below is the implementation of the above approach:

C++




#include <bits/stdc++.h>
using namespace std;
 
// Function to count pairs of equal elements
// by removing arr[i] from the array
void pairs_after_removing(int arr[], int N)
{
    for (int i = 0; i < N; i++) {
        int count = 0;
        // Create a modified array by removing arr[i]
        int modified[N-1];
        int index = 0;
        for (int j = 0; j < N; j++) {
            if (j != i) {
                modified[index++] = arr[j];
            }
        }
        // Count the number of pairs of equal elements in the modified array
        for (int j = 0; j < N-1; j++) {
            for (int k = j+1; k < N-1; k++) {
                if (modified[j] == modified[k]) {
                    count++;
                }
            }
        }
        cout << count << " ";
    }
}
 
// Driver Code
int main()
{
    // Given Array
    int arr[] = { 2, 3, 4, 3, 2 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    pairs_after_removing(arr, N);
 
    return 0;
}


Java




import java.util.Arrays;
 
public class Main {
 
    // Function to count pairs of equal elements
    // by removing arr[i] from the array
    static void pairs_after_removing(int arr[], int N) {
        for (int i = 0; i < N; i++) {
            int count = 0;
            // Create a modified array by removing arr[i]
            int modified[] = new int[N - 1];
            int index = 0;
            for (int j = 0; j < N; j++) {
                if (j != i) {
                    modified[index++] = arr[j];
                }
            }
            // Count the number of pairs of equal elements in the modified array
            for (int j = 0; j < N - 1; j++) {
                for (int k = j + 1; k < N - 1; k++) {
                    if (modified[j] == modified[k]) {
                        count++;
                    }
                }
            }
            System.out.print(count + " ");
        }
    }
 
    // Driver Code
    public static void main(String[] args) {
        // Given Array
        int arr[] = { 2, 3, 4, 3, 2 };
        int N = arr.length;
 
        pairs_after_removing(arr, N);
    }
}
 
// This code is contributed by Prajwal Kandekar


Python3




# Function to count pairs of equal elements
# by removing arr[i] from the array
def pairs_after_removing(arr, N):
    for i in range(N):
        count = 0
        # Create a modified array by removing arr[i]
        modified = [arr[j] for j in range(N) if j != i]
        # Count the number of pairs of equal elements in the modified array
        for j in range(N - 1):
            for k in range(j + 1, N - 1):
                if modified[j] == modified[k]:
                    count += 1
        print(count, end=" ")
 
# Driver Code
if __name__ == "__main__":
    # Given Array
    arr = [2, 3, 4, 3, 2]
    N = len(arr)
 
    pairs_after_removing(arr, N)


C#




// C# code for above approach
using System;
 
public class GFG {
     
    // Function to count pairs of equal elements
    // by removing arr[i] from the array
    static void pairs_after_removing(int[] arr, int N) {
        for (int i = 0; i < N; i++) {
            int count = 0;
            // Create a modified array by removing arr[i]
            int[] modified = new int[N - 1];
            int index = 0;
            for (int j = 0; j < N; j++) {
                if (j != i) {
                    modified[index++] = arr[j];
                }
            }
            // Count the number of pairs of equal elements in the modified array
            for (int j = 0; j < N - 1; j++) {
                for (int k = j + 1; k < N - 1; k++) {
                    if (modified[j] == modified[k]) {
                        count++;
                    }
                }
            }
            Console.Write(count + " ");
        }
    }
 
    // Driver Code
    public static void Main(string[] args) {
        // Given Array
        int[] arr = { 2, 3, 4, 3, 2 };
        int N = arr.Length;
 
        pairs_after_removing(arr, N);
    }
}
 
// This code is contributed by Utkarsh.


Javascript




// Function to count pairs of equal elements
// by removing arr[i] from the array
function pairs_after_removing(arr) {
  const N = arr.length;
  for (let i = 0; i < N; i++) {
    let count = 0;
    // Create a modified array by removing arr[i]
    const modified = arr.filter((_, index) => index !== i);
    // Count the number of pairs of equal elements in the modified array
    for (let j = 0; j < N - 1; j++) {
      for (let k = j + 1; k < N - 1; k++) {
        if (modified[j] === modified[k]) {
          count++;
        }
      }
    }
    process.stdout.write(count + " ");
  }
}
 
// Driver Code
function main() {
  // Given Array
  const arr = [2, 3, 4, 3, 2];
 
  pairs_after_removing(arr);
}
 
main();


Output

1 1 2 1 1 


Time Complexity: O(N^3), where N is the size of the input array. 

Auxiliary Space: O(N^2), where N is the size of the input array. This is because the modified array created in the inner loop has a maximum size of N-1, and we create N-1 modified arrays. Therefore, the total space required is (N-1) * (N-1) = N^2 – 2N + 1, which is O(N^2) asymptotically.

Efficient Approach: Follow the steps below to solve the problem:

  • Initialize a map, say mp, to store the frequency of each distinct element of the array.
  • Initialize a variable, say cntPairs, to store the total count of pairs of equal array elements.
  • Traverse the map and store the total count of pairs of equal elements by incrementing the value of cntPairs by (mp[i] * (mp[i] – 1)) / 2.
  • Finally, traverse the array. For every ith element, print the value of (cntPairs – mp[i] + 1), which denotes the count of pairs of equal array elements by removing arr[i] from the array.

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 of equal elements
// by removing arr[i] from the array
void pairs_after_removing(int arr[], int N)
{
    // Stores total count of
    // pairs of equal elements
    int cntPairs = 0;
 
    // Store frequency of each
    // distinct array element
    unordered_map<int, int> mp;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Update frequency of arr[i]
        mp[arr[i]]++;
    }
 
    // Traverse the map
    for (auto element : mp) {
 
        // Stores key of an element
        int i = element.first;
        cntPairs += mp[i] * (mp[i] - 1) / 2;
    }
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Stores count of pairs of equal
        // element by removing arr[i]
        int pairs_after_arr_i_removed
            = cntPairs + 1 - mp[arr[i]];
 
        cout << pairs_after_arr_i_removed << ' ';
    }
    return;
}
 
// Driver Code
int main()
{
    // Given Array
    int arr[] = { 2, 3, 4, 3, 2 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    pairs_after_removing(arr, N);
 
    return 0;
}


Java




// Java program to implement
// the above approach
import java.util.*;
  
class GFG{
  
// Function to count pairs of equal elements
// by removing arr[i] from the array
static void pairs_after_removing(int arr[], int N)
{
     
    // Stores total count of
    // pairs of equal elements
    int cntPairs = 0;
  
    // Store frequency of each
    // distinct array element
    Map<Integer,
        Integer> mp = new HashMap<Integer,
                                  Integer>();
  
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
         
        // Update frequency of arr[i]
        mp.put(arr[i], mp.getOrDefault(arr[i], 0) + 1);
    }
  
    // Traverse the map
    for(Map.Entry<Integer,
                  Integer> element : mp.entrySet())
    {
         
        // Stores key of an element
        int i = element.getKey();
        cntPairs += mp.get(i) * (mp.get(i) - 1) / 2;
    }
  
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
         
        // Stores count of pairs of equal
        // element by removing arr[i]
        int pairs_after_arr_i_removed = cntPairs +
                           1 - mp.get(arr[i]);
  
        System.out.print(pairs_after_arr_i_removed + " ");
    }
    return;
}
  
// Driver code
public static void main(String[] args)
{
     
    // Given Array
    int arr[] = { 2, 3, 4, 3, 2 };
    int N = arr.length;
  
    pairs_after_removing(arr, N);
}
}
 
// This code is contributed by susmitakundugoaldanga


Python3




# python program to implement
# the above approach
 
# Function to count pairs of equal elements
# by removing arr[i] from the array
def pairs_after_removing(arr, N):
     
    # Stores total count of
    # pairs of equal elements
    cntPairs = 0
 
    # Store frequency of each
    # distinct array element
    mp = {}
 
    # Traverse the array
    for i in arr:
 
        # Update frequency of arr[i]
        mp[i] = mp.get(i, 0) + 1
 
    # Traverse the map
    for element in mp:
 
        # Stores key of an element
        i = element
        cntPairs += mp[i] * (mp[i] - 1) // 2
 
    # Traverse the array
    for i in range(N):
 
        # Stores count of pairs of equal
        # element by removing arr[i]
        pairs_after_arr_i_removed = cntPairs + 1 - mp[arr[i]]
 
        print(pairs_after_arr_i_removed, end = ' ')
    return
 
# Driver Code
if __name__ == '__main__':
   
    # Given Array
    arr = [2, 3, 4, 3, 2]
    N = len(arr)
    pairs_after_removing(arr, N)
 
# This code is contributed by mohit kumar 29


C#




// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
   
class GFG
{
   
// Function to count pairs of equal elements
// by removing arr[i] from the array
static void pairs_after_removing(int[] arr, int N)
{
      
    // Stores total count of
    // pairs of equal elements
    int cntPairs = 0;
   
    // Store frequency of each
    // distinct array element
     Dictionary<int,
            int> mp = new Dictionary<int,
                                      int>();
   
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
          
        // Update frequency of arr[i]
        if(mp.ContainsKey(arr[i]))
            {
                mp[arr[i]]++;
            }
            else
            {
                mp[arr[i]] = 1;
            }
    }
   
    // Traverse the map
    foreach(KeyValuePair<int,
                             int> element in mp)
    {
          
        // Stores key of an element
        int i = element.Key;
        cntPairs += mp[i] * (mp[i] - 1) / 2;
    }
   
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
          
        // Stores count of pairs of equal
        // element by removing arr[i]
        int pairs_after_arr_i_removed = cntPairs +
                           1 - mp[arr[i]];
   
        Console.Write(pairs_after_arr_i_removed + " ");
    }
    return;
}
   
// Driver code
public static void Main()
{
      
    // Given Array
    int[] arr = { 2, 3, 4, 3, 2 };
    int N = arr.Length;
   
    pairs_after_removing(arr, N);
}
}
 
// This code is contributed by sanjoy_62


Javascript




<script>
 
// JavaScript program to implement
// the above approach
 
// Function to count pairs of equal elements
// by removing arr[i] from the array
function pairs_after_removing(arr, N)
{
    // Stores total count of
    // pairs of equal elements
    var cntPairs = 0;
 
    // Store frequency of each
    // distinct array element
    var mp = new Map();
 
    // Traverse the array
    for (var i = 0; i < N; i++) {
 
        // Update frequency of arr[i]
        if(mp.has(arr[i]))
        {
            mp.set(arr[i], mp.get(arr[i])+1);
        }
        else
        {
            mp.set(arr[i], 1);
        }
    }
 
    // Traverse the map
    mp.forEach((value, key) => {
         // Stores key of an element
         var i = key;
        cntPairs += mp.get(i) * (mp.get(i) - 1) / 2;
    });
 
    // Traverse the array
    for (var i = 0; i < N; i++) {
 
        // Stores count of pairs of equal
        // element by removing arr[i]
        var pairs_after_arr_i_removed
            = cntPairs + 1 - mp.get(arr[i]);
 
        document.write( pairs_after_arr_i_removed + ' ');
    }
    return;
}
 
// Driver Code
// Given Array
var arr = [2, 3, 4, 3, 2];
var N = arr.length;
pairs_after_removing(arr, N);
 
 
</script>


Output

1 1 2 1 1 


Time complexity: O(N)
Auxiliary space: O(N)



Last Updated : 07 Aug, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads