# Count triplet of indices (i, j, k) such that XOR of elements between [i, j) equals [j, k]

Given an array of integers Arr. The task is to count the number of triplets (i, j, k) such that Ai ^ Ai+1 ^ Ai+2 ^ …. ^ Aj-1 = Aj ^ Aj+1 ^ Aj+2 ^ ….. ^ Ak, and 0 < (i, j, k) < N , where N is the size of the array.

Where ^ is the bitwise xor of two numbers.

Examples:

Input: Arr = [5, 2, 7]
Output: 2
Explanation:
The triplets are (0, 2, 2) since 5 ^ 2 = 7 and (0, 1, 2) since 2 ^ 7 = 5.

Input: Arr = [3, 6, 12, 8, 6, 2, 1, 5]
Output: 6

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach

• Let’s simplify the given expression :
```Ai ^ Ai + 1 ^ ...Aj - 1 = Aj ^ Aj + 1 ^ ...Ak

Taking XOR with Aj ^ Aj + 1 ^ ...Ak on both sides

Ai ^ Ai + 1 ^ ...Aj - 1 ^ Aj ^ Aj + 1 ^ ...Ak = 0
```

So a subarray [i, k] having XOR 0 will have k – i triplets, because any j can be selected from [i+1, k] and the triplet will satisfy the condition.

• The problem now reduces to finding lengths of all subarray whose XOR is 0 and for each such length L, add L – 1 to the answer.
• In the prefix XOR array if at 2 indices, say L and R, the prefix XOR value is same – then it means that the XOR of subarray [L + 1, R] = 0.
• To find the count, we will store the following :
```Say we are at index i, and the prefix XOR at i = x.

count[x] = Frequency of x in prefix XOR array before i

ways[x] -> For each all j < i, if prefixXor[j] = x,
then ways[x] += (j+1)
```

These can be used to count the triplets using the formula :

```Triplets += count[x] * i  - ways[x]
```

Below is the implementation of the above approach:

## C++

 `// C++ program  to count the Number of ` `// triplets in array having subarray ` `// XOR equal ` `#include ` `using` `namespace` `std; ` ` `  `// Function return the count of ` `// triplets having subarray XOR equal ` `int` `CountOfTriplets(``int` `a[], ``int` `n) ` `{ ` `    ``int` `answer = 0; ` ` `  `    ``// XOR value till i ` `    ``int` `x = 0; ` ` `  `    ``// Count and ways array as defined ` `    ``// above ` `    ``int` `count = { 0 }; ` `    ``int` `ways = { 0 }; ` ` `  `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``{ ` `        ``x ^= a[i]; ` ` `  `        ``// Using the formula stated ` `        ``answer += count[x] * i - ways[x]; ` ` `  `        ``// Increase the frequency of x ` `        ``count[x]++; ` ` `  `        ``// Add i+1 to ways[x] for upcoming ` `        ``// indices ` `        ``ways[x] += (i + 1); ` `    ``} ` `    ``return` `answer; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` ` `  `    ``int` `Arr[] = { 3, 6, 12, 8, 6, 2, 1, 5 }; ` ` `  `    ``int` `N = ``sizeof``(Arr) / ``sizeof``(Arr); ` ` `  `    ``cout << CountOfTriplets(Arr, N); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to count the Number of ` `// triplets in array having subarray ` `// XOR equal ` `import` `java.io.*;  ` `import` `java.util.Arrays;  ` `import` `java.util.ArrayList;  ` `import` `java.lang.*;  ` `import` `java.util.Collections;  ` ` `  `class` `GFG  ` `{ ` ` `  `// Function return the count of ` `// triplets having subarray XOR equal ` `static` `int` `CountOfTriplets(``int` `a[], ``int` `n) ` `{ ` `    ``int` `answer = ``0``; ` ` `  `    ``// XOR value till i ` `    ``int` `x = ``0``; ` ` `  `    ``// Count and ways array as defined ` `    ``// above ` `    ``int` `count[] = ``new` `int``[``100005``]; ` `    ``int` `ways[] = ``new` `int``[``100005``]; ` `     `  ` `  `    ``for` `(``int` `i = ``0``; i < n; i++) ` `    ``{ ` `        ``x ^= a[i]; ` ` `  `        ``// Using the formula stated ` `        ``answer += count[x] * i - ways[x]; ` ` `  `        ``// Increase the frequency of x ` `        ``count[x]++; ` ` `  `        ``// Add i+1 to ways[x] for upcoming ` `        ``// indices ` `        ``ways[x] += (i + ``1``); ` `    ``} ` `    ``return` `answer; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` ` `  `    ``int` `Arr[] = { ``3``, ``6``, ``12``, ``8``, ``6``, ``2``, ``1``, ``5` `}; ` ` `  `    ``int` `N = Arr.length; ` ` `  `    ``System.out.print(CountOfTriplets(Arr, N)); ` ` `  `} ` `} ` `// This code is contributed by shivanisinghss2110 `

## Python3

 `# Python3 program  to count the Number of ` `# triplets in array having subarray ` `# XOR equal ` ` `  `# Function return the count of ` `# triplets having subarray XOR equal ` `def` `CountOfTriplets(a,n): ` `    ``answer ``=` `0` ` `  `    ``# XOR value till i ` `    ``x ``=` `0` ` `  `    ``# Count and ways array as defined ` `    ``# above ` `    ``count ``=` `[``0` `for` `i ``in` `range``(``100005``)] ` `    ``ways ``=` `[``0` `for` `i ``in` `range``(``100005``)] ` ` `  `    ``for` `i ``in` `range``(n): ` `        ``x ^``=` `a[i] ` ` `  `        ``# Using the formula stated ` `        ``answer ``+``=` `count[x] ``*` `i ``-` `ways[x] ` ` `  `        ``# Increase the frequency of x ` `        ``count[x] ``+``=` `1` ` `  `        ``# Add i+1 to ways[x] for upcoming ` `        ``# indices ` `        ``ways[x] ``+``=` `(i ``+` `1``) ` `    ``return` `answer ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``Arr ``=`  `[``3``, ``6``, ``12``, ``8``, ``6``, ``2``, ``1``, ``5``] ` ` `  `    ``N ``=` `len``(Arr) ` ` `  `    ``print``(CountOfTriplets(Arr, N)) ` ` `  `# This code is contributed by Bhupendra_Singh `

## C#

 `// C# program to count the Number of ` `// triplets in array having subarray ` `// XOR equal ` `using` `System; ` ` `  `class` `GFG { ` ` `  `// Function return the count of ` `// triplets having subarray XOR equal ` `static` `int` `CountOfTriplets(``int` `[]a, ``int` `n) ` `{ ` `    ``int` `answer = 0; ` ` `  `    ``// XOR value till i ` `    ``int` `x = 0; ` ` `  `    ``// Count and ways array as defined ` `    ``// above ` `    ``int` `[]count = ``new` `int``; ` `    ``int` `[]ways = ``new` `int``; ` `     `  ` `  `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{ ` `       ``x ^= a[i]; ` `        `  `       ``// Using the formula stated ` `       ``answer += count[x] * i - ways[x]; ` `        `  `       ``// Increase the frequency of x ` `       ``count[x]++; ` `        `  `       ``// Add i+1 to ways[x] for upcoming ` `       ``// indices ` `       ``ways[x] += (i + 1); ` `    ``} ` `     `  `    ``return` `answer; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` ` `  `    ``int` `[]Arr = { 3, 6, 12, 8, 6, 2, 1, 5 }; ` `    ``int` `N = Arr.Length; ` ` `  `    ``Console.Write(CountOfTriplets(Arr, N)); ` ` `  `} ` `} ` ` `  `// This code is contributed by Rohit_ranjan `

Output:

```6
```

Time Complexity : O(N) 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.