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:
#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;
} |
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 |
# 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# 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. |
// 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(); |
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++ 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 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 |
# 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# 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 |
<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> |
1 1 2 1 1
Time complexity: O(N)
Auxiliary space: O(N)