Number of Unique XOR Triplets II - Problem

You are given an integer array nums. A XOR triplet is defined as the XOR of three elements nums[i] XOR nums[j] XOR nums[k] where i <= j <= k.

Return the number of unique XOR triplet values from all possible triplets (i, j, k).

Input & Output

Example 1 — Basic Case

$ Input: nums = [2,3,1,4]

› Output: 8

💡 Note: All possible XOR triplets: (0,0,0)→2, (0,0,1)→3, (0,0,2)→1, (0,0,3)→4, (0,1,1)→2, (0,1,2)→0, (0,1,3)→5, (0,2,2)→2, (0,2,3)→7, (0,3,3)→2, (1,1,1)→3, (1,1,2)→1, (1,1,3)→4, (1,2,2)→3, (1,2,3)→6, (1,3,3)→3, (2,2,2)→1, (2,2,3)→4, (2,3,3)→1, (3,3,3)→4. Unique values: {0,1,2,3,4,5,6,7} = 8 different values.

Example 2 — Small Array

$ Input: nums = [1,2]

› Output: 2

💡 Note: All triplets: (0,0,0)→1, (0,0,1)→2, (0,1,1)→1, (1,1,1)→2. Unique values: {1,2} = 2 different values.

Example 3 — Identical Elements

$ Input: nums = [5,5,5]

› Output: 1

💡 Note: All triplets use three 5's in various combinations, but since XOR of any odd number of identical values equals the value itself, all results equal 5. Unique values: {5} = 1 different value.

Constraints

3 ≤ nums.length ≤ 1000
0 ≤ nums[i] ≤ 2¹⁶

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15 f Meta 12

The key insight is to generate all possible XOR triplets where indices satisfy i ≤ j ≤ k and count unique values using a set. Best approach is brute force with three nested loops since we must examine all combinations. Time: O(n³), Space: O(k) where k is the number of unique XOR results.

Common Approaches

✓ Bit Manipulation with Early Termination

⏱️ Time: O(n³) Space: O(k)

Leverages XOR properties like commutativity (a^b = b^a) and self-cancellation (a^a = 0) to optimize calculations. Uses bit patterns to potentially reduce redundant computations.

Brute Force Triple Nested Loop

⏱️ Time: O(n³) Space: O(k)

Use three nested loops to generate all valid triplets (i, j, k) where i <= j <= k. Calculate XOR for each triplet and use a set to track unique values.

Two-Pass with Pair Preprocessing

⏱️ Time: O(n³) Space: O(n²)

First pass computes XOR of all pairs (i,j) where i<=j. Second pass combines each pair result with elements k where j<=k, storing unique triplet XORs in a set.

Bit Manipulation with Early Termination — Algorithm Steps

Use XOR commutativity to avoid redundant calculations
Apply early termination when possible duplicate patterns are detected
Leverage bit manipulation to group similar XOR operations
Store unique results efficiently using bit-based data structures

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Arrange elements to optimize bit patterns

XOR Associativity

Use (a^b)^c property for efficient computation

Unique Collection

Collect unique results using optimized storage

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_SIZE 1000
#define HASH_SIZE 10007

typedef struct Node {
    int value;
    struct Node* next;
} Node;

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int hash_function(int value) {
    return abs(value) % HASH_SIZE;
}

int contains(Node* hash_table[], int value) {
    int index = hash_function(value);
    Node* current = hash_table[index];
    while (current) {
        if (current->value == value) return 1;
        current = current->next;
    }
    return 0;
}

void insert(Node* hash_table[], int value) {
    if (contains(hash_table, value)) return;
    
    int index = hash_function(value);
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->value = value;
    new_node->next = hash_table[index];
    hash_table[index] = new_node;
}

int count_unique(Node* hash_table[]) {
    int count = 0;
    for (int i = 0; i < HASH_SIZE; i++) {
        Node* current = hash_table[i];
        while (current) {
            count++;
            current = current->next;
        }
    }
    return count;
}

int solution(int nums[], int n) {
    Node* hash_table[HASH_SIZE] = {NULL};
    
    // Sort to potentially optimize bit patterns
    qsort(nums, n, sizeof(int), compare);
    
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Precompute pair XOR
            int pair_xor = nums[i] ^ nums[j];
            
            for (int k = j; k < n; k++) {
                // Use XOR associativity
                int triplet_xor = pair_xor ^ nums[k];
                insert(hash_table, triplet_xor);
            }
        }
    }
    
    return count_unique(hash_table);
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[MAX_SIZE];
    int n = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Must still examine all triplet combinations despite optimizations

⚠ Quadratic Growth

Space Complexity

O(k)

Set stores unique XOR values, k ≤ 2^(max_bits)

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Number of Unique XOR Triplets II - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bit Manipulation with Early Termination — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler