Number of Unique XOR Triplets I - Problem

You are given an integer array nums of length n, where nums is a permutation of the numbers in the range [1, n].

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 = [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 are {0,1,2,3}, so answer is 4.

Example 2 — Smaller Array

$ Input: nums = [2,1]

› Output: 2

💡 Note: Possible triplets: (0,0,0):2⊕2⊕2=2, (0,0,1):2⊕2⊕1=1, (0,1,1):2⊕1⊕1=2, (1,1,1):1⊕1⊕1=1. Unique values are {1,2}, so answer is 2.

Example 3 — Single Element

$ Input: nums = [1]

› Output: 1

💡 Note: Only one triplet possible: (0,0,0):1⊕1⊕1=1. Unique values are {1}, so answer is 1.

Constraints

1 ≤ nums.length ≤ 300
nums is a permutation of [1, 2, ..., n]

Visualization

Tap to expand

Asked in

M Microsoft 15 G Google 12 f Meta 8

The key insight is that XOR has special properties: a⊕a=0 and a⊕a⊕b=b. We need to generate all valid triplets (i,j,k) where i≤j≤k and count unique XOR values. The brute force approach uses three nested loops with O(n³) time. An optimized approach can use frequency counting to group identical elements and reduce redundant calculations. Best approach is brute force for this problem size. Time: O(n³), Space: O(n³)

Common Approaches

✓ Optimized with Early Termination

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

Leverage XOR properties like commutativity and the fact that a⊕a=0 to optimize the brute force approach. We can also use frequency counting to reduce some redundant work.

Triple Nested Loop

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

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

Optimized with Early Termination — Algorithm Steps

Use XOR properties to simplify calculations
Group identical elements to reduce iterations
Apply early termination when possible
Use bit manipulation tricks for faster XOR operations

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Group identical elements to avoid redundant XOR calculations

Handle Cases

Separate logic for same elements vs different elements

Combine Results

Merge all unique XOR values from different cases

Code -

solution.c — C

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

int solution(int* nums, int n) {
    int uniqueXors[100000];
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            for (int k = j; k < n; k++) {
                int xorValue = nums[i] ^ nums[j] ^ nums[k];
                
                // Check if this XOR value already exists
                int found = 0;
                for (int l = 0; l < count; l++) {
                    if (uniqueXors[l] == xorValue) {
                        found = 1;
                        break;
                    }
                }
                
                if (!found) {
                    uniqueXors[count++] = xorValue;
                }
            }
        }
    }
    
    return count;
}

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[1000];
    int n = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Still need to consider all triplet combinations, but with some optimizations

⚠ Quadratic Growth

Space Complexity

O(n)

Uses frequency counting and optimized storage for unique values

⚠ Quadratic Space

8.3K Views

Medium Frequency

~15 min Avg. Time

156 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 I - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Optimized with Early Termination — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler