Count Pairs With XOR in a Range - Practice Coding Problems

Count Pairs With XOR in a Range - Problem

Welcome to the world of XOR operations! In this challenging problem, you need to find pairs of numbers whose XOR result falls within a specific range.

Given an integer array nums and two integers low and high, your task is to count all "nice pairs" in the array.

A nice pair is defined as a pair (i, j) where:

0 <= i < j < nums.length (i comes before j)
low <= (nums[i] XOR nums[j]) <= high (XOR result is within range)

Example: If nums = [1, 4, 2, 7], low = 2, and high = 6, then pair (1, 4) has XOR value 1 ⊕ 4 = 5, which is within range [2, 6].

The challenge lies in efficiently computing XOR values for all pairs while staying within time limits for large arrays.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1, 4, 2, 7], low = 2, high = 6

› Output: 6

💡 Note: All pairs have XOR values in range: (1,4)→5, (1,2)→3, (1,7)→6, (4,2)→6, (4,7)→3, (2,7)→5. All 6 pairs are valid.

example_2.py — Narrow Range

$ Input: nums = [9, 8, 4, 2, 1], low = 5, high = 14

› Output: 8

💡 Note: Valid pairs: (9,8)→1❌, (9,4)→13✓, (9,2)→11✓, (9,1)→8✓, (8,4)→12✓, (8,2)→10✓, (8,1)→9✓, (4,2)→6✓, (4,1)→5✓, (2,1)→3❌. Count = 8.

example_3.py — Edge Case

$ Input: nums = [1, 1, 1], low = 0, high = 0

› Output: 3

💡 Note: All pairs (1,1) have XOR = 0, which equals both low and high bounds. Pairs: (0,1), (0,2), (1,2) all give XOR = 0.

Visualization

Tap to expand

Understanding the Visualization

Prepare Keys

Convert each number to its binary representation - these are our security keys

Smart Matching

Use a Trie to efficiently find which key combinations produce codes in our target range

Count Valid Codes

For each key, query the Trie to count how many previous keys would create valid security codes

Key Takeaway

🎯 Key Insight: By representing numbers in binary and using a Trie, we can efficiently navigate through bit patterns to count XOR pairs within any range, transforming a quadratic problem into a near-linear solution.

Time & Space Complexity

Time Complexity

⏱️

O(n * log(MAX_VAL))

Each number requires O(log(MAX_VAL)) time for Trie operations, done for n numbers

⚡ Linearithmic

Space Complexity

O(n * log(MAX_VAL))

Trie stores up to n numbers, each with log(MAX_VAL) bits

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
1 ≤ nums[i] ≤ 2 × 10⁴
1 ≤ low ≤ high ≤ 2 × 10⁴
XOR operations are bitwise exclusive OR

Asked in

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

The optimal solution uses a Trie data structure to efficiently count XOR pairs within a range. By leveraging the bit-wise nature of XOR operations, we can achieve O(n × log(MAX_VAL)) time complexity instead of the brute force O(n²) approach. The key insight is using range query technique: count(≤ high) - count(< low) to find pairs within [low, high].

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check every pair of elements and count those with XOR in range
Trie-Based Solution (Optimal)	O(n * log(MAX_VAL))	O(n * log(MAX_VAL))	Use a Trie data structure to efficiently count XOR pairs within range

Brute Force (Nested Loops) — Algorithm Steps

Use two nested loops to generate all pairs (i, j) where i < j
For each pair, compute nums[i] XOR nums[j]
Check if the XOR result is within [low, high] range
Increment counter if the condition is satisfied
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with the first element and check against all following elements

Compute XOR

Calculate XOR for each pair and check if it's in range

Count Valid

Increment counter for pairs within the specified range

Code -

solution.c — C

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

int countPairsInRange(int* nums, int n, int low, int high) {
    int count = 0;
    
    // Check all pairs (i, j) where i < j
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int xorVal = nums[i] ^ nums[j];
            if (low <= xorVal && xorVal <= high) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    int nums[20000];
    int n = 0;
    int num;
    
    char line[100000];
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, " ");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    int low, high;
    scanf("%d %d", &low, &high);
    
    printf("%d\n", countPairsInRange(nums, n, low, high));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We need to check all n(n-1)/2 pairs, which is O(n²)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting and iteration

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
1 ≤ nums[i] ≤ 2 × 10⁴
1 ≤ low ≤ high ≤ 2 × 10⁴
XOR operations are bitwise exclusive OR

23.4K Views

Medium-High Frequency

~35 min Avg. Time

987 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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler