Count the Number of Fair Pairs - Problem

Given a 0-indexed integer array nums of size n and two integers lower and upper, return the number of fair pairs.

A pair (i, j) is fair if:

0 <= i < j < n, and
lower <= nums[i] + nums[j] <= upper

Input & Output

Example 1 — Basic Case

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

› Output: 6

💡 Note: Valid pairs: (0,3)→4, (0,4)→4, (0,5)→5, (1,3)→5, (1,4)→5, (1,5)→6. All sums are between 3 and 6 inclusive.

Example 2 — No Valid Pairs

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

› Output: 1

💡 Note: Only one pair sums to 11: (2,3) where nums[2]=9 and nums[3]=2, giving 9+2=11.

Example 3 — All Pairs Valid

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

› Output: 3

💡 Note: All pairs are valid: (0,1)→3, (0,2)→4, (1,2)→5. Each sum is in range [3,5].

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i], lower, upper ≤ 10⁹
lower ≤ upper

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Meta 12

The key insight is to sort the array first, which enables efficient partner finding using binary search or two pointers. Instead of checking all O(n²) pairs, we can find valid partner ranges in O(log n) per element. Best approach is Sort + Binary Search with Time: O(n log n), Space: O(1).

Common Approaches

✓ Brute Force - Check All Pairs

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

Use nested loops to examine all pairs. For each i from 0 to n-2, check all j from i+1 to n-1. Count pairs where nums[i] + nums[j] is between lower and upper inclusive.

Sort + Binary Search

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

Sort the array while keeping track of original indices. For each element, use binary search to find the range of elements that can form valid pairs with it. This avoids checking all pairs explicitly.

Two Pointers Optimization

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

After sorting, for each element use two pointers to find the range of valid partners. The left pointer finds the first valid partner, and the right pointer finds the last valid partner. This avoids repeated binary searches.

Brute Force - Check All Pairs — Algorithm Steps

Iterate i from 0 to n-2
For each i, iterate j from i+1 to n-1
Check if lower ≤ nums[i] + nums[j] ≤ upper
Increment counter if condition is met

Visualization

Tap to expand

Step-by-Step Walkthrough

Check All Pairs

Examine every combination where i < j

Sum and Compare

Calculate nums[i] + nums[j] and check if it's in range

Count Valid Pairs

Increment counter for pairs within [lower, upper]

Code -

solution.c — C

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

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

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ']' && token[0] != '\n') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int lower, upper;
    scanf("%d", &lower);
    scanf("%d", &upper);
    
    int result = solution(nums, numsSize, lower, upper);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops check all n×(n-1)/2 pairs

⚡ Linearithmic

Space Complexity

O(1)

Only using counter variable and loop indices

✓ Linear Space

28.5K Views

Medium 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

Count the Number of Fair Pairs - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Pairs — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler