Difference between sum of odd and even frequent elements in an Array

Difficulty Level : Expert
Last Updated : 04 Feb, 2021

Given an array arr[] of integers, the task is to find the absolute difference between the sum of all odd frequent array elements and the sum of all even frequent array elements.

Examples:

Input: arr[] = {1, 5, 5, 2, 4, 3, 3}
Output: 9
Explanation:
The even frequent elements are 5 and 3 (both occurring twice).
Therefore, sum of all even frequent elements = 5 + 5 + 3 + 3 = 16.
The odd frequent elements are 1, 2 and 4 (each occurring once).
Therefore, sum of all odd frequent elements = 1 + 2 + 4 = 7.
Difference between their sum = 16 – 7 = 9.

Input: arr[] = {1, 1, 2, 2, 3, 3}
Output: 12
Explanation:
The even frequent array elements are 1, 2 and 3 (occurring twice).
Therefore, sum of all even frequent elements = 12.
Since there is no odd frequent element present in the array, difference = 12 – 0 = 12

Approach: Follow the steps below to solve the problem:

Initialize an unordered_map to store the frequency of array elements.
Traverse the array and update the frequency of array elements in the Map.
Then, traverse the map and add the elements having even frequency to a variable, say sum_even, and the ones with odd frequencies to another variable, say sum_odd.
Finally, print the difference between sum_odd and sum_even.

Below is the implementation of the above approach:

C++

// C++ program to find absolute difference 
// between the sum of all odd frequenct and 
// even frequent elements in an array 
 
#include <bits/stdc++.h> 
using namespace std; 
 
// Function to find the sum of all even 
// and odd frequent elements in an array 
int findSum(int arr[], int N) 
{ 
    // Stores the frequency of array elements 
    unordered_map<int, int> mp; 
 
    // Traverse the array 
    for (int i = 0; i < N; i++) { 
 
        // Update frequency of 
        // current element 
        mp[arr[i]]++; 
    } 
 
    // Stores sum of odd and even 
    // frequent elements 
    int sum_odd = 0, sum_even = 0; 
 
    // Traverse the map 
    for (auto itr = mp.begin(); 
        itr != mp.end(); itr++) { 
 
        // If frequency is odd 
        if (itr->second % 2 != 0) 
 
            // Add sum of all occurrences of 
            // current element to sum_odd 
            sum_odd += (itr->first) 
                    * (itr->second); 
 
        // If frequency is even 
        if (itr->second % 2 == 0) 
 
            // Add sum of all occurrences of 
            // current element to sum_even 
            sum_even += (itr->first) 
                        * (itr->second); 
    } 
 
    // Calculate difference 
    // between their sum 
    int diff = sum_even - sum_odd; 
 
    // Return diff 
    return diff; 
} 
 
// Driver Code 
int main() 
{ 
    int arr[] = { 1, 5, 5, 2, 4, 3, 3 }; 
    int N = sizeof(arr) / sizeof(arr[0]); 
    cout << findSum(arr, N); 
 
    return 0; 
}

Java

// Java program to find absolute difference 
// between the sum of all odd frequenct and 
// even frequent elements in an array 
import java.util.*;
import java.io.*;
import java.math.*;
 
class GFG{
     
// Function to find the sum of all even 
// and odd frequent elements in an array 
static int findSum(int arr[], int N) 
{ 
     
    // Stores the frequency of array elements 
    Map<Integer,
        Integer> map = new HashMap<Integer,
                                   Integer>();
                                    
    // Traverse the array 
    for(int i = 0; i < N; i++)
    { 
         
        // Update frequency of 
        // current element 
        if (!map.containsKey(arr[i]))
            map.put(arr[i], 1);
        else
            map.replace(arr[i], map.get(arr[i]) + 1);
    } 
     
    // Stores sum of odd and even 
    // frequent elements 
    int sum_odd = 0, sum_even = 0; 
 
    // Traverse the map 
    Set<Map.Entry<Integer, Integer>> hmap = map.entrySet();
    for(Map.Entry<Integer, Integer> data:hmap)
    {
        int key = data.getKey();
        int val = data.getValue();
         
        // If frequency is odd 
        if (val % 2 != 0) 
         
            // Add sum of all occurrences of 
            // current element to sum_odd 
            sum_odd += (key) * (val); 
 
        // If frequency is even 
        if (val % 2 == 0) 
         
            // Add sum of all occurrences of 
            // current element to sum_even 
            sum_even += (key) * (val); 
    } 
     
    // Calculate difference 
    // between their sum 
    int diff = sum_even - sum_odd; 
 
    // Return diff 
    return diff; 
} 
 
// Driver Code 
public static void main(String args[]) 
{ 
    int arr[] = { 1, 5, 5, 2, 4, 3, 3 }; 
    int N = arr.length;
     
    System.out.println(findSum(arr, N)); 
}
}
 
// This code is contributed by jyoti369

Python3

# Python3 program to find absolute difference 
# between the sum of all odd frequenct and 
# even frequent elements in an array
 
# Function to find the sum of all even 
# and odd frequent elements in an array 
def findSum(arr, N):
     
    # Stores the frequency of array elements
    mp = {}
     
    # Traverse the array
    for i in range(0, N):
         
        # Update frequency of
        # current element
        if arr[i] in mp:
            mp[arr[i]] += 1
        else:
            mp[arr[i]] = 1
             
    # Stores sum of odd and even
    # frequent elements
    sum_odd, sum_even = 0, 0
     
    # Traverse the map
    for itr in mp:
         
        # If frequency is odd
        if (mp[itr] % 2 != 0):
             
            # Add sum of all occurrences of
            # current element to sum_odd
            sum_odd += (itr) * (mp[itr])
             
        # If frequency is even
        if (mp[itr] % 2 == 0):
             
            # Add sum of all occurrences of
            # current element to sum_even
            sum_even += (itr) * (mp[itr])
             
    # Calculate difference
    # between their sum
    diff = sum_even - sum_odd
     
    # Return diff
    return diff
 
# Driver code
arr = [ 1, 5, 5, 2, 4, 3, 3 ] 
N = len(arr)
 
print(findSum(arr, N))
 
# This code is contributed by divyeshrabadiya07

C#

// C# program to find absolute difference 
// between the sum of all odd frequenct and 
// even frequent elements in an array 
using System;
using System.Collections.Generic; 
class GFG {
     
    // Function to find the sum of all even 
    // and odd frequent elements in an array 
    static int findSum(int[] arr, int N) 
    { 
        // Stores the frequency of array elements
        Dictionary<int, int> mp = new Dictionary<int, int>();
      
        // Traverse the array 
        for (int i = 0; i < N; i++) { 
      
            // Update frequency of 
            // current element 
            if(mp.ContainsKey(arr[i]))
            {
                mp[arr[i]]++;
            }
            else{
                mp[arr[i]] = 1;
            } 
        } 
      
        // Stores sum of odd and even 
        // frequent elements 
        int sum_odd = 0, sum_even = 0; 
      
        // Traverse the map 
        foreach(KeyValuePair<int, int> itr in mp) {
      
            // If frequency is odd 
            if (itr.Value % 2 != 0) 
      
                // Add sum of all occurrences of 
                // current element to sum_odd 
                sum_odd += (itr.Key) 
                        * (itr.Value); 
      
            // If frequency is even 
            if (itr.Value % 2 == 0) 
      
                // Add sum of all occurrences of 
                // current element to sum_even 
                sum_even += (itr.Key) 
                            * (itr.Value); 
        } 
      
        // Calculate difference 
        // between their sum 
        int diff = sum_even - sum_odd; 
      
        // Return diff 
        return diff; 
    } 
 
  // Driver code
  static void Main()
  {
    int[] arr = { 1, 5, 5, 2, 4, 3, 3 }; 
    int N = arr.Length;
    Console.Write(findSum(arr, N));
  }
}
 
// This code is contributed by divyesh072019.

Output:

Time Complexity: O(N)
Auxiliary Space: 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

Related Articles

C++

Java

Python3

C#