Open In App

Number of triplets in array having subarray xor equal

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
The triplets are (0, 2, 2) since 5 ^ 2 = 7 and (0, 1, 2) since 2 ^ 7 = 5. 

Input: Arr = {1, 2, 3, 4, 5} 
Output: 5

Brute force Approach: A simple solution is to run three nested loops iterating through all possible values of i, j and k and then another loop to calculate the xor of both the first and second subarray. 
The time complexity of this solution is O(N4).  




// A simple C++ program to find Number of triplets
// in array having subarray xor equal
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the count
int xor_triplet(int arr[], int n)
{
    // Initialise result
    int ans = 0;
 
    // Pick 1st element of the triplet
    for (int i = 0; i < n; i++) {
 
        // Pick 2nd element of the triplet
        for (int j = i + 1; j < n; j++) {
 
            // Pick 3rd element of the triplet
            for (int k = j; k < n; k++) {
 
                int xor1 = 0, xor2 = 0;
 
                // Taking xor in the
                // first subarray
                for (int x = i; x < j; x++) {
                    xor1 ^= arr[x];
                }
 
                // Taking xor in the
                // second subarray
                for (int x = j; x <= k; x++) {
                    xor2 ^= arr[x];
                }
 
                // If both xor is equal
                if (xor1 == xor2) {
                    ans++;
                }
            }
        }
    }
    return ans;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 2, 3, 4, 5 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // Function Calling
    cout << xor_triplet(arr, n);
    return 0;
}




// Java program to find Number of triplets
// in array having subarray xor equal
class GFG {
 
    // Function to return the count
    static int xor_triplet(int arr[], int n)
    {
        // Initialise result
        int ans = 0;
 
        // Pick 1st element of the triplet
        for (int i = 0; i < n; i++) {
 
            // Pick 2nd element of the triplet
            for (int j = i + 1; j < n; j++) {
 
                // Pick 3rd element of the triplet
                for (int k = j; k < n; k++) {
                    int xor1 = 0, xor2 = 0;
 
                    // Taking xor in the
                    // first subarray
                    for (int x = i; x < j; x++) {
                        xor1 ^= arr[x];
                    }
 
                    // Taking xor in the
                    // second subarray
                    for (int x = j; x <= k; x++) {
                        xor2 ^= arr[x];
                    }
 
                    // If both xor is equal
                    if (xor1 == xor2) {
                        ans++;
                    }
                }
            }
        }
        return ans;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int arr[] = { 1, 2, 3, 4, 5 };
        int n = arr.length;
 
        // Function Calling
        System.out.println(xor_triplet(arr, n));
    }
}
 
// This code is contributed by AnkitRai01




# A simple python3 program to find Number of triplets
# in array having subarray xor equal
 
# Function to return the count
 
 
def xor_triplet(arr, n):
 
    # Initialise result
    ans = 0
 
    # Pick 1st element of the triplet
    for i in range(n):
 
        # Pick 2nd element of the triplet
        for j in range(i + 1, n):
 
            # Pick 3rd element of the triplet
            for k in range(j, n):
 
                xor1 = 0
                xor2 = 0
 
                # Taking xor in the
                # first subarray
                for x in range(i, j):
                    xor1 ^= arr[x]
 
                # Taking xor in the
                # second subarray
                for x in range(j, k + 1):
                    xor2 ^= arr[x]
 
                # If both xor is equal
                if (xor1 == xor2):
                    ans += 1
 
    return ans
 
 
# Driver Code
if __name__ == '__main__':
    arr = [1, 2, 3, 4, 5]
    n = len(arr)
 
    # Function Calling
    print(xor_triplet(arr, n))
 
# This code is contributed by PrinciRaj1992




// C# program to find Number of triplets
// in array having subarray xor equal
using System;
 
class GFG {
 
    // Function to return the count
    static int xor_triplet(int[] arr, int n)
    {
        // Initialise result
        int ans = 0;
 
        // Pick 1st element of the triplet
        for (int i = 0; i < n; i++) {
 
            // Pick 2nd element of the triplet
            for (int j = i + 1; j < n; j++) {
 
                // Pick 3rd element of the triplet
                for (int k = j; k < n; k++) {
                    int xor1 = 0, xor2 = 0;
 
                    // Taking xor in the
                    // first subarray
                    for (int x = i; x < j; x++) {
                        xor1 ^= arr[x];
                    }
 
                    // Taking xor in the
                    // second subarray
                    for (int x = j; x <= k; x++) {
                        xor2 ^= arr[x];
                    }
 
                    // If both xor is equal
                    if (xor1 == xor2) {
                        ans++;
                    }
                }
            }
        }
        return ans;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int[] arr = { 1, 2, 3, 4, 5 };
        int n = arr.Length;
 
        // Function Calling
        Console.WriteLine(xor_triplet(arr, n));
    }
}
 
// This code is contributed by PrinciRaj1992




<script>
// A simple Javascript program to find Number of triplets
// in array having subarray xor equal
 
 
// Function to return the count
function xor_triplet(arr, n) {
    // Initialise result
    let ans = 0;
 
    // Pick 1st element of the triplet
    for (let i = 0; i < n; i++) {
 
        // Pick 2nd element of the triplet
        for (let j = i + 1; j < n; j++) {
 
            // Pick 3rd element of the triplet
            for (let k = j; k < n; k++) {
 
                let xor1 = 0, xor2 = 0;
 
                // Taking xor in the
                // first subarray
                for (let x = i; x < j; x++) {
                    xor1 ^= arr[x];
                }
 
                // Taking xor in the
                // second subarray
                for (let x = j; x <= k; x++) {
                    xor2 ^= arr[x];
                }
 
                // If both xor is equal
                if (xor1 == xor2) {
                    ans++;
                }
            }
        }
    }
    return ans;
}
 
// Driver Code
 
let arr = [1, 2, 3, 4, 5];
let n = arr.length;
 
// Function Calling
document.write(xor_triplet(arr, n))
 
// This code is contributed by _saurabh_jaiswal
</script>

Output
5

Time Complexity: O(N4)

Auxiliary Space: O(1)

Better Approach:

Below is the implementation of the above approach: 




/*package whatever //do not write package name here */
 
import java.io.*;
 
class GFG {
   
  public static int no_of_triplets(int arr[], int n)
  {
      n=n+1;
      int res = 0, prefix[] = new int[n];
       
     
    //prefix xor of the array
        for (int i = 1; i < n; ++i)
            prefix[i] = arr[i - 1] ^ prefix[i - 1];
     
        for (int i = 0; i < n; ++i)
            for (int j = i + 1; j < n; ++j)
             //counting many pair have prefix value are equal.
                if (prefix[i] == prefix[j])
                    res += j - i - 1;
        return res;
  }
   
  //Drivers Code
    public static void main (String[] args) {
        
      int arr[]={5,2,7};
      int n=arr.length;
       
      System.out.println(no_of_triplets(arr,n));
    }
}
 
//This code is contributed by Utkarsh Raj Mishra




# python  code for approach
class GFG:
 
    @staticmethod
    def no_of_triplets(arr, n):
        n = n + 1
        res = 0
        prefix = [0] * n
 
        # prefix xor of the array
        for i in range(1, n):
            prefix[i] = arr[i - 1] ^ prefix[i - 1]
 
        for i in range(n):
            for j in range(i + 1, n):
                # counting many pair have prefix value are
                # equal.
                if prefix[i] == prefix[j]:
                    res += j - i - 1
        return res
 
 
# Driver Code
if __name__ == "__main__":
    arr = [5, 2, 7]
    n = len(arr)
 
    print(GFG.no_of_triplets(arr, n))
 
# This code is generated by Chetan Bargal




// C# code with comments
 
using System;
 
class GFG {
 
    public static int no_of_triplets(int[] arr, int n)
    {
        n = n + 1;
        int res = 0;
        int[] prefix = new int[n];
 
        // prefix xor of the array
        for (int i = 1; i < n; ++i)
            prefix[i] = arr[i - 1] ^ prefix[i - 1];
 
        for (int i = 0; i < n; ++i)
            for (int j = i + 1; j < n; ++j)
                // counting many pair have prefix value are
                // equal.
                if (prefix[i] == prefix[j])
                    res += j - i - 1;
        return res;
    }
 
    // Driver Code
    static void Main(string[] args)
    {
 
        int[] arr = { 5, 2, 7 };
        int n = arr.Length;
 
        Console.WriteLine(no_of_triplets(arr, n));
    }
}
 
// This code is contributed by phasing17




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate the number
// of triplets
int no_of_triplets(int arr[], int n)
{
    n = n + 1;
    int res = 0, prefix[n];
 
    // Prefix xor of the array
    for (int i = 1; i < n; ++i)
        prefix[i] = arr[i - 1] ^ prefix[i - 1];
 
    for (int i = 0; i < n; ++i)
        for (int j = i + 1; j < n; ++j)
 
            // Counting how many pairs have
            // the same prefix value
            if (prefix[i] == prefix[j])
                res += j - i - 1;
    return res;
}
 
// Driver Code
int main()
{
    int arr[] = { 5, 2, 7 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    cout << no_of_triplets(arr, n);
    return 0;
}




function no_of_triplets(arr, n) {
    n = n + 1;
    let res = 0, prefix = new Array(n);
     
    // prefix XOR of the array
    prefix[0] = 0;
    for (let i = 1; i < n; ++i) {
        prefix[i] = arr[i - 1] ^ prefix[i - 1];
    }
 
    for (let i = 0; i < n; ++i) {
        for (let j = i + 1; j < n; ++j) {
            // counting how many pairs have the same prefix value
            if (prefix[i] == prefix[j]) {
                res += j - i - 1;
            }
        }
    }
    return res;
}
 
// Drivers Code
let arr = [5, 2, 7];
let n = arr.length;
 
console.log(no_of_triplets(arr, n));

Output
2

Time complexity: O(N2
Auxiliary Space: O(N).  

Efficient Approach: 

Below is the implementation of the above approach: 




// C++ trie based program to find the Number of
// triplets in array having subarray xor equal
#include <bits/stdc++.h>
using namespace std;
 
// maximum number of bits
// in an integer <= 1e9
#define lg 31
 
// Structure of a Trie Node
struct TrieNode {
 
    // [0] index is bit 0
    // and [1] index is bit 1
    TrieNode* children[2];
 
    // Sum of indexes
    // inserted at a node
    int sum_of_indexes;
 
    // Number of indexes
    // inserted at a node
    int number_of_indexes;
 
    // Constructor to initialize
    // a newly created node
    TrieNode()
    {
 
        this->children[0] = nullptr;
        this->children[1] = nullptr;
        this->sum_of_indexes = 0;
        this->number_of_indexes = 0;
    }
};
 
// Function to insert curr_xor
// into the trie
void insert(TrieNode* node,
            int num,
            int index)
{
 
    // Iterate from the 31st bit
    // to the 0th bit of curr_xor
    // number
    for (int bits = lg; bits >= 0; bits--) {
 
        // Check if the current
        // bit is set or not
        int curr_bit = (num >> bits) & 1;
 
        // If this node isn't already
        // present in the trie structure
        // insert it into the trie.
        if (node->children[curr_bit]
            == nullptr) {
            node->children[curr_bit]
                = new TrieNode();
        }
 
        node = node->children[curr_bit];
    }
 
    // Increase the sum of
    // indexes by the current
    // index value
    node->sum_of_indexes += index;
 
    // Increase the number
    // of indexes by 1
    node->number_of_indexes++;
}
 
// Function to check if curr_xor
// is present in trie or not
int query(TrieNode* node,
          int num,
          int index)
{
 
    // Iterate from the 31st bit
    // to the 0th bit of curr_xor number
    for (int bits = lg; bits >= 0; bits--) {
 
        // Check if the current bit
        // is set or not
        int curr_bit = (num >> bits) & 1;
 
        // If this node isn't already
        // present in the trie structure
        // that means no sub array till
        // current index has 0 xor so
        // return 0
        if (node->children[curr_bit]
            == nullptr) {
            return 0;
        }
 
        node = node->children[curr_bit];
    }
 
    // Calculate the number of index
    // inserted at final node
    int sz = node->number_of_indexes;
 
    // Calculate the sum of index
    // inserted at final node
    int sum = node->sum_of_indexes;
 
    int ans = (sz * index) - (sum);
 
    return ans;
}
 
// Function to return the count of
// valid triplets
int no_of_triplets(int arr[], int n)
{
 
    // To store cumulative xor
    int curr_xor = 0;
 
    int number_of_triplets = 0;
 
    // The root of the trie
    TrieNode* root = new TrieNode();
 
    for (int i = 0; i < n; i++) {
 
        int x = arr[i];
 
        // Insert the curr_xor in the trie
        insert(root, curr_xor, i);
 
        // Update the cumulative xor
        curr_xor ^= x;
 
        // Check if the cumulative xor
        // is present in the trie or not
        // if present then add
        // (sz * index) - sum
        number_of_triplets
            += query(root, curr_xor, i);
    }
 
    return number_of_triplets;
}
 
// Driver Code
int main()
{
    // Given array
    int arr[] = { 5, 2, 7 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    cout << no_of_triplets(arr, n);
 
    return 0;
}




// Java trie based program to find the Number of
// triplets in array having subarray xor equal
class GFG
{
     
// maximum number of bits
// in an integer <= 1e9
static int lg = 31;
 
// Structure of a Trie Node
static class TrieNode
{
 
    // [0] index is bit 0
    // and [1] index is bit 1
    TrieNode children[];
 
    // Sum of indexes
    // inserted at at a node
    int sum_of_indexes;
 
    // Number of indexes
    // inserted at a node
    int number_of_indexes;
 
    // Constructor to initialize
    // a newly created node
    TrieNode()
    {
        children = new TrieNode[2];
        this.children[0] = null;
        this.children[1] = null;
        this.sum_of_indexes = 0;
        this.number_of_indexes = 0;
    }
};
 
// Function to insert curr_xor
// into the trie
static void insert(TrieNode node,
                    int num,
                    int index)
{
 
    // Iterate from the 31st bit
    // to the 0th bit of curr_xor
    // number
    for (int bits = lg; bits >= 0; bits--)
    {
 
        // Check if the current
        // bit is set or not
        int curr_bit = (num >> bits) & 1;
 
        // If this node isn't already
        // present in the trie structure
        // insert it into the trie.
        if (node.children[curr_bit]
            == null)
        {
            node.children[curr_bit]
                = new TrieNode();
        }
 
        node = node.children[curr_bit];
    }
 
    // Increase the sum of
    // indexes by the current
    // index value
    node.sum_of_indexes += index;
 
    // Increase the number
    // of indexes by 1
    node.number_of_indexes++;
}
 
// Function to check if curr_xor
// is present in trie or not
static int query(TrieNode node,
                  int num,
                  int index)
{
 
    // Iterate from the 31st bit
    // to the 0th bit of curr_xor number
    for (int bits = lg; bits >= 0; bits--)
    {
 
        // Check if the current bit
        // is set or not
        int curr_bit = (num >> bits) & 1;
 
        // If this node isn't already
        // present in the trie structure
        // that means no sub array till
        // current index has 0 xor so
        // return 0
        if (node.children[curr_bit]
            == null)
        {
            return 0;
        }
 
        node = node.children[curr_bit];
    }
 
    // Calculate the number of index
    // inserted at final node
    int sz = node.number_of_indexes;
 
    // Calculate the sum of index
    // inserted at final node
    int sum = node.sum_of_indexes;
 
    int ans = (sz * index) - (sum);
 
    return ans;
}
 
// Function to return the count of
// valid triplets
static int no_of_triplets(int arr[], int n)
{
 
    // To store cumulative xor
    int curr_xor = 0;
 
    int number_of_triplets = 0;
 
    // The root of the trie
    TrieNode root = new TrieNode();
 
    for (int i = 0; i < n; i++)
    {
 
        int x = arr[i];
 
        // Insert the curr_xor in the trie
        insert(root, curr_xor, i);
 
        // Update the cumulative xor
        curr_xor ^= x;
 
        // Check if the cumulative xor
        // is present in the trie or not
        // if present then add
        // (sz * index) - sum
        number_of_triplets
            += query(root, curr_xor, i);
    }
 
    return number_of_triplets;
}
 
// Driver Code
public static void main(String args[])
{
    // Given array
    int arr[] = { 5, 2, 7 };
    int n = arr.length;
 
    System.out.println(no_of_triplets(arr, n));
}
}
 
// This code is contributed by Arnab Kundu




# Python 3 trie based program to find the Number of
# triplets in array having subarray xor equal
class GFG :
   
    # maximum number of bits
    # in an integer <= 1e9
    lg = 31
     
    # Structure of a Trie Node
    class TrieNode :
       
        # [0] index is bit 0
        # and [1] index is bit 1
        children = None
         
        # Sum of indexes
        # inserted at at a node
        sum_of_indexes = 0
         
        # Number of indexes
        # inserted at a node
        number_of_indexes = 0
         
        # Constructor to initialize
        # a newly created node
        def __init__(self) :
            self.children = [None] * (2)
            self.children[0] = None
            self.children[1] = None
            self.sum_of_indexes = 0
            self.number_of_indexes = 0
             
    # Function to insert curr_xor
    # into the trie
    @staticmethod
    def insert( node,  num,  index) :
       
        # Iterate from the 31st bit
        # to the 0th bit of curr_xor
        # number
        bits = GFG.lg
        while (bits >= 0) :
           
            # Check if the current
            # bit is set or not
            curr_bit = (num >> bits) & 1
             
            # If this node isn't already
            # present in the trie structure
            # insert it into the trie.
            if (node.children[curr_bit] == None) :
                node.children[curr_bit] = GFG.TrieNode()
            node = node.children[curr_bit]
            bits -= 1
             
        # Increase the sum of
        # indexes by the current
        # index value
        node.sum_of_indexes += index
         
        # Increase the number
        # of indexes by 1
        node.number_of_indexes += 1
         
    # Function to check if curr_xor
    # is present in trie or not
    @staticmethod
    def  query( node,  num,  index) :
       
        # Iterate from the 31st bit
        # to the 0th bit of curr_xor number
        bits = GFG.lg
        while (bits >= 0) :
           
            # Check if the current bit
            # is set or not
            curr_bit = (num >> bits) & 1
             
            # If this node isn't already
            # present in the trie structure
            # that means no sub array till
            # current index has 0 xor so
            # return 0
            if (node.children[curr_bit] == None) :
                return 0
            node = node.children[curr_bit]
            bits -= 1
             
        # Calculate the number of index
        # inserted at final node
        sz = node.number_of_indexes
         
        # Calculate the sum of index
        # inserted at final node
        sum = node.sum_of_indexes
        ans = (sz * index) - (sum)
        return ans
       
    # Function to return the count of
    # valid triplets
    @staticmethod
    def  no_of_triplets( arr,  n) :
       
        # To store cumulative xor
        curr_xor = 0
        number_of_triplets = 0
         
        # The root of the trie
        root = GFG.TrieNode()
        i = 0
        while (i < n) :
            x = arr[i]
             
            # Insert the curr_xor in the trie
            GFG.insert(root, curr_xor, i)
             
            # Update the cumulative xor
            curr_xor ^= x
             
            # Check if the cumulative xor
            # is present in the trie or not
            # if present then add
            # (sz * index) - sum
            number_of_triplets += GFG.query(root, curr_xor, i)
            i += 1
        return number_of_triplets
       
    # Driver Code
    @staticmethod
    def main( args) :
       
        # Given array
        arr = [5, 2, 7]
        n = len(arr)
        print(GFG.no_of_triplets(arr, n))
     
if __name__=="__main__":
    GFG.main([])
     
    # This code is contributed by aadityaburujwale.




// C# trie based program to find the Number of
// triplets in array having subarray xor equal
using System;
 
// Structure of a Trie Node
class TrieNode {
 
  // [0] index is bit 0
  // and [1] index is bit 1
  public TrieNode[] children;
 
  // Sum of indexes
  // inserted at at a node
  public int sum_of_indexes;
 
  // Number of indexes
  // inserted at a node
  public int number_of_indexes;
 
  // Constructor to initialize
  // a newly created node
  public TrieNode()
  {
    children = new TrieNode[2];
    this.children[0] = null;
    this.children[1] = null;
    this.sum_of_indexes = 0;
    this.number_of_indexes = 0;
  }
}
 
public class GFG {
 
  // maximum number of bits
  // in an integer <= 1e9
  static int lg = 31;
 
  // Function to insert curr_xor
  // into the trie
  static void insert(TrieNode node, int num, int index)
  {
 
    // Iterate from the 31st bit
    // to the 0th bit of curr_xor
    // number
    for (int bits = lg; bits >= 0; bits--) {
 
      // Check if the current
      // bit is set or not
      int curr_bit = (num >> bits) & 1;
 
      // If this node isn't already
      // present in the trie structure
      // insert it into the trie.
      if (node.children[curr_bit] == null) {
        node.children[curr_bit] = new TrieNode();
      }
 
      node = node.children[curr_bit];
    }
 
    // Increase the sum of
    // indexes by the current
    // index value
    node.sum_of_indexes += index;
 
    // Increase the number
    // of indexes by 1
    node.number_of_indexes++;
  }
 
  // Function to check if curr_xor
  // is present in trie or not
  static int query(TrieNode node, int num, int index)
  {
 
    // Iterate from the 31st bit
    // to the 0th bit of curr_xor number
    for (int bits = lg; bits >= 0; bits--) {
 
      // Check if the current bit
      // is set or not
      int curr_bit = (num >> bits) & 1;
 
      // If this node isn't already
      // present in the trie structure
      // that means no sub array till
      // current index has 0 xor so
      // return 0
      if (node.children[curr_bit] == null) {
        return 0;
      }
 
      node = node.children[curr_bit];
    }
 
    // Calculate the number of index
    // inserted at final node
    int sz = node.number_of_indexes;
 
    // Calculate the sum of index
    // inserted at final node
    int sum = node.sum_of_indexes;
 
    int ans = (sz * index) - (sum);
 
    return ans;
  }
 
  // Function to return the count of
  // valid triplets
  static int no_of_triplets(int[] arr, int n)
  {
 
    // To store cumulative xor
    int curr_xor = 0;
 
    int number_of_triplets = 0;
 
    // The root of the trie
    TrieNode root = new TrieNode();
 
    for (int i = 0; i < n; i++) {
 
      int x = arr[i];
 
      // Insert the curr_xor in the trie
      insert(root, curr_xor, i);
 
      // Update the cumulative xor
      curr_xor ^= x;
 
      // Check if the cumulative xor
      // is present in the trie or not
      // if present then add
      // (sz * index) - sum
      number_of_triplets += query(root, curr_xor, i);
    }
 
    return number_of_triplets;
  }
 
  static public void Main()
  {
    // Given array
    int[] arr = { 5, 2, 7 };
    int n = arr.Length;
 
    Console.WriteLine(no_of_triplets(arr, n));
  }
}
 
// This code is contributed by lokeshmvs21.




// JavaScript trie based program to find the Number of
// triplets in array having subarray xor equal
// maximum number of bits
// in an integer <= 1e9
const lg = 31;
 
// Structure of a Trie Node
class TrieNode {
  constructor() {
    // [0] index is bit 0
    // and [1] index is bit 1
    this.children = [null, null];
 
    // Sum of indexes
    // inserted at a node
    this.sum_of_indexes = 0;
 
    // Number of indexes
    // inserted at a node
    this.number_of_indexes = 0;
  }
}
 
// Function to insert curr_xor
// into the trie
const insert = (node, num, index) => {
  // Iterate from the 31st bit
  // to the 0th bit of curr_xor
  // number
  for (let bits = lg; bits >= 0; bits--) {
    // Check if the current
    // bit is set or not
    const curr_bit = (num >> bits) & 1;
 
    // If this node isn't already
    // present in the trie structure
    // insert it into the trie.
    if (node.children[curr_bit] == null) {
      node.children[curr_bit] = new TrieNode();
    }
 
    node = node.children[curr_bit];
  }
 
  // Increase the sum of
  // indexes by the current
  // index value
  node.sum_of_indexes += index;
 
  // Increase the number
  // of indexes by 1
  node.number_of_indexes++;
};
 
// Function to check if curr_xor
// is present in trie or not
const query = (node, num, index) => {
  // Iterate from the 31st bit
  // to the 0th bit of curr_xor number
  for (let bits = lg; bits >= 0; bits--) {
    // Check if the current bit
    // is set or not
    const curr_bit = (num >> bits) & 1;
 
    // If this node isn't already
    // present in the trie structure
    // that means no sub array till
    // current index has 0 xor so
    // return 0
    if (node.children[curr_bit] == null) {
      return 0;
    }
 
    node = node.children[curr_bit];
  }
 
  // Calculate the number of index
  // inserted at final node
  const sz = node.number_of_indexes;
 
  // Calculate the sum of index
  // inserted at final node
  const sum = node.sum_of_indexes;
 
  const ans = (sz * index) - (sum);
 
  return ans;
};
 
// Function to return the count of
// valid triplets
const no_of_triplets = (arr, n) => {
  // To store cumulative xor
  let curr_xor = 0;
 
  let number_of_triplets = 0;
 
  // The root of the trie
  const root = new TrieNode();
 
  for (let i = 0; i < n; i++) {
    const x = arr[i];
 
    // Insert the curr_xor in the trie
    insert(root, curr_xor, i);
 
    // Update the cumulative xor
    curr_xor ^= x;
 
    // Check if the cumulative xor
    // is present in the trie or not
    // if present then add
    // (sz * index) - sum
    number_of_triplets += query(root, curr_xor, i);
  }
 
  return number_of_triplets;
};
 
// Driver Code
// Given array
const arr = [5, 2, 7];
const n = arr.length;
 
console.log(no_of_triplets(arr, n));
// contributed by akashish__

Output
2

Time complexity: O(31*N) 
Auxiliary Space: O(N).  


Article Tags :