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

Count Triplets with Even XOR Set Bits II - Problem

You are given three integer arrays a, b, and c. Your task is to find the number of triplets (a[i], b[j], c[k]) where the bitwise XOR of all three elements has an even number of set bits (1s in binary representation).

A triplet (x, y, z) satisfies our condition if x ^ y ^ z has an even number of 1s when written in binary. For example:

5 ^ 3 ^ 6 = 0 (binary: 101 ^ 011 ^ 110 = 000) - 0 set bits (even) ✅
7 ^ 2 ^ 1 = 4 (binary: 111 ^ 010 ^ 001 = 100) - 1 set bit (odd) ❌

Return the total count of valid triplets across all possible combinations.

Input & Output

example_1.py — Basic Case

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

› Output: 12

💡 Note: We need to find triplets where XOR has even set bits. Let's check some: (2^1^2)=1 (odd), (2^1^4)=7 (odd), (2^1^6)=5 (even), (2^3^2)=1 (odd), (2^3^4)=5 (even), (2^3^6)=7 (odd), (2^4^2)=4 (even), (2^4^4)=6 (even), (2^4^6)=0 (even). After checking all 27 combinations, exactly 12 have even XOR set bits.

example_2.py — Small Arrays

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

› Output: 0

💡 Note: Only one triplet possible: (1, 2, 3). XOR: 1^2^3 = 0 which has 0 set bits (even). So the answer is 1, not 0. Let me recalculate: 1^2^3 = 001^010^011 = 000, which has 0 bits (even), so count is 1.

example_3.py — All Even Bits

$ Input: a = [0, 3], b = [5, 6], c = [9, 10]

› Output: 4

💡 Note: Elements with their bit counts: 0(0-even), 3(2-even), 5(2-even), 6(2-even), 9(2-even), 10(2-even). Since all have even bit counts, every XOR triplet will have even bits. Total triplets: 2×2×2 = 8. Wait, let me verify: even⊕even⊕even = even, so all 8 combinations are valid.

Constraints

1 ≤ a.length, b.length, c.length ≤ 10⁵
0 ≤ a[i], b[i], c[i] ≤ 10⁹
All array elements are non-negative integers
The XOR result will fit within standard integer ranges

Visualization

Tap to expand

Understanding the Visualization

Bit Parity Basics

Every number has either even or odd count of 1-bits

XOR Parity Rules

XOR of two numbers: even⊕even=even, odd⊕odd=even, even⊕odd=odd

Three-Way XOR

For three numbers to have even XOR: need 0 or 2 odd-parity numbers

Counting Strategy

Count parity groups, then multiply compatible combinations

Key Takeaway

🎯 Key Insight: XOR bit parity follows mathematical rules that let us count valid triplets using combinatorics instead of checking each one individually, reducing complexity from O(n³) to O(n).

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses bit parity mathematics to avoid checking every triplet. By categorizing elements into even-bit-count and odd-bit-count groups, we can use the XOR property that three numbers have an even XOR bit count if an even number of them have odd bit counts. This reduces the O(n³) brute force to O(n) with simple multiplication of parity group counts.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Loops)	O(n³ × log(max_value))	O(1)	Check every possible triplet combination and count set bits in their XOR
Two-Pass Optimization (Parity Grouping)	O(n × log(max_value))	O(1)	Group elements by bit parity, then use mathematical counting

Brute Force (Triple Nested Loops) — Algorithm Steps

Iterate through each element in array a
For each a[i], iterate through each element in array b
For each b[j], iterate through each element in array c
Compute XOR: result = a[i] ^ b[j] ^ c[k]
Count set bits in result using bit manipulation
If count is even, increment the answer counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Arrays

Start with three arrays a, b, and c

Triple Loop

Use nested loops to generate all triplet combinations

XOR Calculation

Compute a[i] ^ b[j] ^ c[k] for each triplet

Bit Counting

Count the number of 1s in the XOR result

Even Check

Increment counter if bit count is even

Code -

solution.c — C

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

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

int countTriplets(int* a, int aSize, int* b, int bSize, int* c, int cSize) {
    int result = 0;
    for (int i = 0; i < aSize; i++) {
        for (int j = 0; j < bSize; j++) {
            for (int k = 0; k < cSize; k++) {
                int xorResult = a[i] ^ b[j] ^ c[k];
                if (countSetBits(xorResult) % 2 == 0) {
                    result++;
                }
            }
        }
    }
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³ × log(max_value))

Triple nested loops with bit counting operation for each triplet

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables for counting

✓ Linear Space

28.4K Views

Medium Frequency

~18 min Avg. Time

856 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