Minimizing array sum by applying XOR operation on all elements of the array

Given an array arr[] of N integer elements, the task is to choose an element X and apply XOR operation on every element of the array with X such that array sum is minimized.

Input: arr[] = {3, 5, 7, 11, 15}
Output: 26
Binary representation of the array elements are {0011, 0101, 0111, 1011, 1111}
We take xor of every element with 7 in order to minimize the sum.
3 XOR 7 = 0100 (4)
5 XOR 7 = 0010 (2)
7 XOR 7 = 0000 (0)
11 XOR 7 = 1100 (12)
15 XOR 7 = 1000 (8)
Sum = 4 + 2 + 0 + 12 + 8 = 26

Input: arr[] = {1, 2, 3, 4, 5}
Output: 14

Approach: The task is to find the element X with which we have to take xor of each element.

  • Convert each number into binary form and update the frequency of bit (0 or 1) in array corresponding to position of each bit in element in array.
  • Now, Traverse the array and check whether element at index is more than n/2 (for ‘n’ elements, we check whether the set bit appears more than n/2 at index) and subsequently we obtain element ‘X’
  • Now, take xor of ‘X’ with all the elements and return the sum.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
const int MAX = 25;
  
// Function to return the minimized sum
int getMinSum(int arr[], int n)
{
    int bits_count[MAX], max_bit = 0, sum = 0, ans = 0;
  
    memset(bits_count, 0, sizeof(bits_count));
  
    // To store the frequency
    // of bit in every element
    for (int d = 0; d < n; d++) {
        int e = arr[d], f = 0;
        while (e > 0) {
            int rem = e % 2;
            e = e / 2;
            if (rem == 1) {
                bits_count[f] += rem;
            }
            f++;
        }
        max_bit = max(max_bit, f);
    }
  
    // Finding element X
    for (int d = 0; d < max_bit; d++) {
        int temp = pow(2, d);
        if (bits_count[d] > n / 2)
            ans = ans + temp;
    }
  
    // Taking XOR of elements and finding sum
    for (int d = 0; d < n; d++) {
        arr[d] = arr[d] ^ ans;
        sum = sum + arr[d];
    }
    return sum;
}
  
// Driver code
int main()
{
    int arr[] = { 3, 5, 7, 11, 15 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    cout << getMinSum(arr, n);
  
    return 0;
}

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// Java implementation of the approach 


class GFG { 


  


    static int MAX = 25; 


  


    // Function to return the minimized sum 


    static int getMinSum(int arr[], int n) 


    { 


        int bits_count[] = new int[MAX], 


            max_bit = 0, sum = 0, ans = 0; 


  


        // To store the frequency 


        // of bit in every element 


        for (int d = 0; d < n; d++) { 


            int e = arr[d], f = 0; 


            while (e > 0) { 


                int rem = e % 2; 


                e = e / 2; 


                if (rem == 1) { 


                    bits_count[f] += rem; 


                } 


                f++; 


            } 


            max_bit = Math.max(max_bit, f); 


        } 


  


        // Finding element X 


        for (int d = 0; d < max_bit; d++) { 


            int temp = (int)Math.pow(2, d); 


            if (bits_count[d] > n / 2) 


                ans = ans + temp; 


        } 


  


        // Taking XOR of elements and finding sum 


        for (int d = 0; d < n; d++) { 


            arr[d] = arr[d] ^ ans; 


            sum = sum + arr[d]; 


        } 


        return sum; 


    } 


  


    // Driver code 


    public static void main(String[] args) 


    { 


        int arr[] = { 3, 5, 7, 11, 15 }; 


        int n = arr.length; 


        System.out.println(getMinSum(arr, n)); 


    } 


} 


  


// This code has been contributed by 29AjayKumar 



















                        chevron_right







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# Python3 implementation of the approach 


  


MAX = 25;  


  


# Function to return the minimized sum  


def getMinSum(arr, n) : 


    bits_count = [0]* MAX


    max_bit = 0; sum = 0; ans = 0;  


  


    # To store the frequency  


    # of bit in every element  


    for d in range(n) : 


        e = arr[d]; f = 0;  


        while (e > 0) : 


            rem = e % 2;  


            e = e // 2;  


            if (rem == 1) : 


                bits_count[f] += rem;  


                  


            f += 1 


              


        max_bit = max(max_bit, f);  


      


  


    # Finding element X  


    for d in range(max_bit) : 


        temp = pow(2, d);  


          


        if (bits_count[d] > n // 2) : 


            ans = ans + temp;  


  


  


    # Taking XOR of elements and finding sum  


    for d in range(n) :  


        arr[d] = arr[d] ^ ans;  


        sum = sum + arr[d];  


      


    return sum 


      


  


# Driver code  


if __name__ == "__main__" :  


  


    arr = [ 3, 5, 7, 11, 15 ];  


    n = len(arr);  


  


    print(getMinSum(arr, n)) 


  


# This code is contributed by Ryuga 



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// C# implementation of the approach 


using System; 


  


class GFG { 


  


    static int MAX = 25; 


  


    // Function to return the minimized sum 


    static int getMinSum(int[] arr, int n) 


    { 


        int[] bits_count = new int[MAX]; 


        int max_bit = 0, sum = 0, ans = 0; 


  


        // To store the frequency 


        // of bit in every element 


        for (int d = 0; d < n; d++) { 


            int e = arr[d], f = 0; 


            while (e > 0) { 


                int rem = e % 2; 


                e = e / 2; 


                if (rem == 1) { 


                    bits_count[f] += rem; 


                } 


                f++; 


            } 


            max_bit = Math.Max(max_bit, f); 


        } 


  


        // Finding element X 


        for (int d = 0; d < max_bit; d++) { 


            int temp = (int)Math.Pow(2, d); 


            if (bits_count[d] > n / 2) 


                ans = ans + temp; 


        } 


  


        // Taking XOR of elements and finding sum 


        for (int d = 0; d < n; d++) { 


            arr[d] = arr[d] ^ ans; 


            sum = sum + arr[d]; 


        } 


        return sum; 


    } 


  


    // Driver code 


    public static void Main(String[] args) 


    { 


        int[] arr = { 3, 5, 7, 11, 15 }; 


        int n = arr.Length; 


        Console.WriteLine(getMinSum(arr, n)); 


    } 


} 


  


/* This code contributed by PrinciRaj1992 */



















                        chevron_right







                        filter_none











Output:


26






          
          
          
          

            

    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
everythingispossible
Check out this Author's contributed articles.
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you find anything incorrect by clicking on  the "Improve Article" button below.