Sum of Bitwise OR of all pairs in a given array
Given an array “arr[0..n-1]” of integers. The task is to calculate the sum of Bitwise OR of all pairs, i.e. calculate the sum of “arr[i] | arr[j]” for all the pairs in the given array where i < j. Here ‘|’ is a bitwise OR operator. The expected time complexity is O(n).
Examples:
Input: arr[] = {5, 10, 15}
Output: 15
Required Value = (5 | 10) + (5 | 15) + (10 | 15)
= 15 + 15 + 15
= 45
Input: arr[] = {1, 2, 3, 4}
Output: 3
Required Value = (1 | 2) + (1 | 3) + (1 | 4) +
(2 | 3) + (2 | 4) + (3 | 4)
= 3 + 3 + 5 + 3 + 6 + 7
= 27
Approach 1: Brute Force
Here we will be running two loops
C++
#include <bits/stdc++.h>
using namespace std;
int pairORSum( int arr[], int n)
{
int ans = 0;
for ( int i = 0; i < n; i++)
for ( int j = i + 1; j < n; j++)
ans += arr[i] | arr[j];
return ans;
}
int main()
{
int arr[] = { 1, 2, 3, 4 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << pairORSum(arr, n) << endl;
return 0;
}
|
Java
import java.io.*;
class GFG {
static int pairORSum( int arr[], int n)
{
int ans = 0 ;
for ( int i = 0 ; i < n; i++)
for ( int j = i + 1 ; j < n; j++)
ans += arr[i] | arr[j];
return ans;
}
public static void main(String args[])
{
int arr[] = { 1 , 2 , 3 , 4 };
int n = arr.length;
System.out.println(pairORSum(arr, n));
}
}
|
Python3
def pairORSum(arr, n) :
ans = 0
for i in range ( 0 , n) :
for j in range ((i + 1 ), n) :
ans = ans + arr[i] | arr[j]
return ans
arr = [ 1 , 2 , 3 , 4 ]
n = len (arr)
print (pairORSum(arr, n))
|
C#
using System;
class GFG {
static int pairORSum( int [] arr, int n)
{
int ans = 0;
for ( int i = 0; i < n; i++)
for ( int j = i + 1; j < n; j++)
ans += arr[i] | arr[j];
return ans;
}
public static void Main()
{
int [] arr = { 1, 2, 3, 4 };
int n = arr.Length;
Console.Write(pairORSum(arr, n));
}
}
|
PHP
<?php
function pairORSum( $arr , $n )
{
$ans = 0;
for ( $i = 0; $i < $n ; $i ++)
for ( $j = $i + 1; $j < $n ; $j ++)
$ans += $arr [ $i ] | $arr [ $j ];
return $ans ;
}
$arr = array (1, 2, 3, 4);
$n = sizeof( $arr ) ;
echo pairORSum( $arr , $n ), "\n" ;
?>
|
Javascript
<script>
function pairORSum(arr, n)
{
var ans = 0;
for ( var i = 0; i < n; i++)
for ( var j = i + 1; j < n; j++)
ans += arr[i] | arr[j];
return ans;
}
var arr = [1, 2, 3, 4];
var n = arr.length;
document.write( pairORSum(arr, n));
</script>
|
Output:
27
Time Complexity: O(n2) // since two loops are used so the algorithm runs for n*n times
Auxiliary Space: O(1) // since no extra array is used so the solution takes constant space
Approach 2: Efficient Solution
It can solve this problem in O(n) time. The assumption here is that integers are represented using 32 bits.
The idea is to count number of set bits at every i’th position (i>=0 && i<=31). Any i’th bit of the AND of two numbers is 1 if the corresponding bit in both the numbers is equal to 1.
Let k1 be the count of set bits at i’th position. Total number of pairs with i’th set bit would be k1C2 = k1*(k1-1)/2 (Count k1 means there are k1 numbers that have i’th set bit). Every such pair adds 2i to total sum. Similarly, there are total k0 values that don’t have set bits at i’th position. Now each element (which have not set the bit at the i’th position can make pair with k1 elements (ie., those elements which have set bits at the i’th position), So there are total k1 * k0 pairs and every such pair also adds 2i to total sum.
sum = sum + (1<<i) * (k1*(k1-1)/2) + (1<<i) * (k1*k0)
This idea is similar to finding sum of bit differences among all pairs.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
typedef long long int LLI;
LLI pairORSum(LLI arr[], LLI n)
{
LLI ans = 0;
for (LLI i = 0; i < 32; i++) {
LLI k1 = 0;
LLI k0 = 0;
for (LLI j = 0; j < n; j++) {
if ((arr[j] & (1 << i)))
k1++;
else
k0++;
}
ans = ans + (1 << i) * (k1 * (k1 - 1) / 2) + (1 << i) * (k1 * k0);
}
return ans;
}
int main()
{
LLI arr[] = { 1, 2, 3, 4 };
LLI n = sizeof (arr) / sizeof (arr[0]);
cout << pairORSum(arr, n) << endl;
return 0;
}
|
Java
import java.io.*;
class GFG {
static int pairORSum( int arr[], int n)
{
int ans = 0 ;
for ( int i = 0 ; i < 32 ; i++) {
int k1 = 0 ;
int k0 = 0 ;
for ( int j = 0 ; j < n; j++) {
if ((arr[j] & ( 1 << i)) != 0 )
k1++;
else
k0++;
}
ans = ans + ( 1 << i) * (k1 * (k1 - 1 ) / 2 ) + ( 1 << i) * (k1 * k0);
}
return ans;
}
public static void main(String args[])
{
int arr[] = { 1 , 2 , 3 , 4 };
int n = arr.length;
System.out.println(pairORSum(arr, n));
}
}
|
Python3
def pairORSum(arr, n) :
ans = 0
for i in range ( 0 , 32 ) :
k1 = 0
k0 = 0
for j in range ( 0 , n) :
if ( (arr[j] & ( 1 <<i)) ):
k1 = k1 + 1
else :
k0 = k0 + 1
ans = ans + ( 1 <<i) * (k1 * (k1 - 1 ) / / 2 ) + ( 1 <<i) * (k1 * k0)
return ans
arr = [ 1 , 2 , 3 , 4 ]
n = len (arr)
print (pairORSum(arr, n))
|
C#
using System;
class GFG {
static int pairORSum( int [] arr, int n)
{
int ans = 0;
for ( int i = 0; i < 32; i++) {
int k1 = 0;
int k0 = 0;
for ( int j = 0; j < n; j++) {
if ((arr[j] & (1 << i)) != 0)
k1++;
else
k0++;
}
ans = ans + (1 << i) * (k1 * (k1 - 1) / 2) + (1 << i) * (k1 * k0);
}
return ans;
}
public static void Main()
{
int [] arr = new int [] { 1, 2, 3, 4 };
int n = arr.Length;
Console.Write(pairORSum(arr, n));
}
}
|
PHP
<?php
function pairORSum( $arr , $n )
{
$ans = 0;
for ( $i = 0; $i < 32; $i ++){
$k1 = 0;
$k0 = 0;
for ( $j = 0; $j < $n ; $j ++){
if ( ( $arr [ $j ] & (1 << $i )))
$k1 ++;
else
$k0 ++;
}
$ans = $ans + (1<< $i ) * ( $k1 *( $k1 -1)/2) + (1<< $i ) * ( $k1 * $k0 ) ;
}
return $ans ;
}
$arr = array (1, 2, 3, 4);
$n = sizeof( $arr );
echo pairORSum( $arr , $n ) ;
?>
|
Javascript
<script>
function pairORSum( arr, n)
{
var ans = 0;
for ( var i = 0; i < 32; i++) {
var k1 = 0;
var k0 = 0;
for ( var j = 0; j < n; j++) {
if ((arr[j] & (1 << i)))
k1++;
else
k0++;
}
ans = ans + (1 << i) * (k1 * (k1 - 1) / 2) +
(1 << i) * (k1 * k0);
}
return ans;
}
var arr = [1, 2, 3, 4];
var n = arr.length;
document.write( pairORSum(arr, n));
</script>
|
Output:
27
Time Complexity: O(n * 32) //since for every element in array another array operates 32 times thus the overall algorithm takes O(n*32) time.
Auxiliary Space: O(1) // since no extra array is used so the solution takes constant space.
Last Updated :
13 Oct, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...