# Find sum of xor of all unordered triplets of the array

Given an array A, consisting of N non-negative integers, find the sum of xor of all unordered triplets of the array. For unordered triplets, the triplet (A[i], A[j], A[k]) is considered the same as triplets (A[j], A[i], A[k]) and all the other permutations.
Since the answer can be large, calculate its mod to 10037.

Examples:

```Input : A = [3, 5, 2, 18, 7]
Output : 132

Input : A = [140, 1, 66]
Output : 207 ```

Naive Approach
Iterate over all the unordered triplets and add xor of each to the sum.

Efficient Approach

• An important point to observe is that xor is independent of all the bits. So we can do the required computation over each bit individually.
• Let’s consider the k’th bit of all the array elements. If the number of unordered triplets is k’th bit xor 1 be C, we can simply add C * 2k to the answer. Let the number of elements whose k’th bit is 1 be X and whose k’th bit is 0 be Y. Then find the unordered triplets whose k’th bits xor to 1 can be formed using two cases:
1. Only one of the three elements has k’th bit 1.
2. All three of them have k’th bit 1.
• Number of ways to select 3 elements having k’th bit 1 =
• Number of ways to select 1 element with k’th bit 1 and rest with 0 =
• We will use nCr mod p to compute the combinatorial function values.

Below is the implementation of the above approach.

## C++

 `// C++ program to find sum of xor of ` `// all unordered triplets of the array ` `#include `   `using` `namespace` `std; `   `// Iterative Function to calculate ` `// (x^y)%p in O(log y) ` `int` `power(``int` `x, ``int` `y, ``int` `p) ` `{ ` `    ``// Initialize result ` `    ``int` `res = 1; `   `    ``// Update x if it is more than or ` `    ``// equal to p ` `    ``x = x % p; ` `    `    `    ``while` `(y > 0) ` `    ``{ ` `        ``// If y is odd, multiply x ` `        ``// with result ` `        ``if` `(y & 1) ` `            ``res = (res * x) % p; `   `        ``// y must be even now ` `        ``y = y >> 1; ``// y = y/2 ` `        ``x = (x * x) % p; ` `    ``} ` `    ``return` `res; ` `} `   `// Returns n^(-1) mod p ` `int` `modInverse(``int` `n, ``int` `p) ` `{ ` `    ``return` `power(n, p - 2, p); ` `} `   `// Returns nCr % p using Fermat's little ` `// theorem. ` `int` `nCrModPFermat(``int` `n, ``int` `r, ``int` `p) ` `{ ` `    ``// Base case ` `    ``if` `(r == 0) ` `        ``return` `1; ` `    ``if` `(n < r) ` `        ``return` `0; ` `    `  `    ``// Fill factorial array so that we ` `    ``// can find all factorial of r, n ` `    ``// and n-r ` `    ``int` `fac[n + 1]; ` `    ``fac[0] = 1; ` `    ``for` `(``int` `i = 1; i <= n; i++) ` `        ``fac[i] = fac[i - 1] * i % p; `   `    ``return` `(fac[n] * modInverse(fac[r], p) % p ` `            ``* modInverse(fac[n - r], p) % p) % p; ` `} `   `// Function returns sum of xor of all ` `// unordered triplets of the array ` `int` `SumOfXor(``int` `a[], ``int` `n) ` `{ `   `    ``int` `mod = 10037; `   `    ``int` `answer = 0; `   `    ``// Iterating over the bits ` `    ``for` `(``int` `k = 0; k < 32; k++) ` `    ``{ ` `        ``// Number of elements whith k'th bit ` `        ``// 1 and 0 respectively ` `        ``int` `x = 0, y = 0; `   `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{ ` `            ``// Checking if k'th bit is 1 ` `            ``if` `(a[i] & (1 << k)) ` `                ``x++; ` `            ``else` `                ``y++; ` `        ``} ` `        ``// Adding this bit's part to the answer ` `        ``answer += ((1 << k) % mod * ` `                ``(nCrModPFermat(x, 3, mod) ` `                    ``+ x * nCrModPFermat(y, 2, mod)) ` `                ``% mod) % mod; ` `    ``} ` `    ``return` `answer; ` `} ` `// Drivers code ` `int` `main() ` `{ ` `    ``int` `n = 5; ` `    ``int` `A[n] = { 3, 5, 2, 18, 7 }; `   `    ``cout << SumOfXor(A, n); `   `    ``return` `0; ` `} `

## Java

 `// Java program to find sum of xor of` `// all unordered triplets of the array` `class` `GFG{`   `// Iterative Function to calculate` `// (x^y)%p in O(log y)` `static` `int` `power(``int` `x, ``int` `y, ``int` `p)` `{` `    `  `    ``// Initialize result` `    ``int` `res = ``1``;`   `    ``// Update x if it is more than or` `    ``// equal to p` `    ``x = x % p;`   `    ``while` `(y > ``0``)` `    ``{` `        `  `        ``// If y is odd, multiply x` `        ``// with result` `        ``if` `((y & ``1``) == ``1``)` `            ``res = (res * x) % p;`   `        ``// y must be even now` `        ``y = y >> ``1``; ``// y = y/2` `        ``x = (x * x) % p;` `    ``}` `    ``return` `res;` `}`   `// Returns n^(-1) mod p` `static` `int` `modInverse(``int` `n, ``int` `p)` `{` `    ``return` `power(n, p - ``2``, p);` `}`   `// Returns nCr % p using Fermat's little` `// theorem.` `static` `int` `nCrModPFermat(``int` `n, ``int` `r, ``int` `p)` `{` `    `  `    ``// Base case` `    ``if` `(r == ``0``)` `        ``return` `1``;` `    ``if` `(n < r)` `        ``return` `0``;`   `    ``// Fill factorial array so that we` `    ``// can find all factorial of r, n` `    ``// and n-r` `    ``int` `fac[] = ``new` `int``[n + ``1``];` `    ``fac[``0``] = ``1``;` `    ``for``(``int` `i = ``1``; i <= n; i++)` `        ``fac[i] = fac[i - ``1``] * i % p;`   `    ``return` `(fac[n] * modInverse(fac[r], p) % p * ` `                     ``modInverse(fac[n - r], p) %` `                                            ``p) % p;` `}`   `// Function returns sum of xor of all` `// unordered triplets of the array` `static` `int` `SumOfXor(``int` `a[], ``int` `n)` `{`   `    ``int` `mod = ``10037``;` `    ``int` `answer = ``0``;`   `    ``// Iterating over the bits` `    ``for``(``int` `k = ``0``; k < ``32``; k++)` `    ``{` `        `  `        ``// Number of elements whith k'th bit` `        ``// 1 and 0 respectively` `        ``int` `x = ``0``, y = ``0``;`   `        ``for``(``int` `i = ``0``; i < n; i++)` `        ``{` `            `  `            ``// Checking if k'th bit is 1` `            ``if` `((a[i] & (``1` `<< k)) != ``0``)` `                ``x++;` `            ``else` `                ``y++;` `        ``}` `        ``// Adding this bit's part to the answer` `        ``answer += ((``1` `<< k) % mod * ` `                   ``(nCrModPFermat(x, ``3``, mod) + x * ` `                    ``nCrModPFermat(y, ``2``, mod)) % ` `                                        ``mod) % mod;` `    ``}` `    ``return` `answer;` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `n = ``5``;` `    ``int` `A[] = { ``3``, ``5``, ``2``, ``18``, ``7` `};`   `    ``System.out.println(SumOfXor(A, n));` `}` `}`   `// This code is contributed by jrishabh99`

## Python3

 `# Python3 program to find sum of xor of ` `# all unordered triplets of the array `   `# Iterative Function to calculate ` `# (x^y)%p in O(log y) ` `def` `power(x, y, p): ` `    `  `    ``# Initialize result ` `    ``res ``=` `1`   `    ``# Update x if it is more than or ` `    ``# equal to p ` `    ``x ``=` `x ``%` `p `   `    ``while` `(y > ``0``): ` `        ``# If y is odd, multiply x ` `        ``# with result ` `        ``if` `(y & ``1``): ` `            ``res ``=` `(res ``*` `x) ``%` `p `   `        ``# y must be even now ` `        ``y ``=` `y >> ``1``#y = y/2 ` `        ``x ``=` `(x ``*` `x) ``%` `p ` `    ``return` `res `   `# Returns n^(-1) mod p ` `def` `modInverse(n, p): ` `    ``return` `power(n, p ``-` `2``, p) `   `# Returns nCr % p using Fermat's little ` `# theorem. ` `def` `nCrModPFermat(n, r, p): ` `    `  `    ``# Base case ` `    ``if` `(r ``=``=` `0``): ` `        ``return` `1` `    ``if` `(n < r): ` `        ``return` `0`   `    ``# Fill factorial array so that we ` `    ``# can find all factorial of r, n ` `    ``# and n-r ` `    ``fac ``=` `[``0``]``*``(n ``+` `1``) ` `    ``fac[``0``] ``=` `1` `    ``for` `i ``in` `range``(``1``, n ``+` `1``): ` `        ``fac[i] ``=` `fac[i ``-` `1``] ``*` `i ``%` `p `   `    ``return` `(fac[n] ``*` `modInverse(fac[r], p) ``%` `p ``*` `            ``modInverse(fac[n ``-` `r], p) ``%` `p) ``%` `p `   `# Function returns sum of xor of all ` `# unordered triplets of the array ` `def` `SumOfXor(a, n): `   `    ``mod ``=` `10037`   `    ``answer ``=` `0`   `    ``# Iterating over the bits ` `    ``for` `k ``in` `range``(``32``): ` `        `  `        ``# Number of elements whith k'th bit ` `        ``# 1 and 0 respectively ` `        ``x ``=` `0` `        ``y ``=` `0`   `        ``for` `i ``in` `range``(n): ` `            `  `            ``# Checking if k'th bit is 1 ` `            ``if` `(a[i] & (``1` `<< k)): ` `                ``x ``+``=` `1` `            ``else``: ` `                ``y ``+``=` `1` `        ``# Adding this bit's part to the answer ` `        ``answer ``+``=` `((``1` `<< k) ``%` `mod ``*` `(nCrModPFermat(x, ``3``, mod) ` `                    ``+` `x ``*` `nCrModPFermat(y, ``2``, mod)) ` `                ``%` `mod) ``%` `mod `   `    ``return` `answer `   `# Drivers code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``n ``=` `5` `    ``A``=``[``3``, ``5``, ``2``, ``18``, ``7``] `   `    ``print``(SumOfXor(A, n)) `   `# This code is contributed by mohit kumar 29 `

## C#

 `// C# program to find sum of xor of` `// all unordered triplets of the array` `using` `System;` `class` `GFG{`   `// Iterative Function to calculate` `// (x^y)%p in O(log y)` `static` `int` `power(``int` `x, ``int` `y, ``int` `p)` `{` `    `  `    ``// Initialize result` `    ``int` `res = 1;`   `    ``// Update x if it is more than or` `    ``// equal to p` `    ``x = x % p;`   `    ``while` `(y > 0)` `    ``{` `        `  `        ``// If y is odd, multiply x` `        ``// with result` `        ``if` `((y & 1) == 1)` `            ``res = (res * x) % p;`   `        ``// y must be even now` `        ``y = y >> 1; ``// y = y/2` `        ``x = (x * x) % p;` `    ``}` `    ``return` `res;` `}`   `// Returns n^(-1) mod p` `static` `int` `modInverse(``int` `n, ``int` `p)` `{` `    ``return` `power(n, p - 2, p);` `}`   `// Returns nCr % p using Fermat's little` `// theorem.` `static` `int` `nCrModPFermat(``int` `n, ``int` `r, ``int` `p)` `{` `    `  `    ``// Base case` `    ``if` `(r == 0)` `        ``return` `1;` `    ``if` `(n < r)` `        ``return` `0;`   `    ``// Fill factorial array so that we` `    ``// can find all factorial of r, n` `    ``// and n-r` `    ``int` `[]fac = ``new` `int``[n + 1];` `    ``fac[0] = 1;` `    ``for``(``int` `i = 1; i <= n; i++)` `        ``fac[i] = fac[i - 1] * i % p;`   `    ``return` `(fac[n] * modInverse(fac[r], p) % p * ` `                     ``modInverse(fac[n - r], p) %` `                                            ``p) % p;` `}`   `// Function returns sum of xor of all` `// unordered triplets of the array` `static` `int` `SumOfXor(``int` `[]a, ``int` `n)` `{` `    ``int` `mod = 10037;` `    ``int` `answer = 0;`   `    ``// Iterating over the bits` `    ``for``(``int` `k = 0; k < 32; k++)` `    ``{` `        `  `        ``// Number of elements whith k'th bit` `        ``// 1 and 0 respectively` `        ``int` `x = 0, y = 0;`   `        ``for``(``int` `i = 0; i < n; i++)` `        ``{` `            `  `            ``// Checking if k'th bit is 1` `            ``if` `((a[i] & (1 << k)) != 0)` `                ``x++;` `            ``else` `                ``y++;` `        ``}` `        ``// Adding this bit's part to the answer` `        ``answer += ((1 << k) % mod * ` `                   ``(nCrModPFermat(x, 3, mod) + x * ` `                    ``nCrModPFermat(y, 2, mod)) % ` `                                        ``mod) % mod;` `    ``}` `    ``return` `answer;` `}`   `// Driver code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `n = 5;` `    ``int` `[]A = { 3, 5, 2, 18, 7 };`   `    ``Console.WriteLine(SumOfXor(A, n));` `}` `}`   `// This code is contributed by gauravrajput1`

## Javascript

 ``

Output:

`132`

Time Complexity : O(32 * N)

Auxiliary Space: O(N) since we are storing N elements in array data structure.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next