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

• Difficulty Level : Basic
• Last Updated : 27 Aug, 2022

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.

My Personal Notes arrow_drop_up