Number of Excellent Pairs - Practice Coding Problems

Number of Excellent Pairs - Problem

You are given a 0-indexed positive integer array nums and a positive integer k.

A pair of numbers (num1, num2) is called excellent if the following conditions are satisfied:

Both numbers num1 and num2 exist in the array nums
The sum of the number of set bits in num1 OR num2 and num1 AND num2 is greater than or equal to k

Here's the key insight: For any two numbers a and b, the number of set bits in (a OR b) + the number of set bits in (a AND b) equals the number of set bits in a + the number of set bits in b. This transforms our problem from complex bitwise operations to simple bit counting!

Goal: Return the number of distinct excellent pairs.

Important notes:

Pairs (a,b) and (c,d) are distinct if either a != c or b != d
Pairs like (1,2) and (2,1) are considered different
A number can be paired with itself if it appears in the array

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,2,3,1], k = 3

› Output: 5

💡 Note: Unique numbers are [1,2,3]. Check all pairs: (1,1): bits(1|1)+bits(1&1)=1+1=2<3 ✗, (1,2): bits(1|2)+bits(1&2)=2+0=2<3 ✗, (1,3): bits(1|3)+bits(1&3)=2+1=3≥3 ✓, (2,1): 2+0=2<3 ✗, (2,2): bits(2|2)+bits(2&2)=1+1=2<3 ✗, (2,3): bits(2|3)+bits(2&3)=2+2=4≥3 ✓, (3,1): 2+1=3≥3 ✓, (3,2): 2+2=4≥3 ✓, (3,3): bits(3|3)+bits(3&3)=2+2=4≥3 ✓. Total: 5 pairs.

example_2.py — All Pairs Excellent

$ Input: nums = [5,1,1], k = 1

› Output: 4

💡 Note: Unique numbers are [5,1]. Since k=1 is low, most pairs work: (5,5): bits(5)=2, 2+2=4≥1 ✓, (5,1): bits(5)+bits(1)=2+1=3≥1 ✓, (1,5): same as (5,1) ✓, (1,1): bits(1)=1, 1+1=2≥1 ✓. All 4 pairs are excellent.

example_3.py — High Threshold

$ Input: nums = [1,1,1,1], k = 10

› Output: 0

💡 Note: Only unique number is 1. The pair (1,1) has bits(1|1)+bits(1&1)=1+1=2, which is less than k=10. No excellent pairs exist.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 60
Each number has at most 20 bits (since 2²⁰ > 10⁹)

Visualization

Tap to expand

Understanding the Visualization

The Key Identity

For any two numbers, OR captures all set bits, AND captures common bits, and their sum equals the total individual bits

Frequency Mapping

Instead of checking each pair, group numbers by bit count and use multiplication

Mathematical Optimization

For each pair of bit counts summing to ≥k, multiply their frequencies

Key Takeaway

🎯 Key Insight: The mathematical identity `bits(a|b) + bits(a&b) = bits(a) + bits(b)` transforms an expensive bitwise problem into simple frequency counting and arithmetic, reducing complexity from O(n²) to O(n).

Asked in

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

The optimal solution uses the key insight that bits(a|b) + bits(a&b) = bits(a) + bits(b). Instead of computing expensive OR/AND operations, we count the frequency of each possible bit count (0-20) and calculate excellent pairs mathematically by checking which bit count combinations sum to ≥k.

Common Approaches

Approach	Time	Space	Notes
✓ Bit Count Frequency Map	O(n + 20²)	O(n + 20)	Count frequency of each bit count, then calculate pairs mathematically
Brute Force (Nested Loops)	O(n² × log(max_num))	O(n)	Check every possible pair and count set bits in OR and AND operations

Bit Count Frequency Map — Algorithm Steps

Remove duplicates from the input array
Count the number of set bits for each unique number
Build a frequency map: bit_count -> number of elements with that bit count
For each possible bit count i (0 to 20, since max number is 10^9)
For each possible bit count j (0 to 20)
If i + j >= k, add freq[i] * freq[j] to the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Bits

Count set bits in each unique number

Build Frequency Map

Group numbers by their bit count

Calculate Combinations

For each bit count pair summing to ≥k, multiply frequencies

Code -

solution.c — C

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

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

long long countExcellentPairs(int* nums, int numsSize, int k) {
    // Remove duplicates (simplified)
    int uniqueNums[numsSize];
    int uniqueCount = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int exists = 0;
        for (int j = 0; j < uniqueCount; j++) {
            if (uniqueNums[j] == nums[i]) {
                exists = 1;
                break;
            }
        }
        if (!exists) {
            uniqueNums[uniqueCount++] = nums[i];
        }
    }
    
    // Count frequency of each bit count
    int bitCountFreq[21] = {0};
    for (int i = 0; i < uniqueCount; i++) {
        int bitCount = popcount(uniqueNums[i]);
        bitCountFreq[bitCount]++;
    }
    
    long long result = 0;
    // Check all combinations of bit counts
    for (int bits1 = 0; bits1 <= 20; bits1++) {
        for (int bits2 = 0; bits2 <= 20; bits2++) {
            if (bits1 + bits2 >= k) {
                result += (long long)bitCountFreq[bits1] * bitCountFreq[bits2];
            }
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + 20²)

O(n) to process all numbers and count bits, O(400) to check all bit count combinations

✓ Linear Growth

Space Complexity

O(n + 20)

O(n) for unique numbers set, O(20) for frequency map of bit counts

⚡ Linearithmic Space

28.5K Views

Medium-High Frequency

~25 min Avg. Time

847 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

Bit Count Frequency Map — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler