Sum of Bitwise OR of all pairs in a given array

25 Nov, 2021
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. 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
 
A Brute Force approach is to run two loops and time complexity is O(n2).  
C++
Java
Python3
C#
PHP
Javascript
// 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 functionint 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 pairsimport 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 functionarr = [1, 2, 3, 4]n = len(arr)print(pairORSum(arr, n))
// A Simple C# program to compute// sum of bitwise OR of all pairsusing 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 functionvar arr = [1, 2, 3, 4];var n = arr.length;document.write( pairORSum(arr, n)); </script>
Output:  
27
Time Complexity: O(n2)
Auxiliary Space: O(1)
An Efficient Solution 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 iff 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++
Java
Python3
C#
PHP
Javascript
// 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 pairsimport 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 functionarr = [1, 2, 3, 4]n = len(arr)print(pairORSum(arr, n))
// An efficient C# program to compute// sum of bitwise OR of all pairsusing 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 functionvar arr = [1, 2, 3, 4];var n = arr.length;document.write( pairORSum(arr, n));  </script>
Output:  
27
 Time Complexity: O(n * 32)
Auxiliary Space: O(1)
itsok
rrrtnx
subhammahato348
Bitwise-OR
Arrays
Bit Magic
Arrays
Bit Magic
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Data Structures
Window Sliding Technique
Search, insert and delete in an unsorted array
What is Data Structure: Types, Classifications and Applications
Chocolate Distribution Problem
Bitwise Operators in C/C++
Left Shift and Right Shift Operators in C/C++
Travelling Salesman Problem | Set 1 (Naive and Dynamic Programming)
Count set bits in an integer
How to swap two numbers without using a temporary variable?