# Find maximum element among the elements with minimum frequency in given Array

• Last Updated : 14 Sep, 2021

Given an array arr[] consisting of N integers, the task is to find the maximum element with the minimum frequency.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {2, 2, 5, 50, 1}
Output: 50
Explanation:
The element with minimum frequency is {1, 5, 50}. The maximum element among these element is 50.

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

Approach: The given problem can be solved by storing the frequency of the array element in a HashMap and then find the maximum value having a minimum frequency. Follow the step below to solve the given problem:

• Store the frequency of each element in a HashMap, say M.
• Initialize two variables, say maxValue as INT_MIN and minFreq as INT_MAX that store the resultant maximum element and stores the minimum frequency among all the frequencies.
• Iterate over the map M and perform the following steps:
• If the frequency of the current element is less than minFreq then update the value of minFreq to the current frequency and the value of maxValue to the current element.
• If the frequency of the current element is equal to the minFreq and the value of maxValue is less than the current value then then update the value of maxValue to the current element.
• After completing the above steps, print the value of maxValue as the resultant element.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the maximum element``// with the minimum frequency``int` `maxElementWithMinFreq(``int``* arr, ``int` `N)``{``    ``// Stores the frequency of array``    ``// elements``    ``unordered_map<``int``, ``int``> mp;` `    ``// Find the frequency and store``    ``// in the map``    ``for` `(``int` `i = 0; i < N; i++) {``        ``mp[arr[i]]++;``    ``}` `    ``// Initialize minFreq to the maximum``    ``// value and minValue to the minimum``    ``int` `minFreq = INT_MAX;``    ``int` `maxValue = INT_MIN;` `    ``// Traverse the map mp``    ``for` `(``auto` `x : mp) {` `        ``int` `num = x.first;``        ``int` `freq = x.second;` `        ``// If freq < minFreq, then update``        ``// minFreq to freq and maxValue``        ``// to the current element``        ``if` `(freq < minFreq) {``            ``minFreq = freq;``            ``maxValue = num;``        ``}` `        ``// If freq is equal to the minFreq``        ``// and current element > maxValue``        ``// then update maxValue to the``        ``// current element``        ``else` `if` `(freq == minFreq``                 ``&& maxValue < num) {``            ``maxValue = num;``        ``}``    ``}` `    ``// Return the resultant maximum value``    ``return` `maxValue;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 2, 2, 5, 50, 1 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << maxElementWithMinFreq(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Function to find the maximum element``// with the minimum frequency``static` `int` `maxElementWithMinFreq(``int``[] arr, ``int` `N)``{``  ` `    ``// Stores the frequency of array``    ``// elements``    ``HashMap mp = ``new` `HashMap();` `    ``// Find the frequency and store``    ``// in the map``    ``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``);``    ``}``    ``}` `    ``// Initialize minFreq to the maximum``    ``// value and minValue to the minimum``    ``int` `minFreq = Integer.MAX_VALUE;``    ``int` `maxValue = Integer.MIN_VALUE;` `    ``// Traverse the map mp``    ``for` `(Map.Entry x : mp.entrySet()){` `        ``int` `num = x.getKey();``        ``int` `freq = x.getValue();` `        ``// If freq < minFreq, then update``        ``// minFreq to freq and maxValue``        ``// to the current element``        ``if` `(freq < minFreq) {``            ``minFreq = freq;``            ``maxValue = num;``        ``}` `        ``// If freq is equal to the minFreq``        ``// and current element > maxValue``        ``// then update maxValue to the``        ``// current element``        ``else` `if` `(freq == minFreq``                 ``&& maxValue < num) {``            ``maxValue = num;``        ``}``    ``}` `    ``// Return the resultant maximum value``    ``return` `maxValue;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``2``, ``2``, ``5``, ``50``, ``1` `};``    ``int` `N = arr.length;``    ``System.out.print(maxElementWithMinFreq(arr, N));` `}``}` `// This code is contributed by shikhasingrajput`

## Python3

 `# Python 3 program for the above approach``import` `sys``from` `collections ``import` `defaultdict` `# Function to find the maximum element``# with the minimum frequency``def` `maxElementWithMinFreq(arr, N):` `    ``# Stores the frequency of array``    ``# elements``    ``mp ``=` `defaultdict(``int``)` `    ``# Find the frequency and store``    ``# in the map``    ``for` `i ``in` `range``(N):``        ``mp[arr[i]] ``+``=` `1` `    ``# Initialize minFreq to the maximum``    ``# value and minValue to the minimum``    ``minFreq ``=` `sys.maxsize``    ``maxValue ``=` `-``sys.maxsize``-``1` `    ``# Traverse the map mp``    ``for` `x ``in` `mp:` `        ``num ``=` `x``        ``freq ``=` `mp[x]` `        ``# If freq < minFreq, then update``        ``# minFreq to freq and maxValue``        ``# to the current element``        ``if` `(freq < minFreq):``            ``minFreq ``=` `freq``            ``maxValue ``=` `num` `        ``# If freq is equal to the minFreq``        ``# and current element > maxValue``        ``# then update maxValue to the``        ``# current element``        ``elif` `(freq ``=``=` `minFreq``              ``and` `maxValue < num):``            ``maxValue ``=` `num` `    ``# Return the resultant maximum value``    ``return` `maxValue` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``2``, ``2``, ``5``, ``50``, ``1``]``    ``N ``=` `len``(arr)``    ``print``(maxElementWithMinFreq(arr, N))` `    ``# This code is contributed by ukasp.`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to find the maximum element``// with the minimum frequency``static` `int` `maxElementWithMinFreq(``int` `[]arr, ``int` `N)``{``  ` `    ``// Stores the frequency of array``    ``// elements``    ``Dictionary<``int``, ``int``> mp = ``new` `Dictionary<``int``,``int``>();` `    ``// Find the frequency and store``    ``// in the map``    ``for` `(``int` `i = 0; i < N; i++) {``        ``if``(mp.ContainsKey(arr[i]))``        ``mp[arr[i]]++;``        ``else``          ``mp.Add(arr[i],1);``    ``}` `    ``// Initialize minFreq to the maximum``    ``// value and minValue to the minimum``    ``int` `minFreq = Int32.MaxValue;``    ``int` `maxValue = Int32.MinValue;` `    ``// Traverse the map mp``    ``foreach``(KeyValuePair<``int``,``int``> x ``in` `mp) {` `        ``int` `num = x.Key;``        ``int` `freq = x.Value;` `        ``// If freq < minFreq, then update``        ``// minFreq to freq and maxValue``        ``// to the current element``        ``if` `(freq < minFreq) {``            ``minFreq = freq;``            ``maxValue = num;``        ``}` `        ``// If freq is equal to the minFreq``        ``// and current element > maxValue``        ``// then update maxValue to the``        ``// current element``        ``else` `if` `(freq == minFreq``                 ``&& maxValue < num) {``            ``maxValue = num;``        ``}``    ``}` `    ``// Return the resultant maximum value``    ``return` `maxValue;``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int` `[]arr = { 2, 2, 5, 50, 1 };``    ``int` `N = arr.Length;``    ``Console.Write(maxElementWithMinFreq(arr, N));``}``}` `// This code is contributed by SURENDRA_GANGWAR.`

## Javascript

 ``
Output:
`50`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up