# 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 & 15)
= 0 + 5 + 10
= 15

Input: arr[] = {1, 2, 3, 4}
Output: 3
Required Value = (1 & 2) + (1 & 3) + (1 & 4) +
(2 & 3) + (2 & 4) + (3 & 4)
= 0 + 1 + 0 + 2 + 0 + 0
= 3
```

## 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 AND  ` `// 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` `pairAndSum(``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[] = {5, 10, 15}; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof` `(arr); ` `    ``cout << pairAndSum(arr, n) << endl; ` `    ``return` `0; ` `} `

## Java

 `// A Simple Java program to compute ` `// sum of bitwise AND 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` `pairAndSum(``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[] = {``5``, ``10``, ``15``}; ` `        ``int` `n = arr.length; ` `        ``System.out.println(pairAndSum(arr, n) ); ` `    ``} ` `} ` ` `  `/*This code is contributed by Nikita Tiwari.*/`

## Python3

 `# A Simple Python 3 program to compute ` `# sum of bitwise AND of all pairs ` ` `  `# Returns value of "arr & arr + ` `# arr & arr + ... arr[i] & arr[j] + ` `# ..... arr[n-2] & arr[n-1]" ` `def` `pairAndSum(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 ``=` `[``5``, ``10``, ``15``] ` `n ``=` `len``(arr)  ` `print``(pairAndSum(arr, n)) ` ` `  `# This code is contributed by Nikita Tiwari. `

## C#

 `// A Simple C# program to compute ` `// sum of bitwise AND 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` `pairAndSum(``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 = {5, 10, 15}; ` `        ``int` `n = arr.Length; ` `        ``Console.Write(pairAndSum(arr, n) ); ` `    ``} ` `} ` `  `  `// This code is contributed by nitin mittal. `

## PHP

 ` `

Output :

`15`

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 k be the count of set bits at i'th position. Total number of pairs with i'th set bit would be kC2 = k*(k-1)/2 (Count k means there are k numbers which have i’th set bit). Every such pair adds 2i to total sum. Similarly, we work for all other places and add the sum to our final answer.

This idea is similar to this. Below is the implementation.

## C

 `// An efficient C++ program to compute sum of bitwise AND ` `// 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` `pairAndSum(``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 i'th bit set ` `        ``int` `k = 0;  ``// Initialize the count ` `        ``for` `(``int` `j = 0; j < n; j++) ` `            ``if` `( (arr[j] & (1 << i)) ) ` `                ``k++; ` ` `  `        ``// There are k set bits, means k(k-1)/2 pairs. ` `        ``// Every pair adds 2^i to the answer. Therefore, ` `        ``// we add "2^i * [k*(k-1)/2]" to the answer. ` `        ``ans += (1<

## Java

 `// An efficient Java program to compute ` `// sum of bitwise AND 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` `pairAndSum(``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 i'th bit set ` `            ``// Initialize the count ` `            ``int` `k = ``0``; ` `            ``for` `(``int` `j = ``0``; j < n; j++) ` `            ``{ ` `                ``if` `((arr[j] & (``1` `<< i))!=``0``) ` `                    ``k++; ` `            ``} ` `     `  `            ``// There are k set bits, means k(k-1)/2 pairs. ` `            ``// Every pair adds 2^i to the answer. Therefore, ` `            ``// we add "2^i * [k*(k-1)/2]" to the answer. ` `            ``ans += (``1` `<< i) * (k * (k - ``1``)/``2``); ` `        ``} ` `        ``return` `ans; ` `    ``} ` ` `  `    ``// Driver program to test above function ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `arr[] = {``5``, ``10``, ``15``}; ` `        ``int` `n = arr.length; ` `        ``System.out.println(pairAndSum(arr, n)); ` `    ``} ` `} ` ` `  `/*This code is contributed by Nikita Tiwari.*/`

## Python3

 `# An efficient Python 3 program to ` `# compute sum of bitwise AND of all pairs ` ` `  `# Returns value of "arr & arr + ` `# arr & arr + ... arr[i] & arr[j] + ` `# ..... arr[n-2] & arr[n-1]" ` `def` `pairAndSum(arr, n) : ` `    ``ans ``=` `0` `# Initialize result ` ` `  `    ``# Traverse over all bits ` `    ``for` `i ``in` `range``(``0``,``32``) : ` `         `  `        ``# Count number of elements with i'th bit set ` `        ``# Initialize the count ` `        ``k ``=` `0` `        ``for` `j ``in` `range``(``0``,n) : ` `            ``if` `( (arr[j] & (``1` `<< i)) ) : ` `                ``k ``=` `k ``+` `1` ` `  `        ``# There are k set bits, means k(k-1)/2 pairs. ` `        ``# Every pair adds 2^i to the answer. Therefore, ` `        ``# we add "2^i * [k*(k-1)/2]" to the answer. ` `        ``ans ``=` `ans ``+` `(``1` `<< i) ``*` `(k ``*` `(k ``-` `1``) ``/``/` `2``) ` `     `  `    ``return` `ans ` `     `  `# Driver program to test above function ` `arr ``=` `[``5``, ``10``, ``15``] ` `n ``=` `len``(arr)  ` `print``(pairAndSum(arr, n)) ` ` `  `# This code is contributed by Nikita Tiwari. `

## C#

 `// An efficient C# program to compute ` `// sum of bitwise AND 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` `pairAndSum(``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 ` `            ``// i'th bit set Initialize the count ` `            ``int` `k = 0; ` `            ``for` `(``int` `j = 0; j < n; j++) ` `            ``{ ` `                ``if` `((arr[j] & (1 << i))!=0) ` `                    ``k++; ` `            ``} ` `     `  `            ``// There are k set bits, means  ` `            ``// k(k-1)/2 pairs. Every pair  ` `            ``// adds 2^i to the answer.  ` `            ``// Therefore, we add "2^i *  ` `            ``// [k*(k-1)/2]" to the answer. ` `            ``ans += (1 << i) * (k * (k - 1)/2); ` `        ``} ` `         `  `        ``return` `ans; ` `    ``} ` ` `  `    ``// Driver program to test above function ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `[]arr = ``new` `int``[]{5, 10, 15}; ` `        ``int` `n = arr.Length; ` `         `  `        ``Console.Write(pairAndSum(arr, n)); ` `    ``} ` `} ` ` `  `/* This code is contributed by smitha*/`

## PHP

 ` `

Output:

`15`

My Personal Notes arrow_drop_up

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.