Sum of elements in an array with frequencies greater than or equal to that element

Given an array arr[] of N integers. The task is to find the sum of the elements which have frequencies greater than or equal to that element in the array.

Examples:

Input: arr[] = {2, 1, 1, 2, 1, 6}
Output: 3
The elements in the array are {2, 1, 6}
Where,
 2 appear 2 times which is greater than equal to 2 itself.
 1 appear 3 times which is greater than 1 itself.
 But 6 appears 1 time which is not greater than or equals to 6.
So, sum = 2 + 1 = 3.

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

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

Traverse the array and store the frequencies of all the elements in an unordered_map in C++ or equivalent data structure in any other programming language.
Calculate the sum of elements having frequencies greater than or equal to that element.

Below is the implementation of the above approach:

C++

// C++ program to find sum of elements 
// in an array having frequency greater 
// than or equal to that element 
  
#include <bits/stdc++.h> 
using namespace std; 
  
// Function to return the sum of elements 
// in an array having frequency greater 
// than or equal to that element 
int sumOfElements(int arr[], int n) 
{ 
    bool prime[n + 1]; 
    int i, j; 
  
    // Map is used to store 
    // element frequencies 
    unordered_map<int, int> m; 
    for (i = 0; i < n; i++) 
        m[arr[i]]++; 
  
    int sum = 0; 
  
    // Traverse the map using iterators 
    for (auto it = m.begin(); it != m.end(); it++) { 
  
        // Calculate the sum of elements 
        // having frequencies greater than 
        // or equal to the element itself 
        if ((it->second) >= (it->first)) { 
            sum += (it->first); 
        } 
    } 
  
    return sum; 
} 
  
// Driver code 
int main() 
{ 
    int arr[] = { 1, 2, 3, 3, 2, 3, 2, 3, 3 }; 
    int n = sizeof(arr) / sizeof(arr[0]); 
  
    cout << sumOfElements(arr, n); 
  
    return 0; 
} 

Java

// Java program to find sum of elements 
// in an array having frequency greater 
// than or equal to that element 
import java.util.*; 
class Solution 
{ 
  
// Function to return the sum of elements 
// in an array having frequency greater 
// than or equal to that element 
static int sumOfElements(int arr[], int n) 
{ 
    boolean prime[] = new boolean[n + 1]; 
    int i, j; 
  
    // Map is used to store 
    // element frequencies 
    HashMap<Integer, Integer> m= new HashMap<Integer,Integer>(); 
    for (i = 0; i < n; i++) 
        { 
            if(m.get(arr[i])==null) 
            m.put(arr[i],1); 
            else
            m.put(arr[i],m.get(arr[i])+1); 
        } 
  
    int sum = 0; 
        // Getting an iterator  
        Iterator hmIterator = m.entrySet().iterator();  
    
    
    // Traverse the map using iterators 
        while (hmIterator.hasNext()) {  
            Map.Entry mapElement = (Map.Entry)hmIterator.next(); 
  
        // Calculate the sum of elements 
        // having frequencies greater than 
        // or equal to the element itself 
        if (((int)mapElement.getValue()) >= ((int)mapElement.getKey())) { 
            sum += ((int)mapElement.getKey()); 
        } 
    } 
  
    return sum; 
} 
  
// Driver code 
public static void main(String args[]) 
{ 
    int arr[] = { 1, 2, 3, 3, 2, 3, 2, 3, 3 }; 
    int n = arr.length; 
  
    System.out.println(sumOfElements(arr, n)); 
  
 } 
} 
//contributed by Arnab Kundu 

Python3

# Python3 program to find sum of elements  
# in an array having frequency greater  
# than or equal to that element 
  
# Function to return the sum of elements  
# in an array having frequency greater  
# than or equal to that element  
def sumOfElements(arr, n) : 
  
    # dictionary is used to store  
    # element frequencies  
    m = dict.fromkeys(arr, 0) 
  
    for i in range(n) : 
            m[arr[i]] += 1
  
    sum = 0
  
    # traverse the dictionary 
    for key,value in m.items() : 
  
        # Calculate the sum of elements  
        # having frequencies greater than  
        # or equal to the element itself  
        if value >= key : 
                sum += key 
  
    return sum
  
# Driver code 
if __name__ == "__main__" : 
  
    arr = [1, 2, 3, 3, 2, 3, 2, 3, 3] 
    n = len(arr) 
  
    print(sumOfElements(arr, n)) 
  
# This code is contributed by Ryuga 

C#

// C# program to find sum of elements 
// in an array having frequency greater 
// than or equal to that element 
using System; 
using System.Collections.Generic; 
  
class GFG 
{ 
  
    // Function to return the sum of elements 
    // in an array having frequency greater 
    // than or equal to that element 
    static int sumOfElements(int []arr, int n) 
    { 
        bool []prime = new bool[n + 1]; 
        int i; 
      
        // Map is used to store 
        // element frequencies 
        Dictionary<int, int> m= new Dictionary<int,int>(); 
        for (i = 0; i < n; i++) 
            { 
                if(!m.ContainsKey(arr[i])) 
                    m.Add(arr[i],1); 
                else
                { 
                    var val = m[arr[i]]; 
                    m.Remove(arr[i]); 
                    m.Add(arr[i], val + 1); 
                } 
              
            } 
      
            int sum = 0; 
            // Calculate the sum of elements 
            // having frequencies greater than 
            // or equal to the element itself 
            foreach(KeyValuePair<int, int> entry in m) 
            { 
                if(entry.Value >= entry.Key) 
                { 
                    sum+=entry.Key; 
                } 
            } 
      
        return sum; 
    } 
      
    // Driver code 
    public static void Main(String []args) 
    { 
        int []arr = { 1, 2, 3, 3, 2, 3, 2, 3, 3 }; 
        int n = arr.Length; 
      
        Console.WriteLine(sumOfElements(arr, n)); 
    } 
} 
  
// This code has been contributed by 29AjayKumar 

Output:

Time complexity : O(n)

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.

My Personal Notes

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

C++

Java

Python3

C#

Recommended Posts: