# 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++ program to find sum of elements ` `// in an array having frequency greater ` `// than or equal to that element ` ` `  `#include ` `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); ` ` `  `    ``cout << sumOfElements(arr, n); ` ` `  `    ``return` `0; ` `} `

 `// 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 m= ``new` `HashMap(); ` `    ``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 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# 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:
```6
```

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.

Practice Tags :