Maximum difference between frequency of two elements such that element having greater frequency is also greater
Last Updated :
07 Jul, 2022
Given an array of n positive integers with many repeating elements. The task is to find the maximum difference between the frequency of any two different elements, such that the element with greater frequency is also greater in value than the second integer.
Examples:
Input : arr[] = { 3, 1, 3, 2, 3, 2 }.
Output : 2
Frequency of 3 = 3.
Frequency of 2 = 2.
Frequency of 1 = 1.
Here difference of frequency of element 3 and 1 is = 3 - 1 = 2.
Also 3 > 1.
Method 1 (Use Hashing): The naive approach can be, find the frequency of each element and for each element find the element having lesser value and lesser frequency than the current element.
Below is the implementation of this approach:
C++
#include<bits/stdc++.h>
using namespace std;
int maxdiff( int arr[], int n)
{
unordered_map< int , int > freq;
for ( int i = 0; i < n; i++)
freq[arr[i]]++;
int ans = 0;
for ( int i=0; i<n; i++)
{
for ( int j=0; j<n; j++)
{
if (freq[arr[i]] > freq[arr[j]] &&
arr[i] > arr[j] )
ans = max(ans, freq[arr[i]]-freq[arr[j]]);
else if (freq[arr[i]] < freq[arr[j]] &&
arr[i] < arr[j] )
ans = max(ans, freq[arr[j]]-freq[arr[i]]);
}
}
return ans;
}
int main()
{
int arr[] = { 3, 1, 3, 2, 3, 2 };
int n = sizeof (arr)/ sizeof (arr[0]);
cout << maxdiff(arr, n) << endl;
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int maxdiff( int arr[], int n)
{
Map<Integer, Integer> freq = new HashMap<>();
for ( int i = 0 ; i < n; i++)
freq.put(arr[i],
freq.get(arr[i]) == null ? 1 :
freq.get(arr[i]) + 1 );
int ans = 0 ;
for ( int i = 0 ; i < n; i++)
{
for ( int j = 0 ; j < n; j++)
{
if (freq.get(arr[i]) > freq.get(arr[j]) &&
arr[i] > arr[j])
ans = Math.max(ans, freq.get(arr[i]) -
freq.get(arr[j]));
else if (freq.get(arr[i]) < freq.get(arr[j]) &&
arr[i] < arr[j] )
ans = Math.max(ans, freq.get(arr[j]) -
freq.get(arr[i]));
}
}
return ans;
}
public static void main(String[] args)
{
int arr[] = { 3 , 1 , 3 , 2 , 3 , 2 };
int n = arr.length;
System.out.println(maxdiff(arr, n));
}
}
|
Python3
from collections import defaultdict
def maxdiff(arr, n):
freq = defaultdict( lambda : 0 )
for i in range (n):
freq[arr[i]] + = 1
ans = 0
for i in range (n):
for j in range (n):
if freq[arr[i]] > freq[arr[j]] and arr[i] > arr[j]:
ans = max (ans, freq[arr[i]] - freq[arr[j]])
elif freq[arr[i]] < freq[arr[j]] and arr[i] < arr[j]:
ans = max (ans, freq[arr[j]] - freq[arr[i]])
return ans
arr = [ 3 , 1 , 3 , 2 , 3 , 2 ]
n = len (arr)
print (maxdiff(arr,n))
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static int maxdiff( int [] arr, int n)
{
Dictionary< int ,
int > freq = new Dictionary< int ,
int >();
for ( int i = 0; i < n; i++)
{
if (freq.ContainsKey(arr[i]))
freq[arr[i]]++;
else
freq.Add(arr[i], 1);
}
int ans = 0;
for ( int i = 0; i < n; i++)
{
for ( int j = 0; j < n; j++)
{
if (freq[arr[i]] > freq[arr[j]] && arr[i] > arr[j])
ans = Math.Max(ans, freq[arr[i]] - freq[arr[i]]);
else if (freq[arr[i]] < freq[arr[j]] && arr[i] < arr[j])
ans = Math.Max(ans, freq[arr[j]] - freq[arr[i]]);
}
}
return ans;
}
public static void Main(String[] args)
{
int [] arr = { 3, 1, 3, 2, 3, 2 };
int n = arr.Length;
Console.WriteLine(maxdiff(arr, n));
}
}
|
Javascript
<script>
function maxdiff(arr, n)
{
let freq = new Map();
for (let i = 0; i < n; i++)
freq.set(arr[i],
freq.get(arr[i]) == null ? 1 :
freq.get(arr[i]) + 1);
let ans = 0;
for (let i = 0; i < n; i++)
{
for (let j = 0; j < n; j++)
{
if (freq.get(arr[i]) > freq.get(arr[j]) &&
arr[i] > arr[j])
ans = Math.max(ans, freq.get(arr[i]) -
freq.get(arr[j]));
else if (freq.get(arr[i]) < freq.get(arr[j]) &&
arr[i] < arr[j] )
ans = Math.max(ans, freq.get(arr[j]) -
freq.get(arr[i]));
}
}
return ans;
}
let arr = [ 3, 1, 3, 2, 3, 2 ];
let n = arr.length;
document.write(maxdiff(arr, n));
</script>
|
Time Complexity: O(n2).
Auxiliary Space: O(n)
Method 2 (Use Hashing and Sorting): The idea is to find all the distinct elements and store them in an array, say dist[ ]. Sort the distinct element array dist[] in increasing order. Now for any distinct element at index i, for all index j such that i > j > 0, find the element between index 0 to i-1 having a minimum frequency. We can find the frequency of an element in the same way as method 1, i.e., storing frequencies in a hash table.
So do this for all i and find the maximum difference. To find the minimum frequency for all i maintain a prefix minimum.
Below is the representation of this approach:
C++
#include<bits/stdc++.h>
using namespace std;
int maxdiff( int arr[], int n)
{
unordered_map< int , int > freq;
int dist[n];
int j = 0;
for ( int i = 0; i < n; i++)
{
if (freq.find(arr[i]) == freq.end())
dist[j++] = arr[i];
freq[arr[i]]++;
}
sort(dist, dist + j);
int min_freq = n+1;
int ans = 0;
for ( int i=0; i<j; i++)
{
int cur_freq = freq[dist[i]];
ans = max(ans, cur_freq - min_freq);
min_freq = min(min_freq, cur_freq);
}
return ans;
}
int main()
{
int arr[] = { 3, 1, 3, 2, 3, 2 };
int n = sizeof (arr)/ sizeof (arr[0]);
cout << maxdiff(arr, n) << endl;
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int maxdiff( int arr[], int n)
{
HashMap<Integer,Integer> freq= new HashMap<>();
int []dist = new int [n];
int j = 0 ;
for ( int i = 0 ; i < n; i++)
{
dist[j++] = arr[i];
if (!freq.containsKey(arr[i]))
freq.put(arr[i], 1 );
else
freq.put(arr[i], freq.get(arr[i]) + 1 );
}
Arrays.sort(dist);
int min_freq = n + 1 ;
int ans = 0 ;
for ( int i = 0 ; i < j; i++)
{
int cur_freq = freq.get(dist[i]);
ans = Math.max(ans, cur_freq - min_freq);
min_freq = Math.min(min_freq, cur_freq);
}
return ans;
}
public static void main(String[] args)
{
int arr[] = { 3 , 1 , 3 , 2 , 3 , 2 };
int n = arr.length;
System.out.print(maxdiff(arr, n) + "\n" );
}
}
|
Python3
def maxdiff(arr, n):
freq = {}
dist = [ 0 ] * n
j = 0
for i in range (n):
if (arr[i] not in freq):
dist[j] = arr[i]
j + = 1
freq[arr[i]] = 0
if (arr[i] in freq):
freq[arr[i]] + = 1
dist = dist[:j]
dist.sort()
min_freq = n + 1
ans = 0
for i in range (j):
cur_freq = freq[dist[i]]
ans = max (ans, cur_freq - min_freq)
min_freq = min (min_freq, cur_freq)
return ans
arr = [ 3 , 1 , 3 , 2 , 3 , 2 ]
n = len (arr)
print (maxdiff(arr, n))
|
C#
using System.Collections.Generic;
using System;
class GFG{
static int maxdiff( int []arr, int n)
{
Dictionary< int ,
int > freq = new Dictionary< int ,
int >();
List< int > dist = new List< int >();
int j = 0;
for ( int i = 0; i < n; i++)
{
if (freq.ContainsKey(arr[i]) == false )
{
dist.Add(arr[i]);
j++;
}
if (freq.ContainsKey(arr[i]))
freq[arr[i]]++;
else
freq[arr[i]]=1;
}
dist.Sort();
int min_freq = n + 1;
int ans = 0;
for ( int i = 0; i < j; i++)
{
int cur_freq = freq[dist[i]];
ans = Math.Max(ans, cur_freq - min_freq);
min_freq = Math.Min(min_freq, cur_freq);
}
return ans;
}
public static void Main(String[] args)
{
int []arr = { 3, 1, 3, 2, 3, 2 };
int n = arr.Length;
Console.WriteLine(maxdiff(arr, n));
}
}
|
Javascript
<script>
function maxdiff(arr, n)
{
var freq = new Map();
var dist = Array(n);
var j = 0;
for ( var i = 0; i < n; i++)
{
if (!freq.has(arr[i]))
dist[j++] = arr[i];
if (freq.has(arr[i]))
freq.set(arr[i], freq.get(arr[i])+1)
else
freq.set(arr[i], 1)
}
dist.sort();
var min_freq = n+1;
var ans = 0;
for ( var i=0; i<j; i++)
{
var cur_freq = freq.get(dist[i]);
ans = Math.max(ans, cur_freq - min_freq);
min_freq = Math.min(min_freq, cur_freq);
}
return ans;
}
var arr = [3, 1, 3, 2, 3, 2 ];
var n = arr.length;
document.write( maxdiff(arr, n))
</script>
|
Time Complexity: O(n log n).
Auxiliary Space: O(n)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...