Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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

  • Difficulty Level : Expert
  • Last Updated : 21 Nov, 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:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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: 

Below is the implementation of the above approach:

C++




// C++ program to find absolute difference
// between the sum of all odd frequent 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.
Javascript



<script>
 
// JavaScript 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
function findSum(arr, N)
{
    // Stores the frequency of array elements
    var mp = {};
    for(let i =0; i<N;i++)
      mp[arr[i]] = 0;
 
    // Traverse the array
    for (let i = 0; i < N; i++) {
 
        // Update frequency of
        // current element
        mp[arr[i]]++;
    }
 
    // Stores sum of odd and even
    // frequent elements
    var sum_odd = 0, sum_even = 0;
 
 
    // Traverse the map
    for (let 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
    var diff = sum_even - sum_odd;
 
    // Return diff
    return diff;
}
 
// Driver Code
 
var arr = new Array( 1, 5, 5, 2, 4, 3, 3 );
var N = arr.length;
console.log( findSum(arr, N) );
 
// This code is contributed by ukasp. 
 
</script>
Output:
9
Time Complexity: O(N)
Auxiliary Space: O(N)



My Personal Notes
arrow_drop_up
Next

Find the value of XXXX.....(N times) % M where N is large
Recommended Articles
Page :
Absolute difference between sum of even elements at even indices & odd elements at odd indices in given Array
04, Dec 21
Minimum distance between any most frequent and least frequent element of an array
13, Jul 20
Find the nearest odd and even perfect squares of odd and even array elements respectively
05, Mar 21
Sum of Array Divisible by Size with Even and Odd Numbers at Odd and Even Index in Java
02, Dec 20
Even numbers at even index and odd numbers at odd index
28, Oct 17
Check if a number has an odd count of odd divisors and even count of even divisors
20, Aug 20
Modify Binary Tree by replacing all nodes at even and odd levels by their nearest even or odd perfect squares respectively
22, Feb 21
Count of integers in a range which have even number of odd digits and odd number of even digits
21, Aug 19
Count numbers from given range having odd digits at odd places and even digits at even places
02, Dec 20
Make all the elements of array odd by incrementing odd-indexed elements of odd-length subarrays
16, Dec 20
Difference between sum of K maximum even and odd array elements
29, Oct 20
Sum of maximum of all subarrays by adding even frequent maximum twice
20, Dec 20
Find the Array Permutation having sum of elements at odd indices greater than sum of elements at even indices
07, Jul 21
Construct an Array of size N in which sum of odd elements is equal to sum of even elements
22, Apr 20
Count possible removals to make absolute difference between the sum of odd and even indexed elements equal to K
10, Dec 20
Maximize difference between sum of even and odd-indexed elements of a subsequence
17, Jan 21
Maximize difference between sum of even and odd-indexed elements of a subsequence | Set 2
10, Nov 21
Check if the sum of K least and most frequent array elements are equal or not
26, Jul 21
Maximize difference between odd and even indexed array elements by shift operations
01, Feb 21
Maximize difference between odd and even indexed array elements by swapping unequal adjacent bits in their binary representations
22, Feb 21
Maximize difference between odd and even-indexed array elements by rotating their binary representations
20, Apr 21
Print indices of array elements whose removal makes the sum of odd and even-indexed elements equal
11, Dec 20
Minimize the maximum difference of any pair by doubling odd elements and reducing even elements by half
20, Dec 20
Generate an array consisting of most frequent greater elements present on the right side of each array element
16, May 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
patelajeet
@patelajeet
Vote for difficulty
Current difficulty :
Expert





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!