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

• Last Updated : 23 Mar, 2021

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:
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:

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`

## Javascript

 ``
Output:
`6`

Time Complexity : O(N)

My Personal Notes arrow_drop_up