Count Pairs With XOR in a Range

Count Pairs With XOR in a Range - Problem

Given a 0-indexed integer array nums and two integers low and high, return the number of nice pairs.

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

0 <= i < j < nums.length
low <= (nums[i] XOR nums[j]) <= high

The XOR operation computes the bitwise exclusive OR of two numbers.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Nice pairs are (0,2): 1^2=3 ∈ [1,4] and (1,3): 4^7=3 ∈ [1,4]. Total count is 2.

Example 2 — Wider Range

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

› Output: 8

💡 Note: Multiple pairs have XOR values in [5,14]: (0,1): 9^8=1 ✗, (0,2): 9^4=13 ✓, (0,3): 9^2=11 ✓, etc. Count all valid pairs.

Example 3 — No Valid Pairs

$ Input: nums = [1,1,1], low = 5, high = 10

› Output: 0

💡 Note: All pairs have XOR = 1^1 = 0, which is not in range [5,10]. No nice pairs exist.

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
1 ≤ nums[i] ≤ 2 × 10⁴
1 ≤ low ≤ high ≤ 2 × 10⁴

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22

The key insight is that we need to count pairs efficiently where XOR falls in a range. The brute force approach checks all pairs in O(n²) time. The optimal trie-based solution uses binary representation to count XOR values in range efficiently. Time: O(n × log(max_val)), Space: O(n × log(max_val))

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force - Check All Pairs

⏱️ Time: O(n²) Space: O(1)

Generate all possible pairs where i < j, compute their XOR, and count how many fall within [low, high] range.

Trie-Based XOR Range Count

⏱️ Time: O(n × log(max_val)) Space: O(n × log(max_val))

Build a trie to store binary representations of numbers, then for each number, traverse the trie to count how many existing numbers produce XOR values in the target range.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct TrieNode {
    struct TrieNode* children[2];
    int count;
} TrieNode;

typedef struct {
    TrieNode* root;
    int maxBits;
} Trie;

TrieNode* createNode() {
    TrieNode* node = (TrieNode*)calloc(1, sizeof(TrieNode));
    return node;
}

Trie* createTrie(int maxBits) {
    Trie* trie = (Trie*)malloc(sizeof(Trie));
    trie->root = createNode();
    trie->maxBits = maxBits;
    return trie;
}

void insert(Trie* trie, int num) {
    TrieNode* node = trie->root;
    for (int i = trie->maxBits - 1; i >= 0; i--) {
        int bit = (num >> i) & 1;
        if (!node->children[bit]) {
            node->children[bit] = createNode();
        }
        node = node->children[bit];
        node->count++;
    }
}

int dfs(TrieNode* node, int num, int limit, int bitPos) {
    if (!node || bitPos < 0) {
        return node ? node->count : 0;
    }
    
    int numBit = (num >> bitPos) & 1;
    int limitBit = (limit >> bitPos) & 1;
    int result = 0;
    
    if (limitBit == 1) {
        if (node->children[numBit]) {
            result += dfs(node->children[numBit], num, limit, bitPos - 1);
        }
        if (node->children[1 - numBit]) {
            result += dfs(node->children[1 - numBit], num, (1 << bitPos) - 1, bitPos - 1);
        }
    } else {
        if (node->children[numBit]) {
            result += dfs(node->children[numBit], num, limit, bitPos - 1);
        }
    }
    
    return result;
}

int countLessEqual(Trie* trie, int num, int limit) {
    if (limit < 0) {
        return 0;
    }
    return dfs(trie->root, num, limit, trie->maxBits - 1);
}

int countXorInRange(Trie* trie, int num, int low, int high) {
    return countLessEqual(trie, num, high) - countLessEqual(trie, num, low - 1);
}

int solution(int* nums, int numsSize, int low, int high) {
    Trie* trie = createTrie(20);
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        count += countXorInRange(trie, nums[i], low, high);
        insert(trie, nums[i]);
    }
    
    return count;
}

int parseArray(char* str, int* nums) {
    int count = 0;
    char* p = str;
    
    // Find opening bracket
    while (*p && *p != '[') p++;
    if (!*p) return 0;
    p++;
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p && (*p == ' ' || *p == ',' || *p == '\t' || *p == '\n')) p++;
        
        if (*p && *p != ']' && (isdigit(*p) || *p == '-')) {
            nums[count] = (int)strtol(p, &p, 10);
            count++;
        }
        
        // Skip to next number or end
        while (*p && *p != ',' && *p != ']') p++;
        if (*p == ',') p++;
    }
    
    return count;
}

int main() {
    char buffer[100000];
    int nums[1000];
    
    // Read nums array
    fgets(buffer, sizeof(buffer), stdin);
    int numsSize = parseArray(buffer, nums);
    
    // Read low
    fgets(buffer, sizeof(buffer), stdin);
    int low = atoi(buffer);
    
    // Read high
    fgets(buffer, sizeof(buffer), stdin);
    int high = atoi(buffer);
    
    int result = solution(nums, numsSize, low, high);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

38.5K Views

Medium Frequency

~35 min Avg. Time

1.8K 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