Count the Number of Fair Pairs - Practice Coding Problems

Count the Number of Fair Pairs - Problem

🎯 Count the Number of Fair Pairs

Imagine you're organizing a team-building activity where participants need to be paired up based on their combined skill levels. You have an array of skill ratings and need to find pairs that fall within an acceptable range!

Given a 0-indexed integer array nums of size n and two integers lower and upper, your task is to count how many "fair pairs" exist in the array.

A pair (i, j) is considered fair if:

0 <= i < j < n (different indices, order matters)
lower <= nums[i] + nums[j] <= upper (sum within acceptable range)

Example: If nums = [0,1,7,4,4,5], lower = 3, upper = 6
Valid pairs: (1,3), (1,4), (1,5), (2,3), (3,4), (4,5)
Answer: 6 fair pairs

Input & Output

example_1.py — Basic Case

$ Input: nums = [0,1,7,4,4,5], lower = 3, upper = 6

› Output: 6

💡 Note: Valid pairs: (0,3): 0+4=4 ✓, (0,4): 0+4=4 ✓, (0,5): 0+5=5 ✓, (1,3): 1+4=5 ✓, (1,4): 1+4=5 ✓, (1,5): 1+5=6 ✓. Total: 6 pairs

example_2.py — Edge Case

$ Input: nums = [1,7,9,2,5], lower = 11, upper = 11

› Output: 1

💡 Note: Only one pair sums to exactly 11: (2,4) where nums[2]=9 and nums[4]=5, so 9+5=11. All other pairs sum to different values.

example_3.py — No Valid Pairs

$ Input: nums = [1,2,3], lower = 10, upper = 15

› Output: 0

💡 Note: Maximum possible sum is 2+3=5, which is less than lower=10. No pairs can satisfy the condition lower ≤ sum ≤ upper.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i], lower, upper ≤ 10⁹
lower ≤ upper (guaranteed valid range)

Visualization

Tap to expand

Understanding the Visualization

Sort for Efficiency

Line up all elements in order to enable binary search - like organizing a speed dating event by age

Calculate Valid Range

For each element, determine what values its partner needs to have for their sum to be 'fair'

Binary Search Bounds

Quickly find the leftmost and rightmost valid partners using binary search

Count the Range

Count all valid partners in one operation instead of checking each individually

Key Takeaway

🎯 Key Insight: Sorting enables us to use binary search for range counting, transforming an O(n²) pair-checking problem into an O(n log n) range-finding solution!

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 31 Apple 22

The optimal approach uses sorting + binary search to achieve O(n log n) time complexity. After sorting the array, for each element we calculate the valid range for its complement and use binary search to count elements in that range efficiently, avoiding the O(n²) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible pair (i,j) where i < j and count those with sum in range
Two Pointers (Optimal)	O(n log n)	O(1)	Sort array and use two pointers to efficiently count pairs in valid range
Sorting + Binary Search	O(n log n)	O(1)	Sort array, then for each element use binary search to find valid complement range

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each element at index i
For each i, iterate through elements at indices j > i
Check if nums[i] + nums[j] is within [lower, upper]
Increment counter if condition is met
Return the final count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Begin with element at index 0, check against all following elements

Check each pair

For each pair (i,j), calculate sum and check if it's in valid range

Move to next element

Increment i and repeat the process

Count valid pairs

Accumulate count of pairs that meet the criteria

Code -

solution.c — C

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

long long countFairPairs(int* nums, int numsSize, int lower, int upper) {
    long long count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            long long pairSum = (long long)nums[i] + nums[j];
            if (pairSum >= lower && pairSum <= upper) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    printf("Input parsing implementation needed\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops, each potentially running n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting

✓ Linear Space

42.7K Views

Medium-High Frequency

~18 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

🎯 Count the Number of Fair Pairs

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler