We are given an array of n elements. The task is to make XOR of whole array 0. We can do the following to achieve this.
- We can select any one of the elements.
- After selecting an element, we can either increment or decrement it by 1.
We need to find the minimum number of increment/decrement operations required for the selected element to make the XOR sum of the whole array zero.
Examples:
Input : arr[] = {2, 4, 8}
Output : Element = 8,
Operation required = 2
Explanation : Select 8 as element and perform 2
time decrement on it. So that it
became 6, Now our array is {2, 4, 6}
whose XOR sum is 0.
Input : arr[] = {1, 1, 1, 1}
Output : Element = 1,
Operation required = 0
Explanation : Select any of 1 and you have already
your XOR sum = 0. So, no operation
required.
Naive Approach: Select an element and then find the XOR of the rest of the array. If that element became equals to XOR obtained then our XOR of the whole array should become zero. Now, our cost for that will be the absolute difference between the selected element and obtained XOR. This process of finding cost will be done for each element and thus resulting in Time Complexity of (n^2).
Efficient Approach: Find the XOR of the whole array. Now, suppose we have selected element arr[i], so cost required for that element will be absolute(arr[i]-(XORsum^arr[i])). Calculating the minimum of these absolute values for each element will be our minimum required operation also the element corresponding to the minimum required operation will be our selected element.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
void minCost( int arr[], int n)
{
int cost = INT_MAX;
int element;
int XOR = 0;
for ( int i = 0; i < n; i++)
XOR ^= arr[i];
for ( int i = 0; i < n; i++) {
if (cost > abs ((XOR ^ arr[i]) - arr[i])) {
cost = abs ((XOR ^ arr[i]) - arr[i]);
element = arr[i];
}
}
cout << "Element = " << element << endl;
cout << "Operation required = " << abs (cost);
}
int main()
{
int arr[] = { 2, 8, 4, 16 };
int n = sizeof (arr) / sizeof (arr[0]);
minCost(arr, n);
return 0;
}
|
Java
import java.lang.*;
class GFG
{
static void minCost( int [] arr, int n)
{
int cost = Integer.MAX_VALUE;
int element= 0 ;
int XOR = 0 ;
for ( int i = 0 ; i < n; i++)
XOR ^= arr[i];
for ( int i = 0 ; i < n; i++) {
if (cost > Math.abs((XOR ^ arr[i])
- arr[i])) {
cost = Math.abs((XOR ^ arr[i]) -
arr[i]);
element = arr[i];
}
}
System.out.println( "Element = " + element);
System.out.println( "Operation required = " +
Math.abs(cost));
}
public static void main (String[] args)
{
int [] arr = { 2 , 8 , 4 , 16 };
int n = arr.length;
minCost(arr, n);
}
}
|
Python3
def minCost(arr,n):
cost = 999999 ;
XOR = 0 ;
for i in range ( 0 , n):
XOR ^ = arr[i];
for i in range ( 0 ,n):
if (cost > abs ((XOR ^ arr[i]) - arr[i])):
cost = abs ((XOR ^ arr[i]) - arr[i])
element = arr[i]
print ( "Element = " , element)
print ( "Operation required = " , abs (cost))
arr = [ 2 , 8 , 4 , 16 ]
n = len (arr)
minCost(arr, n)
|
C#
using System;
class GFG
{
static void minCost( int []arr, int n)
{
int cost = int .MaxValue;
int element=0;
int XOR = 0;
for ( int i = 0; i < n; i++)
XOR ^= arr[i];
for ( int i = 0; i < n; i++)
{
if (cost > Math.Abs((XOR ^ arr[i]) - arr[i]))
{
cost = Math.Abs((XOR ^ arr[i]) - arr[i]);
element = arr[i];
}
}
Console.WriteLine( "Element = " + element);
Console.Write( "Operation required = " +
Math.Abs(cost));
}
public static void Main ()
{
int []arr = {2, 8, 4, 16};
int n = arr.Length;
minCost(arr, n);
}
}
|
Javascript
<script>
function minCost(arr, n)
{
var cost = 1000000000;
var element;
var XOR = 0;
for ( var i = 0; i < n; i++)
XOR ^= arr[i];
for ( var i = 0; i < n; i++) {
var x= Math.abs((XOR ^ arr[i]) - arr[i])
if (cost > x) {
cost = x;
element = arr[i];
}
}
document.write( "Element = " + element + "<br>" );
document.write( "Operation required = " + Math.abs(cost));
}
var arr = [ 2, 8, 4, 16 ];
var n = arr.length;
minCost(arr, n);
</script>
|
PHP
<?php
function minCost( $arr , $n )
{
$cost = PHP_INT_MAX;
$element ;
$XOR = 0;
for ( $i = 0; $i < $n ; $i ++)
$XOR ^= $arr [ $i ];
for ( $i = 0; $i < $n ; $i ++)
{
if ( $cost > abs (( $XOR ^ $arr [ $i ]) -
$arr [ $i ]))
{
$cost = abs (( $XOR ^ $arr [ $i ]) -
$arr [ $i ]);
$element = $arr [ $i ];
}
}
echo "Element = " , $element , "\n" ;
echo "Operation required = " , abs ( $cost );
}
$arr = array (2, 8, 4, 16) ;
$n = count ( $arr );
minCost( $arr , $n );
?>
|
Output
Element = 16
Operation required = 2
Time Complexity : O(n)
Auxiliary space: O(1) it is using constant space
New Approach:
C++
#include <bits/stdc++.h>
using namespace std;
void minCost( int arr[], int n)
{
unordered_map< int , int > freq;
for ( int i = 0; i < n; i++) {
freq[arr[i]]++;
}
int max_freq = INT_MIN;
int max_elem = -1;
for ( auto it : freq) {
if (it.second > max_freq) {
max_freq = it.second;
max_elem = it.first;
}
}
int XOR = 0;
for ( int i = 0; i < n; i++) {
XOR ^= arr[i];
}
int cost = abs ((XOR ^ max_elem) - max_elem);
cout << "Element = " << max_elem << endl;
cout << "Operation required = " << abs (cost) << endl;
}
int main()
{
int arr[] = { 2, 8, 4, 16 };
int n = sizeof (arr) / sizeof (arr[0]);
minCost(arr, n);
return 0;
}
|
Java
import java.util.*;
public class MinCost {
public static void minCost( int [] arr, int n) {
HashMap<Integer, Integer> freq = new HashMap<>();
for ( int i = 0 ; i < n; i++) {
freq.put(arr[i], freq.getOrDefault(arr[i], 0 ) + 1 );
}
int maxFreq = Integer.MIN_VALUE;
int maxElem = - 1 ;
for (Integer elem : freq.keySet()) {
if (freq.get(elem) > maxFreq) {
maxFreq = freq.get(elem);
maxElem = elem;
}
}
int xor = 0 ;
for ( int i = 0 ; i < n; i++) {
xor ^= arr[i];
}
int cost = Math.abs((xor ^ maxElem) - maxElem);
System.out.println( "Element = " + maxElem);
System.out.println( "Operation required = " + Math.abs(cost));
}
public static void main(String[] args) {
int [] arr = { 2 , 8 , 4 , 16 };
int n = arr.length;
minCost(arr, n);
}
}
|
Python3
from collections import Counter
def min_cost(arr):
freq = Counter(arr)
max_freq = float ( '-inf' )
max_elem = - 1
for element, frequency in freq.items():
if frequency > max_freq:
max_freq = frequency
max_elem = element
XOR = 0
for element in arr:
XOR ^ = element
cost = abs ((XOR ^ max_elem) - max_elem)
print ( "Element =" , max_elem)
print ( "Operation required =" , abs (cost))
if __name__ = = "__main__" :
arr = [ 2 , 8 , 4 , 16 ]
min_cost(arr)
|
C#
using System;
using System.Collections.Generic;
public class Program
{
public static void MinCost( int [] arr)
{
Dictionary< int , int > freq = new Dictionary< int , int >();
for ( int i = 0; i < arr.Length; i++)
{
if (freq.ContainsKey(arr[i]))
freq[arr[i]]++;
else
freq[arr[i]] = 1;
}
int max_freq = int .MinValue;
int max_elem = -1;
foreach ( var kvp in freq)
{
if (kvp.Value > max_freq)
{
max_freq = kvp.Value;
max_elem = kvp.Key;
}
}
int XOR = 0;
for ( int i = 0; i < arr.Length; i++)
{
XOR ^= arr[i];
}
int cost = Math.Abs((XOR ^ max_elem) - max_elem);
Console.WriteLine( "Element = " + max_elem);
Console.WriteLine( "Operation required = " + Math.Abs(cost));
}
public static void Main()
{
int [] arr = { 2, 8, 4, 16 };
MinCost(arr);
}
}
|
Javascript
const freq = new Map();
function minCost(arr) {
for (let i = 0; i < arr.length; i++) {
if (freq.has(arr[i])) {
freq.set(arr[i], freq.get(arr[i]) + 1);
} else {
freq.set(arr[i], 1);
}
}
let max_freq = -Infinity;
let max_elem = -1;
for (let [key, value] of freq) {
if (value >= max_freq) {
max_freq = value;
max_elem = key;
}
}
let XOR = 0;
for (let i = 0; i < arr.length; i++) {
XOR ^= arr[i];
}
let cost = Math.abs((XOR ^ max_elem) - max_elem);
console.log( "Element = " + max_elem);
console.log( "Operation required = " + Math.abs(cost));
}
const arr = [2, 8, 4, 16];
minCost(arr);
|
Output
Element = 16
Operation required = 2
Time Complexity: O(n), where n is the size of the input array.
Auxiliary Space: O(n)