Open In App

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

Improve
Improve
Like Article
Like
Save
Share
Report

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

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


Javascript




<script>
// javascript 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
function sumOfElements(arr, n) {
    let prime = new Array(n + 1);
    let i, j;
  
    // Map is used to store
    // element frequencies
    let m = new Map();
    for (i = 0; i < n; i++) {
        if (m.has(arr[i])) {
            m.set(arr[i], m.get(arr[i]) + 1)
        } else[
            m.set(arr[i], 1)
        ]
    }
  
    let sum = 0;
  
    // Traverse the map using iterators
    for (let it of m) {
  
        // Calculate the sum of elements
        // having frequencies greater than
        // or equal to the element itself
        if ((it[1]) >= (it[0])) {
            sum += (it[0]);
        }
    }
  
    return sum;
}
  
// Driver code
let arr = [1, 2, 3, 3, 2, 3, 2, 3, 3];
let n = arr.length;
  
document.write(sumOfElements(arr, n));
  
// This code is contributed by gfgking.
</script>


Output

6

Time complexity: O(n)

Auxiliary Space: O(n)

Method #2:Using Built in python functions:

Approach:

  • Calculate the frequencies using Counter() function
  • Calculate the sum of elements having frequencies greater than or equal to that element.

C++




#include <iostream>
#include <map>
using namespace std;
  
int sumOfElements(int arr[], int n){
  
    // Map is used to calculate frequency of elements of array
    map<int, int> m;
    for(int i = 0; i < n; i++){
        if(m.find(arr[i]) != m.end()){
            m[arr[i]]++;
        } else {
            m[arr[i]] = 1;
        }
    }
  
    int sum = 0;
  
    // Traverse the map
    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;
}
  
int main(){
    int arr[] = {1, 2, 3, 3, 2, 3, 2, 3, 3};
    int n = sizeof(arr)/sizeof(arr[0]);
  
    cout << sumOfElements(arr, n) << endl;
  
    return 0;
}


Java




// Java program for the above approach
import java.util.HashMap;
  
class Main {
  
    // Function to return the sum of elements
    // in an array having frequency greater
    // than or equal to that element
    public static int sumOfElements(int[] arr, int n)
    {
  
        // HashMap is used to calculate frequency of
        // elements of array
        HashMap<Integer, Integer> m
            = new HashMap<Integer, Integer>();
        for (int i = 0; i < n; i++) {
            if (m.containsKey(arr[i])) {
                m.put(arr[i], m.get(arr[i]) + 1);
            }
            else {
                m.put(arr[i], 1);
            }
        }
  
        int sum = 0;
  
        // Traverse the HashMap
        for (Integer key : m.keySet()) {
  
            // Calculate the sum of elements
            // having frequencies greater than
            // or equal to the element itself
            if (m.get(key) >= key) {
                sum += 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;
  
        System.out.println(sumOfElements(arr, n));
    }
}
  
// This code is contributed by phasing17


Python3




# Python program for the above approach
from collections import Counter
  
# Function to return the sum of elements
# in an array having frequency greater
# than or equal to that element
def sumOfElements(arr, n):
  
    # Counter function is used to 
    # calculate frequency of elements of array
    m = Counter(arr)
  
    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 vikkycirus


C#




using System;
using System.Collections.Generic;
  
class MainClass 
{
  
  // Function to return the sum of elements
  // in an array having frequency greater
  // than or equal to that element
  public static int SumOfElements(int[] arr, int n)
  {
  
    // Dictionary is used to calculate frequency of
    // elements of array
    Dictionary<int, int> m = new Dictionary<int, int>();
    for (int i = 0; i < n; i++) {
      if (m.ContainsKey(arr[i])) {
        m[arr[i]]++;
      } else {
        m.Add(arr[i], 1);
      }
    }
  
    int sum = 0;
  
    // Traverse the Dictionary
    foreach (KeyValuePair<int, int> kvp in m) {
      // Calculate the sum of elements
      // having frequencies greater than
      // or equal to the element itself
      if (kvp.Value >= kvp.Key) {
        sum += kvp.Key;
      }
    }
  
    return sum;
  }
  
  // Driver code
  public static void Main() {
    int[] arr = { 1, 2, 3, 3, 2, 3, 2, 3, 3 };
    int n = arr.Length;
  
    Console.WriteLine(SumOfElements(arr, n));
  }
}


Javascript




function sumOfElements(arr, n){
  
    // Map function is used to calculate frequency of elements of array
    let m = new Map();
    for(let i = 0; i < n; i++){
        if(m.has(arr[i])){
            m.set(arr[i], m.get(arr[i])+1);
        } else {
            m.set(arr[i], 1);
        }
    }
  
    let sum = 0;
  
    // traverse the Map
    for(let [key, value] of m){
  
        // Calculate the sum of elements
        // having frequencies greater than
        // or equal to the element itself
        if(value >= key){
            sum += key;
        }
    }
  
    return sum;
}
  
// Driver code
let arr = [1, 2, 3, 3, 2, 3, 2, 3, 3];
let n = arr.length;
  
console.log(sumOfElements(arr, n));


Output

6

Time Complexity: O(n)

Auxiliary Space: O(n)



Last Updated : 19 Apr, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads