Number of Unique XOR Triplets II - Practice Coding Problems

Number of Unique XOR Triplets II - Problem

Given an integer array nums, you need to find all possible XOR triplets and count how many unique XOR values they produce.

A XOR triplet is defined as nums[i] ⊕ nums[j] ⊕ nums[k] where i ≤ j ≤ k. Note that the same element can be used multiple times if the indices satisfy the constraint.

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

Example: For array [1, 2, 3], possible triplets are:

1 ⊕ 1 ⊕ 1 = 1
1 ⊕ 1 ⊕ 2 = 2
1 ⊕ 1 ⊕ 3 = 3
1 ⊕ 2 ⊕ 2 = 1
1 ⊕ 2 ⊕ 3 = 0
And so on...

We only count the distinct XOR values, not how many times each appears.

Input & Output

example_1.py — Basic Case

$ Input: [1, 2, 3]

› Output: 4

💡 Note: All possible triplets and their XOR values: (0,0,0): 1⊕1⊕1=1, (0,0,1): 1⊕1⊕2=2, (0,0,2): 1⊕1⊕3=3, (0,1,1): 1⊕2⊕2=1, (0,1,2): 1⊕2⊕3=0, (0,2,2): 1⊕3⊕3=1, (1,1,1): 2⊕2⊕2=2, (1,1,2): 2⊕2⊕3=3, (1,2,2): 2⊕3⊕3=2, (2,2,2): 3⊕3⊕3=3. Unique values: {0, 1, 2, 3}, so answer is 4.

example_2.py — Duplicates

$ Input: [1, 1, 1]

› Output: 1

💡 Note: All triplets are (0,0,0), (0,0,1), (0,0,2), (0,1,1), (0,1,2), (0,2,2), (1,1,1), (1,1,2), (1,2,2), (2,2,2). Since all elements are 1, every XOR result is 1⊕1⊕1=1. Only one unique value: {1}.

example_3.py — Single Element

$ Input: [5]

› Output: 1

💡 Note: Only one possible triplet: (0,0,0) which gives 5⊕5⊕5=5. Only one unique XOR value: {5}.

Visualization

Tap to expand

Understanding the Visualization

Setup Assembly Line

Initialize our processing station with a collection bin (hash set) for unique XOR values

Generate Triplets

Systematically create all valid triplet combinations where i ≤ j ≤ k

XOR Processing

Feed each triplet through the XOR processor: nums[i] ⊕ nums[j] ⊕ nums[k]

Unique Collection

Processed results automatically sorted into unique bins - duplicates discarded

Count Results

Final count represents the number of different XOR values we can create

Key Takeaway

🎯 Key Insight: The hash set automatically deduplicates XOR results, making the algorithm both simple and efficient. This is the optimal solution since we must examine all O(n³) triplet combinations.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Must consider all possible triplets - this is the theoretical minimum for this problem

⚠ Quadratic Growth

Space Complexity

O(min(n³, 2^b))

Hash set stores unique XOR values, bounded by number of possible bit patterns

⚠ Quadratic Space

Constraints

1 ≤ nums.length ≤ 300
1 ≤ nums[i] ≤ 10⁸
Important: i ≤ j ≤ k constraint allows reuse of elements

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal approach uses a hash set to track unique XOR values while iterating through all possible triplets in O(n³) time. Since we must consider all triplet combinations, this time complexity is unavoidable. The key insight is using XOR's properties and a set for automatic deduplication, making this the most efficient solution possible for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Set (Optimal)	O(n³)	O(min(n³, 2^b))	Generate and store unique XOR triplets in a single optimized pass
Two-Pass with Frequency Counting	O(n³)	O(n + unique_values)	First pass counts element frequencies, second pass generates triplets efficiently
Brute Force (Triple Nested Loops)	O(n³)	O(min(n³, 2^b))	Generate all possible triplets and store unique XOR values in a set

One-Pass Hash Set (Optimal) — Algorithm Steps

Initialize a hash set to store unique XOR values
Use optimized triple loop with early bounds checking
For each triplet (i,j,k) where i ≤ j ≤ k, calculate XOR immediately
Insert XOR result into hash set (automatically handles duplicates)
Return the size of the hash set

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Set

Create empty hash set for unique XOR values

Triple Loop

Iterate through all valid triplet indices

Calculate & Store

Compute XOR and insert into set immediately

Auto-Dedup

Hash set automatically handles duplicates

Return Count

Size of set equals number of unique values

Code -

solution.c — C

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

#define MAX_VALS 100000

int countUniqueXORTriplets(int* nums, int n) {
    bool seen[MAX_VALS] = {false};
    int count = 0;
    
    // Single optimized pass
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            for (int k = j; k < n; k++) {
                int xorResult = nums[i] ^ nums[j] ^ nums[k];
                if (xorResult < MAX_VALS && !seen[xorResult]) {
                    seen[xorResult] = true;
                    count++;
                }
            }
        }
    }
    
    return count;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    while (scanf("%d%c", &nums[n], &c)) {
        n++;
        if (c == ']') break;
    }
    printf("%d\n", countUniqueXORTriplets(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Must consider all possible triplets - this is the theoretical minimum for this problem

⚠ Quadratic Growth

Space Complexity

O(min(n³, 2^b))

Hash set stores unique XOR values, bounded by number of possible bit patterns

⚠ Quadratic Space

Constraints

1 ≤ nums.length ≤ 300
1 ≤ nums[i] ≤ 10⁸
Important: i ≤ j ≤ k constraint allows reuse of elements

37.3K Views

Medium Frequency

~15 min Avg. Time

1.2K 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler