Highest / Lowest Frequency Elements

vector<int> getFrequencies(vector<int>& v) {

    // Write Your Code Here

    unordered_map<int, int> frequencyMap;

    // Count frequencies of each element

    for (int num : v) {

        frequencyMap[num]++;

    }

    int highestFrequency = 0;

    int lowestFrequency = INT_MAX;

    int highestFreqElement = INT_MAX;

    int lowestFreqElement = INT_MAX;

    // Find the highest and lowest frequency elements

    for (const auto& entry : frequencyMap) {

        int element = entry.first;

        int frequency = entry.second;

        // Check for highest frequency

        if (frequency > highestFrequency) {

            highestFrequency = frequency;

            highestFreqElement = element;

        } else if (frequency == highestFrequency) {

            highestFreqElement = min(highestFreqElement, element);

        }

        // Check for lowest frequency

        if (frequency < lowestFrequency) {

            lowestFrequency = frequency;

            lowestFreqElement = element;

        } else if (frequency == lowestFrequency) {

            lowestFreqElement = min(lowestFreqElement, element);

        }

    }

    return {highestFreqElement, lowestFreqElement};

}

from typing import List
from collections import Counter

def getFrequencies(v: List[int]) -> List[int]: 
    # Write your code here
    d = Counter(v)
    most_to_least = d.most_common()
    most_common , most_common_count = most_to_least[0][0], most_to_least[0][1]

    least_to_most = most_to_least[::-1]
    least_common,least_common_count = least_to_most[0][0],least_to_most[0][1]
    
    i,n=1,len(least_to_most)


    while(n>i):
        if( most_common > most_to_least[i][0] and most_common_count == most_to_least[i][1] ):
            most_common = most_to_least[i][0]
        if(least_common > least_to_most[i][0] and least_common_count == least_to_most[i][1]):
            least_common = least_to_most[i][0]
        i+=1

    return [most_common,least_common]
   

#include<bits/stdc++.h>
vector<int> getFrequencies(vector<int>& v) {
    // Write Your Code Here

    map<int,int> mpp;

    for(int i=0;i<v.size();i++){
        mpp[v[i]]++;
    }

    int minFreq=INT_MAX;
    int maxFreq=INT_MIN;
    int minValue=0;
    int maxValue=0;
    
    for(auto it: mpp){

        if(it.second>maxFreq){
            maxFreq=it.second;
            maxValue=it.first;
        }

        if(it.second<minFreq){
            minFreq=it.second;
            minValue=it.first;
        }

    }

    return {maxValue,minValue};
}

from typing import List

def getFrequencies(n :int,v: List[int]) -> List[int]: 

    frequency={}

    for num in v:

        if num in frequency:

            frequency[num]+=1

        frequency[num]=1

    highest_freq= float("-inf")

    lowest_freq= float("inf")

    highest_freq_element=float("inf")

    lowest_freq_element=float("inf")

    for key,values in frequency.items():

        if values>highest_freq or (values==highest_freq and key>highest_freq_element) :

            highest_freq=values

            highest_freq_element=key

        if values<lowest_freq or (values==lowest_freq and key<lowest_freq_element):

            lowest_freq=values

            lowest_freq_element=key

    return [highest_freq_element,lowest_freq_element]

vector<int> getFrequencies(vector<int>& v) {

    // Calculate frequencies of elements in v

    unordered_map<int, int> ans;

    for(int i = 0; i < v.size(); i++) {

        ans[v[i]]++;

    }

    // Initialize minimum and maximum frequencies and values

    int minFreq = INT_MAX, maxFreq = 0;

    int minVal = v[0], maxVal = v[0];

    // Find minimum and maximum frequencies and corresponding values

    for(auto it : ans) {

        // Update minimum frequency and value

        if(minFreq >= it.second) {

            if(minFreq == it.second) {

                minVal = min(minVal, it.first);

            } else {

                minFreq = it.second;

                minVal = it.first;

            }

        }

        // Update maximum frequency and value

        if(maxFreq <= it.second) {

            if(maxFreq == it.second) {

                maxVal = min(maxVal, it.first);

            } else {

                maxFreq = it.second;

                maxVal = it.first;

            }

        }

    }

    // Return vector containing maxVal and minVal

    return {maxVal, minVal};

}

import java.util.*;

import java.util.Arrays;

public class Solution {

    public static int[] getFrequencies(int []v) {

        // Write Your Code Here

        int res[] = new int[2];

        // Arrays.sort(v);

        TreeMap<Integer,Integer> map = new TreeMap<>();

        for(int i=0;i<v.length;i++) {

            map.put(v[i], map.getOrDefault(v[i], 0)+1);

        }

        int lar = Integer.MIN_VALUE;

        int low = Integer.MAX_VALUE;

         // for largest because 1st element showing the largest element in the array

         for(Integer key : map.keySet()) {

            int val = map.get(key);

            if(val > lar) {

                lar = val;

                res[0] = key;

            }

        }

        //for lowest because 2nd element showing the lowest element in the array

        for(Integer key : map.keySet()) {

            int val = map.get(key);

            if(val < low) {

                low = val;

                res[1] = key;

            }

        }

        return res;

    }

}

vector<int> getFrequencies(vector<int>& v) {

    // Write Your Code Here

    unordered_map<int,int> mp;

    for(int i=0;i<v.size();i++)

    {

        if(mp.find(v[i])!=mp.end())

        {

            mp[v[i]]++;

        }

        else mp[v[i]]=1;

    }

    int maxfreq = 0;

    int minfreq =INT_MAX;

    int maxfval = v[0];

    int minfval = v[0];

    for(auto it = mp.begin();it!=mp.end();it++)

    {

        if(it->second<=minfreq)

        {

            if(it->second == minfreq)

            {

                minfval = min(minfval,it->first);

            }

            else{

                minfreq = it->second;

                minfval = it->first;

            }

        }

        if(it->second>=maxfreq)

        {

            if(it->second == maxfreq)

            {

                maxfval = min(maxfval,it->first);

            }

            else{

                maxfreq = it->second;

                maxfval = it->first;

            }

        }

    }

    return {maxfval,minfval};

}

from typing import List

def getFrequencies(v: List[int]) -> List[int]: 
    # Write your code here
    freq_dict = dict()
    for i in v:
        if i in freq_dict:
            freq_dict[i] += 1
        else:
            freq_dict[i] = 1
    
    max_val = max(freq_dict.values())
    min_val = min(freq_dict.values())
    
    max_list = []
    for i,j in freq_dict.items():
        if j == max_val:
            max_list.append(i)
    
    min_list = []
    for i,j in freq_dict.items():
        if j == min_val:
            min_list.append(i)
    
    return min(max_list),min(min_list)
    pass

vector<int> getFrequencies(vector<int>& v) {

    // Write Your Code Here

    map<int, int>mpp;

    for(int i=0; i<v.size(); i++)

    {

          mpp[v[i]]++;

    }

    int maxf = 0;

     int lowest=0;

    int highest = 0;

    int minf=INT_MAX;

  map<int, int>::iterator iter;

    for( iter=mpp.begin(); iter!=mpp.end(); ++iter)

    {

          if(iter->second<minf)

          {

              minf = iter->second;

              lowest = iter->first;

          }

    }

     for( iter=mpp.begin(); iter!=mpp.end(); ++iter)

    {

          if(iter->second>maxf)

          {

             maxf = iter->second;

             highest = iter->first;

          }

    }

    return {highest, lowest};

}

import java.util.*;

public class Solution {

    public static int[] getFrequencies(int []v) {

        // Write Your Code Here

        int n = v.length;

        HashMap<Integer,Integer> map = new HashMap<>();

        for(int i : v){

            if(map.containsKey(i)){

                map.put(i, map.get(i)+1);

            }else{

                map.put(i,1);

            }

        }

        int maxKey = Integer.MIN_VALUE;

        int minKey = Integer.MAX_VALUE;

        int maxCount = Integer.MIN_VALUE;

        int minCount = Integer.MAX_VALUE;

        for (Map.Entry<Integer, Integer> entry : map.entrySet()){

            int freq = entry.getValue();

            int key = entry.getKey();

            if(freq > maxCount){

                maxCount = freq;

                maxKey = entry.getKey();

            }

            if(freq < minCount){

                minCount = freq;

                minKey = entry.getKey();

            }

            if(freq == minCount){

                minKey = Math.min(key, minKey);

            }

            if(freq == maxCount){

                maxKey = Math.min(key, maxKey);

            }

        }

        int arr [] = new int[2];

        arr[0] = maxKey;

        arr[1] = minKey;

        return arr;

    }

}