Difference between highest and least frequencies in an array
Last Updated :
06 Nov, 2023
Given an array, find the difference between highest occurrence and least occurrence of any number in an array
Examples:
Input : arr[] = [7, 8, 4, 5, 4, 1, 1, 7, 7, 2, 5]
Output : 2
Lowest occurring element (5) occurs once.
Highest occurring element (1 or 7) occurs 3 times
Input : arr[] = [1, 1, 1, 3, 3, 3]
Output : 0
A simple solution is to use two loops to count the frequency of every element and keep track of maximum and minimum frequencies.
Algorithm:
- Define function named maxMinDiff with two parameters arr[] and n.
- Initialize variables maxFreq to INT_MIN and minFreq to INT_MAX.
- Loop through array arr[] from i = 0 to n-1
- Initialize count variable to 0
- Loop through array arr[] from j = 0 to n-1
- If arr[i] is equal to arr[j], increment count
- Update maxFreq and minFreq with maximum and minimum of their respective values and count
- Find difference between maxFreq and minFreq and store it in variable diff
- Return diff
Below is the implementation of the approach:
C++
#include<bits/stdc++.h>
using namespace std;
int maxMinDiff( int arr[], int n) {
int maxFreq = INT_MIN, minFreq = INT_MAX;
for ( int i=0; i<n; i++) {
int count = 0;
for ( int j=0; j<n; j++) {
if (arr[i] == arr[j])
count++;
}
maxFreq = max(maxFreq, count);
minFreq = min(minFreq, count);
}
return (maxFreq - minFreq);
}
int main() {
int arr[] = { 7, 8, 4, 5, 4, 1, 1, 7, 7, 2, 5 };
int n = sizeof (arr)/ sizeof (arr[0]);
int diff = maxMinDiff(arr, n);
cout << diff << endl;
return 0;
}
|
Java
import java.util.*;
class Main {
public static int maxMinDiff( int [] arr, int n)
{
int maxFreq = Integer.MIN_VALUE,
minFreq = Integer.MAX_VALUE;
for ( int i = 0 ; i < n; i++) {
int count = 0 ;
for ( int j = 0 ; j < n; j++) {
if (arr[i] == arr[j])
count++;
}
maxFreq = Math.max(maxFreq, count);
minFreq = Math.min(minFreq, count);
}
return (maxFreq - minFreq);
}
public static void main(String[] args)
{
int arr[] = { 7 , 8 , 4 , 5 , 4 , 1 , 1 , 7 , 7 , 2 , 5 };
int n = arr.length;
int diff = maxMinDiff(arr, n);
System.out.println(diff);
}
}
|
Python
def max_min_diff(arr):
max_freq = float ( '-inf' )
min_freq = float ( 'inf' )
for i in range ( len (arr)):
count = 0
for j in range ( len (arr)):
if arr[i] = = arr[j]:
count + = 1
max_freq = max (max_freq, count)
min_freq = min (min_freq, count)
return max_freq - min_freq
if __name__ = = "__main__" :
arr = [ 7 , 8 , 4 , 5 , 4 , 1 , 1 , 7 , 7 , 2 , 5 ]
diff = max_min_diff(arr)
print (diff)
|
C#
using System;
class Program
{
static int MaxMinDiff( int [] arr, int n)
{
int maxFreq = int .MinValue;
int minFreq = int .MaxValue;
for ( int i = 0; i < n; i++)
{
int count = 0;
for ( int j = 0; j < n; j++)
{
if (arr[i] == arr[j])
count++;
}
maxFreq = Math.Max(maxFreq, count);
minFreq = Math.Min(minFreq, count);
}
return maxFreq - minFreq;
}
static void Main()
{
int [] arr = { 7, 8, 4, 5, 4, 1, 1, 7, 7, 2, 5 };
int n = arr.Length;
int diff = MaxMinDiff(arr, n);
Console.WriteLine(diff);
}
}
|
Javascript
function maxMinDiff(arr) {
let maxFreq = -Infinity;
let minFreq = Infinity;
for (let i = 0; i < arr.length; i++) {
let count = 0;
for (let j = 0; j < arr.length; j++) {
if (arr[i] === arr[j]) {
count++;
}
}
maxFreq = Math.max(maxFreq, count);
minFreq = Math.min(minFreq, count);
}
return maxFreq - minFreq;
}
const arr = [7, 8, 4, 5, 4, 1, 1, 7, 7, 2, 5];
const diff = maxMinDiff(arr);
console.log(diff);
|
Time Complexity: O(N*N) where N is the size of input array. This is because two nested for loops are executing in maxMinDiff function.
Space Complexity: O(1) as no extra space has been taken.
A better solution is to sort the array in O(n log n) and check consecutive element’s occurrence and compare their count respectively.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int findDiff( int arr[], int n)
{
sort(arr, arr + n);
int count = 0, max_count = 0, min_count = n;
for ( int i = 0; i < (n - 1); i++) {
if (arr[i] == arr[i + 1]) {
count += 1;
continue ;
}
else {
max_count = max(max_count, count);
min_count = min(min_count, count);
count = 0;
}
}
return (max_count - min_count);
}
int main()
{
int arr[] = { 7, 8, 4, 5, 4, 1, 1, 7, 7, 2, 5 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << findDiff(arr, n) << "\n" ;
return 0;
}
|
Java
import java.util.*;
class GFG {
static int findDiff( int arr[], int n)
{
Arrays.sort(arr);
int count = 0 , max_count = 0 ,
min_count = n;
for ( int i = 0 ; i < (n - 1 ); i++) {
if (arr[i] == arr[i + 1 ]) {
count += 1 ;
continue ;
}
else {
max_count = Math.max(max_count,
count);
min_count = Math.min(min_count,
count);
count = 0 ;
}
}
return (max_count - min_count);
}
public static void main(String[] args)
{
int arr[] = { 7 , 8 , 4 , 5 , 4 , 1 ,
1 , 7 , 7 , 2 , 5 };
int n = arr.length;
System.out.println(findDiff(arr, n));
}
}
|
Python3
def findDiff(arr, n):
arr.sort()
count = 0 ; max_count = 0 ; min_count = n
for i in range ( 0 , (n - 1 )):
if arr[i] = = arr[i + 1 ]:
count + = 1
continue
else :
max_count = max (max_count, count)
min_count = min (min_count, count)
count = 0
return max_count - min_count
arr = [ 7 , 8 , 4 , 5 , 4 , 1 , 1 , 7 , 7 , 2 , 5 ]
n = len (arr)
print (findDiff(arr, n))
|
C#
using System;
class GFG {
static int findDiff( int [] arr, int n)
{
Array.Sort(arr);
int count = 0, max_count = 0,
min_count = n;
for ( int i = 0; i < (n - 1); i++) {
if (arr[i] == arr[i + 1]) {
count += 1;
continue ;
}
else {
max_count = Math.Max(max_count,
count);
min_count = Math.Min(min_count,
count);
count = 0;
}
}
return (max_count - min_count);
}
public static void Main()
{
int [] arr = { 7, 8, 4, 5, 4, 1,
1, 7, 7, 2, 5 };
int n = arr.Length;
Console.WriteLine(findDiff(arr, n));
}
}
|
Javascript
<script>
function findDiff(arr, n)
{
arr.sort( function (a, b){ return a - b});
let count = 0, max_count = 0, min_count = n;
for (let i = 0; i < (n - 1); i++) {
if (arr[i] == arr[i + 1]) {
count += 1;
continue ;
}
else {
max_count = Math.max(max_count, count);
min_count = Math.min(min_count, count);
count = 0;
}
}
return (max_count - min_count);
}
let arr = [ 7, 8, 4, 5, 4, 1, 1, 7, 7, 2, 5 ];
let n = arr.length;
document.write(findDiff(arr, n));
</script>
|
PHP
<?php
function findDiff( $arr , $n )
{
sort( $arr );
$count = 0; $max_count = 0;
$min_count = $n ;
for ( $i = 0; $i < ( $n - 1); $i ++)
{
if ( $arr [ $i ] == $arr [ $i + 1])
{
$count += 1;
continue ;
}
else
{
$max_count = max( $max_count , $count );
$min_count = min( $min_count , $count );
$count = 0;
}
}
return ( $max_count - $min_count );
}
$arr = array (7, 8, 4, 5, 4, 1,
1, 7, 7, 2, 5);
$n = sizeof( $arr );
echo (findDiff( $arr , $n ) . "\n" );
?>
|
Time Complexity: O(nlogn) the inbuilt sort function takes N log N time to complete all operations, hence the overall time taken by the algorithm is N log N
Space Complexity: O(1) since no extra array is used so the space taken by the algorithm is constant
An efficient solution is to use hashing. We count frequencies of all elements and finally traverse the hash table to find maximum and minimum.
Below is the implementation.
C++
#include <bits/stdc++.h>
using namespace std;
int findDiff( int arr[], int n)
{
unordered_map< int , int > hm;
for ( int i = 0; i < n; i++)
hm[arr[i]]++;
int max_count = 0, min_count = n;
for ( auto x : hm) {
max_count = max(max_count, x.second);
min_count = min(min_count, x.second);
}
return (max_count - min_count);
}
int main()
{
int arr[] = { 7, 8, 4, 5, 4, 1, 1, 7, 7, 2, 5 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << findDiff(arr, n) << "\n" ;
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int findDiff( int arr[], int n)
{
Map<Integer,Integer> mp = new HashMap<>();
for ( int i = 0 ; i < n; i++)
{
if (mp.containsKey(arr[i]))
{
mp.put(arr[i], mp.get(arr[i])+ 1 );
}
else
{
mp.put(arr[i], 1 );
}
}
int max_count = 0 , min_count = n;
for (Map.Entry<Integer,Integer> x : mp.entrySet())
{
max_count = Math.max(max_count, x.getValue());
min_count = Math.min(min_count, x.getValue());
}
return (max_count - min_count);
}
public static void main(String[] args)
{
int arr[] = { 7 , 8 , 4 , 5 , 4 , 1 , 1 , 7 , 7 , 2 , 5 };
int n = arr.length;
System.out.println(findDiff(arr, n));
}
}
|
Python3
from collections import defaultdict
def findDiff(arr,n):
mp = defaultdict( lambda : 0 )
for i in range (n):
mp[arr[i]] + = 1
max_count = 0 ;min_count = n
for key,values in mp.items():
max_count = max (max_count,values)
min_count = min (min_count,values)
return max_count - min_count
arr = [ 7 , 8 , 4 , 5 , 4 , 1 , 1 , 7 , 7 , 2 , 5 ]
n = len (arr)
print (findDiff(arr,n))
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static int findDiff( int []arr, int n)
{
Dictionary< int , int > mp = new Dictionary< int , int >();
for ( int i = 0 ; i < n; i++)
{
if (mp.ContainsKey(arr[i]))
{
var val = mp[arr[i]];
mp.Remove(arr[i]);
mp.Add(arr[i], val + 1);
}
else
{
mp.Add(arr[i], 1);
}
}
int max_count = 0, min_count = n;
foreach (KeyValuePair< int , int > entry in mp)
{
max_count = Math.Max(max_count, entry.Value);
min_count = Math.Min(min_count, entry.Value);
}
return (max_count - min_count);
}
public static void Main(String[] args)
{
int []arr = { 7, 8, 4, 5, 4, 1, 1, 7, 7, 2, 5 };
int n = arr.Length;
Console.WriteLine(findDiff(arr, n));
}
}
|
Javascript
<script>
function findDiff(arr, n)
{
var mp = {};
for ( var i = 0; i < n; i++) {
if (mp.hasOwnProperty(arr[i])) {
var val = mp[arr[i]];
delete mp[arr[i]];
mp[arr[i]] = val + 1;
} else {
mp[arr[i]] = 1;
}
}
var max_count = 0,
min_count = n;
for (const [key, value] of Object.entries(mp)) {
max_count = Math.max(max_count, value);
min_count = Math.min(min_count, value);
}
return max_count - min_count;
}
var arr = [7, 8, 4, 5, 4, 1, 1, 7, 7, 2, 5];
var n = arr.length;
document.write(findDiff(arr, n));
</script>
|
Time Complexity: O(n) since one traversal of the array is required to complete all operations hence the overall time required by the algorithm is linear
Auxiliary Space: O(n) since an unordered map is used, in the worst case all elements will be stored inside the unordered map thus the space taken by the algorithm is linear
This article is contributed by Himanshu Ranjan.
Share your thoughts in the comments
Please Login to comment...