# 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 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
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

A Brute Force approach is to run two loops and time complexity is O(n2).

## C++

 `// A Simple C++ program to compute sum of bitwise OR ` `// of all pairs ` `#include ` `using` `namespace` `std; ` ` `  `// Returns value of "arr  | arr + arr | arr + ` `// ... 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); ` `    ``cout << pairORSum(arr, n) << endl; ` `    ``return` `0; ` `} `

## Java

 `// A Simple Java program to compute ` `// sum of bitwise OR of all pairs ` `import` `java.io.*; ` ` `  `class` `GFG { ` ` `  `    ``// Returns value of "arr | arr + ` `    ``// arr | arr + ... 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)); ` `    ``} ` `} `

## Python3

 `# A Simple Python 3 program to compute ` `# sum of bitwise OR of all pairs ` ` `  `# Returns value of "arr | arr + ` `# arr | arr + ... 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)) `

## C#

 `// A Simple C# program to compute ` `// sum of bitwise OR of all pairs ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``// Returns value of "arr | arr + ` `    ``// arr | arr + ... 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

 ` `

Output :

`27`

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 which have i’th set bit). Every such pair adds 2i to total sum. Similarly, there are total k0 values which 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 ` `using` `namespace` `std; ` `typedef` `long` `long` `int` `LLI; ` ` `  `// Returns value of "arr | arr + arr | arr + ` `// ... 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); ` ` `  `    ``cout << pairORSum(arr, n) << endl; ` ` `  `    ``return` `0; ` `} `

## Java

 `// An efficient Java program to compute ` `// sum of bitwise OR of all pairs ` `import` `java.io.*; ` ` `  `class` `GFG { ` ` `  `    ``// Returns value of "arr | arr + arr | arr + ` `    ``// ... 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)); ` `    ``} ` `} `

## Python3

 `# An efficient Python 3 program to ` `# compute the sum of bitwise OR of all pairs ` ` `  `# Returns value of "arr | arr + arr | arr + ` `# ... 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``<

## C#

 `// An efficient C# program to compute ` `// sum of bitwise OR of all pairs ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``// Returns value of "arr | arr + arr | arr + ` `    ``// ... 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

 ` `

Output:

`27`

My Personal Notes arrow_drop_up 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.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.