Sum of Bitwise OR of all pairs in a given array
Last Updated :
13 Oct, 2022
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
= 45Input: 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
= 27Approach 1: Brute Force
Here we will be running two loops
C++
// A Simple C++ program to compute sum of bitwise OR
// of all pairs
#include <bits/stdc++.h>
using namespace std;
// Returns value of "arr[0] | arr[1] + arr[0] | arr[2] +
// ... arr[i] | arr[j] + ..... arr[n-2] | arr[n-1]"
int pairORSum(int arr[], int n)
{
int ans = 0; // Initialize result
// Consider all pairs (arr[i], arr[j) such that
// i < j
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
ans += arr[i] | arr[j];
return ans;
}
// Driver program to test above function
int main()
{
int arr[] = { 1, 2, 3, 4 };
int n = sizeof(arr) / sizeof(arr[0]);
cout << pairORSum(arr, n) << endl;
return 0;
}
// A Simple Java program to compute
// sum of bitwise OR of all pairs
import java.io.*;
class GFG {
// Returns value of "arr[0] | arr[1] +
// arr[0] | arr[2] + ... arr[i] | arr[j] +
// ..... arr[n-2] | arr[n-1]"
static int pairORSum(int arr[], int n)
{
int ans = 0; // Initialize result
// Consider all pairs (arr[i], arr[j)
// such that i < j
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
ans += arr[i] | arr[j];
return ans;
}
// Driver program to test above function
public static void main(String args[])
{
int arr[] = { 1, 2, 3, 4 };
int n = arr.length;
System.out.println(pairORSum(arr, n));
}
}
# A Simple Python 3 program to compute
# sum of bitwise OR of all pairs
# Returns value of "arr[0] | arr[1] +
# arr[0] | arr[2] + ... arr[i] | arr[j] +
# ..... arr[n-2] | arr[n-1]"
def pairORSum(arr, n) :
ans = 0 # Initialize result
# Consider all pairs (arr[i], arr[j)
# such that i < j
for i in range(0, n) :
for j in range((i + 1), n) :
ans = ans + arr[i] | arr[j]
return ans
# Driver program to test above function
arr = [1, 2, 3, 4]
n = len(arr)
print(pairORSum(arr, n))
// A Simple C# program to compute
// sum of bitwise OR of all pairs
using System;
class GFG {
// Returns value of "arr[0] | arr[1] +
// arr[0] | arr[2] + ... arr[i] | arr[j] +
// ..... arr[n-2] | arr[n-1]"
static int pairORSum(int[] arr, int n)
{
int ans = 0; // Initialize result
// Consider all pairs (arr[i], arr[j)
// such that i < j
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
ans += arr[i] | arr[j];
return ans;
}
// Driver program to test above function
public static void Main()
{
int[] arr = { 1, 2, 3, 4 };
int n = arr.Length;
Console.Write(pairORSum(arr, n));
}
}
<?php
// A Simple PHP program to
// compute sum of bitwise
// OR of all pairs
// Returns value of "arr[0] |
// arr[1] + arr[0] | arr[2] +
// ... arr[i] | arr[j] + .....
// arr[n-2] | arr[n-1]"
function pairORSum($arr, $n)
{
// Initialize result
$ans = 0;
// Consider all pairs (arr[i],
// arr[j) such that i < j
for ($i = 0; $i < $n; $i++)
for ( $j = $i + 1; $j < $n; $j++)
$ans += $arr[$i] | $arr[$j];
return $ans;
}
// Driver Code
$arr = array(1, 2, 3, 4);
$n = sizeof($arr) ;
echo pairORSum($arr, $n), "\n";
?>
<script>
// A Simple Javascript program to compute sum of bitwise OR
// of all pairs
// Returns value of "arr[0] | arr[1] + arr[0] | arr[2] +
// ... arr[i] | arr[j] + ..... arr[n-2] | arr[n-1]"
function pairORSum(arr, n)
{
var ans = 0; // Initialize result
// Consider all pairs (arr[i], arr[j) such that
// i < j
for (var i = 0; i < n; i++)
for (var j = i + 1; j < n; j++)
ans += arr[i] | arr[j];
return ans;
}
// Driver program to test above function
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++
// An efficient C++ program to compute sum of bitwise OR
// of all pairs
#include <bits/stdc++.h>
using namespace std;
typedef long long int LLI;
// Returns value of "arr[0] | arr[1] + arr[0] | arr[2] +
// ... arr[i] | arr[j] + ..... arr[n-2] | arr[n-1]"
LLI pairORSum(LLI arr[], LLI n)
{
LLI ans = 0; // Initialize result
// Traverse over all bits
for (LLI i = 0; i < 32; i++) {
// Count number of elements with the i'th bit set(ie., 1)
LLI k1 = 0; // Initialize the count
// Count number of elements with i’th bit not-set(ie., 0) `
LLI k0 = 0; // Initialize the count
for (LLI j = 0; j < n; j++) {
if ((arr[j] & (1 << i))) // if i'th bit is set
k1++;
else
k0++;
}
// There are k1 set bits, means k1(k1-1)/2 pairs. k1C2
// There are k0 not-set bits and k1 set bits so total pairs will be k1*k0.
// Every pair adds 2^i to the answer. Therefore,
ans = ans + (1 << i) * (k1 * (k1 - 1) / 2) + (1 << i) * (k1 * k0);
}
return ans;
}
// Driver program to test the above function
int main()
{
LLI arr[] = { 1, 2, 3, 4 };
LLI n = sizeof(arr) / sizeof(arr[0]);
cout << pairORSum(arr, n) << endl;
return 0;
}
// An efficient Java program to compute
// sum of bitwise OR of all pairs
import java.io.*;
class GFG {
// Returns value of "arr[0] | arr[1] + arr[0] | arr[2] +
// ... arr[i] | arr[j] + ..... arr[n-2] | arr[n-1]"
static int pairORSum(int arr[], int n)
{
int ans = 0; // Initialize result
// Traverse over all bits
for (int i = 0; i < 32; i++) {
// Count number of elements with the ith bit set(ie., 1)
int k1 = 0; // Initialize the count
// Count number of elements with ith bit not-set(ie., 0) `
int k0 = 0; // Initialize the count
for (int j = 0; j < n; j++) {
if ((arr[j] & (1 << i)) != 0) // if i'th bit is set
k1++;
else
k0++;
}
// There are k1 set bits, means k1(k1-1)/2 pairs. k1C2
// There are k0 not-set bits and k1 set bits so total pairs will be k1*k0.
// Every pair adds 2^i to the answer. Therefore,
ans = ans + (1 << i) * (k1 * (k1 - 1) / 2) + (1 << i) * (k1 * k0);
}
return ans;
}
// Driver program to test above function
public static void main(String args[])
{
int arr[] = { 1, 2, 3, 4 };
int n = arr.length;
System.out.println(pairORSum(arr, n));
}
}
# An efficient Python 3 program to
# compute the sum of bitwise OR of all pairs
# Returns value of "arr[0] | arr[1] + arr[0] | arr[2] +
# ... arr[i] | arr[j] + ..... arr[n-2] | arr[n-1]"
def pairORSum(arr, n) :
# Initialize result
ans = 0
# Traverse over all bits
for i in range(0, 32) :
# Count number of elements with the i'th bit set(ie., 1)
k1 = 0
# Count number of elements with i’th bit not-set(ie., 0) `
k0 = 0
for j in range(0, n) :
if( (arr[j] & (1<<i)) ): # if i'th bit is set
k1 = k1 + 1
else :
k0 = k0 + 1
# There are k1 set bits, means k1(k1-1)/2 pairs. k1C2
# There are k0 not-set bits and k1 set bits so total pairs will be k1 * k0.
# Every pair adds 2 ^ i to the answer. Therefore,
ans = ans + (1<<i) * (k1*(k1-1)//2) + (1<<i) * (k1 * k0)
return ans
# Driver program to test above function
arr = [1, 2, 3, 4]
n = len(arr)
print(pairORSum(arr, n))
// An efficient C# program to compute
// sum of bitwise OR of all pairs
using System;
class GFG {
// Returns value of "arr[0] | arr[1] + arr[0] | arr[2] +
// ... arr[i] | arr[j] + ..... arr[n-2] | arr[n-1]"
static int pairORSum(int[] arr, int n)
{
int ans = 0; // Initialize result
// Traverse over all bits
for (int i = 0; i < 32; i++) {
// Count number of elements with the ith bit set(ie., 1)
int k1 = 0; // Initialize the count
// Count number of elements with ith bit not-set(ie., 0) `
int k0 = 0; // Initialize the count
for (int j = 0; j < n; j++) {
// if i'th bit is set
if ((arr[j] & (1 << i)) != 0)
k1++;
else
k0++;
}
// There are k1 set bits, means k1(k1-1)/2 pairs. k1C2
// There are k0 not-set bits and k1 set bits so total pairs will be k1*k0.
// Every pair adds 2^i to the answer. Therefore,
ans = ans + (1 << i) * (k1 * (k1 - 1) / 2) + (1 << i) * (k1 * k0);
}
return ans;
}
// Driver program to test above function
public static void Main()
{
int[] arr = new int[] { 1, 2, 3, 4 };
int n = arr.Length;
Console.Write(pairORSum(arr, n));
}
}
<?php
// An efficient PHP program to compute
// sum of bitwise OR of all pairs
// Returns value of "arr[0] | arr[1] + arr[0] | arr[2] +
// ... arr[i] | arr[j] + ..... arr[n-2] | arr[n-1]"
function pairORSum($arr, $n)
{
$ans = 0; // Initialize result
// Traverse over all bits
for ( $i = 0; $i < 32; $i++){
// Count number of elements with the ith bit set(ie., 1)
$k1 = 0; // Initialize the count
// Count number of elements with ith bit not-set(ie., 0) `
$k0 = 0; // Initialize the count
for ( $j = 0; $j < $n; $j++){
if ( ($arr[$j] & (1 << $i))) // if i'th bit is set
$k1++;
else
$k0++;
}
// There are k1 set bits, means k1(k1-1)/2 pairs. k1C2
// There are k0 not-set bits and k1 set bits so total pairs will be k1*k0.
// Every pair adds 2^i to the answer. Therefore,
$ans = $ans + (1<<$i) * ($k1*($k1-1)/2) + (1<<$i) * ($k1*$k0) ;
}
return $ans;
}
// Driver Code
$arr = array(1, 2, 3, 4);
$n = sizeof($arr);
echo pairORSum($arr, $n) ;
?>
<script>
// An efficient Javascript program
// to compute sum of bitwise OR
// of all pairs
// Returns value of "arr[0] | arr[1] + arr[0] | arr[2] +
// ... arr[i] | arr[j] + ..... arr[n-2] | arr[n-1]"
function pairORSum( arr, n)
{
var ans = 0; // Initialize result
// Traverse over all bits
for (var i = 0; i < 32; i++) {
// Count number of elements
// with the i'th bit set(ie., 1)
var k1 = 0; // Initialize the count
// Count number of elements with
// i’th bit not-set(ie., 0) `
var k0 = 0; // Initialize the count
for (var j = 0; j < n; j++) {
if ((arr[j] & (1 << i))) // if i'th bit is set
k1++;
else
k0++;
}
// There are k1 set bits,
// means k1(k1-1)/2 pairs. k1C2
// There are k0 not-set bits and
// k1 set bits so total pairs will be k1*k0.
// Every pair adds 2^i to the answer. Therefore,
ans = ans + (1 << i) * (k1 * (k1 - 1) / 2) +
(1 << i) * (k1 * k0);
}
return ans;
}
// Driver program to test the above function
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.
Similar Reads
Sum of Bitwise And of all pairs in a given array
Given an array "arr[0..n-1]" of integers, calculate sum of "arr[i] & arr[j]" for all the pairs in the given where i < j. Here & is bitwise AND operator. Expected time complexity is O(n). Examples : Input: arr[] = {5, 10, 15} Output: 15 Required Value = (5 & 10) + (5 & 15) + (10
13 min read
Maximize sum of LSBs of Bitwise OR of all possible N/2 pairs from given Array
Given an array arr[] consisting of N positive integers, where N is even, the task is to form N/2 pairs such that the sum of the Least Significant Bit of Bitwise OR of all these pairs is maximum. Examples: Input: arr[] = {1, 2, 3, 4, 5, 6, 7, 8}Output: 8Explanation:On forming the pairs as (8, 4),(6,
7 min read
Count of odd and even sum pairs in an array
Given an array arr[] of N positive integers, the task is to find the number of pairs with odd sum and the number of pairs with even sum.Examples: Input: arr[] = {1, 2, 3, 4, 5} Output: Odd pairs = 6 Even pairs = 4Input: arr[] = {7, 4, 3, 2} Output: Odd pairs = 4 Even pairs = 2 Naive Approach: The na
8 min read
Find XOR sum of Bitwise AND of all pairs from given two Arrays
Given two arrays A and B of sizes N and M respectively, the task is to calculate the XOR sum of bitwise ANDs of all pairs of A and B Examples: Input: A={3, 5}, B={2, 3}, N=2, M=2Output:0Explanation:The answer is (3&2)^(3&3)^(5&2)^(5&3)=1^3^0^2=0. Input: A={1, 2, 3}, B={5, 6}, N=3, M=
9 min read
Find bitwise OR of all possible sub-arrays
Given an array A of size N where, 1\leq N \leq 10^{5} . The task is to find the OR of all possible sub-arrays of A and then the OR of all these results. Examples: Input : 1 4 6 Output : 7 All possible subarrays are {1}, {1, 4}, {4, 6} and {1, 4, 6} ORs of these subarrays are 1, 5, 6 and 7. OR of the
9 min read
Sum of product of all pairs of a Binary Array
Given a binary array arr[] of size N, the task is to print the sum of product of all pairs of the given array elements. Note: The binary array contains only 0 and 1. Examples: Input: arr[] = {0, 1, 1, 0, 1}Output: 3Explanation: Sum of product of all possible pairs are: {0 × 1 + 0 × 1 + 0 × 0 + 0 × 1
5 min read
Maximum and minimum sum of Bitwise XOR of pairs from an array
Given an array arr[] of size N, the task is to find the maximum and minimum sum of Bitwise XOR of all pairs from an array by splitting the array into N / 2 pairs. Examples: Input: arr[] = {1, 2, 3, 4}Output: 6 10Explanation:Bitwise XOR of the all possible pair splits are as follows:(1, 2), (3, 4) →
11 min read
Sum of bitwise OR of all possible subsets of given set
Given an array arr[] of size n, we need to find sum of all the values that comes from ORing all the elements of the subsets. Prerequisites : Subset Sum of given set Examples : Input : arr[] = {1, 2, 3} Output : 18 Total Subsets = 23 -1= 7 1 = 1 2 = 2 3 = 3 1 | 2 = 3 1 | 3 = 3 2 | 3 = 3 1 | 2 | 3 = 3
8 min read
Bitwise OR of sum of all subsequences of an array
Given an array arr[] of length N, the task is to find the Bitwise OR of the sum of all possible subsequences from the given array. Examples: Input: arr[] = {4, 2, 5}Output: 15Explanation: All subsequences from the given array and their corresponding sums:{4} - 4{2} - 2{5} - 5{4, 2} - 6{4, 5} - 9{2,
6 min read
Sum of bitwise AND of all possible subsets of given set
Given an array, we need to calculate the Sum of Bit-wise AND of all possible subsets of the given array. Examples: Input : 1 2 3 Output : 9 For [1, 2, 3], all possible subsets are {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3} Bitwise AND of these subsets are, 1 + 2 + 3 + 0 + 1 + 2 + 0 = 9. So, th
7 min read