Count Triplets with Even XOR Set Bits I - Practice Coding Problems

Count Triplets with Even XOR Set Bits I - Problem

Given three integer arrays a, b, and c, you need to find the number of triplets (a[i], b[j], c[k]) where the XOR of all three elements has an even number of set bits.

A set bit is a bit with value 1 in the binary representation of a number. For example, the number 5 (binary: 101) has 2 set bits, while 7 (binary: 111) has 3 set bits.

The key insight is that XOR has an even number of set bits if and only if an even number of the operands have an odd number of set bits. This is because XOR combines bits, and the parity (even/odd) of set bits follows specific rules.

Examples:

3 ⊕ 5 ⊕ 6 = 0 → 0 set bits (even) ✓
1 ⊕ 2 ⊕ 4 = 7 → 3 set bits (odd) ✗
2 ⊕ 3 ⊕ 1 = 0 → 0 set bits (even) ✓

Input & Output

example_1.py — Basic Case

$ Input: a = [2, 1], b = [3, 4], c = [1, 5]

› Output: 4

💡 Note: Valid triplets: (2,3,1)→XOR=0(0 bits), (2,4,5)→XOR=3(2 bits), (1,3,1)→XOR=3(2 bits), (1,4,5)→XOR=0(0 bits). All have even number of set bits.

example_2.py — Single Elements

$ Input: a = [1], b = [2], c = [3]

› Output: 0

💡 Note: Only triplet is (1,2,3). XOR: 1⊕2⊕3 = 0⊕3 = 3 (binary: 11), which has 2 set bits (even). Wait, this should be 1! Let me recalculate: 1⊕2⊕3 = 3⊕3 = 0, which has 0 set bits (even). Result: 1.

example_3.py — All Same

$ Input: a = [0], b = [0], c = [0]

› Output: 1

💡 Note: Single triplet (0,0,0). XOR: 0⊕0⊕0 = 0, which has 0 set bits (even). This triplet is valid.

Constraints

1 ≤ a.length, b.length, c.length ≤ 10⁵
0 ≤ a[i], b[i], c[i] ≤ 10⁹
The number of valid triplets will fit in a 32-bit integer
Note: XOR of three numbers has even parity iff an even number of them have odd parity

Visualization

Tap to expand

Understanding the Visualization

Classify Elements

Separate each array into even-parity and odd-parity groups

Apply Parity Rule

Valid triplets need 0 or 2 odd-parity elements (even total)

Count Mathematically

Use multiplication principle instead of generating all combinations

Optimize

Single pass through arrays, constant-time calculations

Key Takeaway

🎯 Key Insight: XOR parity depends only on the count of odd-parity operands, enabling mathematical optimization without computing actual XOR values.

Asked in

G Google 35 ⊞ Microsoft 28 a Amazon 22 f Meta 18

The optimal solution leverages the mathematical property that XOR has even parity if and only if an even number of operands have odd parity. Instead of computing XOR values, we count elements by parity in each array and use combinatorial counting to find valid triplets in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Parity Counting (Optimal)	O(n)	O(1)	Count elements by parity and use mathematical combinations
Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check every possible triplet combination and count set bits in their XOR

Optimized Parity Counting (Optimal) — Algorithm Steps

For each array, count elements with even vs odd number of set bits
Use the parity rule: valid triplets have 0 or 2 elements with odd parity
Case 1: All three elements have even parity → even_a × even_b × even_c
Case 2: Exactly two elements have odd parity → Calculate all combinations
Sum all valid combinations to get the final count

Visualization

Tap to expand

Step-by-Step Walkthrough

Classify by Parity

Count even and odd parity elements in each array

Apply Parity Rule

Valid triplets need 0 or 2 odd-parity elements

Count Combinations

Use multiplication principle for valid cases

Sum Results

Add all valid combination counts

Code -

solution.c — C

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

int popcount(int n) {
    int count = 0;
    while (n) {
        count += n & 1;
        n >>= 1;
    }
    return count;
}

void countParity(int* arr, int size, int* evenCount, int* oddCount) {
    *evenCount = *oddCount = 0;
    for (int i = 0; i < size; i++) {
        if (popcount(arr[i]) % 2 == 0) {
            (*evenCount)++;
        } else {
            (*oddCount)++;
        }
    }
}

int countTriplets(int* a, int aSize, int* b, int bSize, int* c, int cSize) {
    int evenA, oddA, evenB, oddB, evenC, oddC;
    countParity(a, aSize, &evenA, &oddA);
    countParity(b, bSize, &evenB, &oddB);
    countParity(c, cSize, &evenC, &oddC);
    
    // Case 1: All even parity
    int case1 = evenA * evenB * evenC;
    
    // Case 2: Exactly 2 odd parity
    int case2 = oddA * oddB * evenC +
                oddA * evenB * oddC +
                evenA * oddB * oddC;
    
    return case1 + case2;
}

int main() {
    int a[] = {2, 1};
    int b[] = {3, 4};
    int c[] = {1, 5};
    printf("%d\n", countTriplets(a, 2, b, 2, c, 2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all arrays to count parities, then constant time for combination calculations

✓ Linear Growth

Space Complexity

O(1)

Only storing counters for even/odd elements in each array

✓ 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Optimized Parity Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler