Skip to content
Related Articles

Related Articles

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 <bits/stdc++.h>
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[100005] = { 0 };
    int ways[100005] = { 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[0]);
 
    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[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;
 
    Console.Write(CountOfTriplets(Arr, N));
 
}
}
 
// This code is contributed by Rohit_ranjan

Javascript




<script>
 
    // Javascript program  to count the Number of
    // triplets in array having subarray
    // XOR equal
     
    // Function return the count of
    // triplets having subarray XOR equal
    function CountOfTriplets(a, n)
    {
        let answer = 0;
 
        // XOR value till i
        let x = 0;
 
        // Count and ways array as defined
        // above
        let count = new Array(100005);
        let ways = new Array(100005);
        count.fill(0);
        ways.fill(0);
 
        for (let 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] = ways[x] + i + 1;
        }
        return answer;
    }
     
    let Arr = [ 3, 6, 12, 8, 6, 2, 1, 5 ];
   
    let N = Arr.length;
   
    document.write(CountOfTriplets(Arr, N));
 
</script>
Output: 
6

 

Time Complexity : O(N)
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :