Number of Unique XOR Triplets I - Practice Coding Problems

Number of Unique XOR Triplets I - Problem

Given an integer array nums of length n, where nums is a permutation of numbers from 1 to n, find the number of unique XOR triplet values.

A XOR triplet is defined as the XOR operation applied to three elements: nums[i] XOR nums[j] XOR nums[k] where i ≤ j ≤ k.

Your task is to return the count of unique XOR values that can be obtained from all possible triplets (i, j, k).

Note: We only care about the unique XOR values, not the number of ways to form them.

Input & Output

example_1.py — Basic Case

$ Input: [1, 2, 3]

› Output: 4

💡 Note: All possible triplets: (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} = 4

example_2.py — Minimum Case

$ Input: [1]

› Output: 1

💡 Note: Only one possible triplet: (0,0,0) which gives 1⊕1⊕1 = 1. So there's 1 unique XOR value.

example_3.py — Four Elements

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

› Output: 8

💡 Note: With 4 elements, we get many more triplet combinations. The XOR operations produce 8 different unique values when considering all valid triplets (i,j,k) where i≤j≤k.

Constraints

1 ≤ n ≤ 1000
nums is a permutation of [1, 2, ..., n]
All elements in nums are unique and in range [1, n]

Visualization

Tap to expand

Understanding the Visualization

Setup Phase

Initialize empty set for tracking unique XOR results and prepare three nested loops

Generate Triplets

Use constraints i≤j≤k to generate all valid index combinations systematically

Compute XOR

For each triplet, calculate nums[i] ⊕ nums[j] ⊕ nums[k] using bitwise XOR

Track Uniqueness

Add XOR result to set - duplicates automatically filtered out

Return Count

Final answer is the size of our set containing all unique XOR values

Key Takeaway

🎯 Key Insight: Use a set data structure to automatically handle duplicate XOR values while systematically generating all valid triplets with the constraint i≤j≤k

Asked in

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

The optimal approach uses brute force with set deduplication - generate all possible triplets (i,j,k) where i≤j≤k using three nested loops, compute their XOR values, and use a set to automatically handle duplicates. While O(n³) time complexity, it's straightforward and works well for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Loops)	O(n³)	O(k)	Generate all possible triplets and store unique XOR values in a set

Brute Force (Triple Nested Loops) — Algorithm Steps

Initialize an empty set to store unique XOR values
Use three nested loops: i from 0 to n-1, j from i to n-1, k from j to n-1
For each valid triplet (i,j,k), compute nums[i] XOR nums[j] XOR nums[k]
Add the XOR result to the set (duplicates automatically handled)
Return the size of the set

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty set and three pointers at beginning

First Loop

Fix first element, move second and third pointers

Compute XOR

Calculate XOR of current triplet and add to set

Continue

Move to next valid triplet combination

Code -

solution.c — C

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

#define MAX_XOR 8192
bool seen[MAX_XOR];

int countUniqueXORTriplets(int* nums, int n) {
    // Initialize seen array
    for (int i = 0; i < MAX_XOR; i++) {
        seen[i] = false;
    }
    
    int uniqueCount = 0;
    
    // Generate all possible triplets (i, j, k) where i <= j <= k
    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 (!seen[xorResult]) {
                    seen[xorResult] = true;
                    uniqueCount++;
                }
            }
        }
    }
    
    return uniqueCount;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops each running up to n times

⚠ Quadratic Growth

Space Complexity

O(k)

Where k is the number of unique XOR values (at most 2^(max bits))

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

842 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Triple Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler