Count Pairs Whose Sum is Less than Target

Count Pairs Whose Sum is Less than Target - Problem

You are given a 0-indexed integer array nums of length n and an integer target. Your task is to count all valid pairs of indices where the sum of their corresponding values is strictly less than the target.

A valid pair (i, j) must satisfy:

0 ≤ i < j < n (i comes before j)
nums[i] + nums[j] < target (sum is strictly less than target)

Return the total number of such pairs.

Example: If nums = [1, 3, 2, 4] and target = 5, the pairs (0,1), (0,2), and (2,1) have sums 4, 3, and 5 respectively. Only the first two are valid since they're less than 5.

Input & Output

example_1.py — Basic Case

$ Input: nums = [-1,1,2,3,1], target = 2

› Output: 3

💡 Note: The valid pairs are: (-1,1) with sum 0, (-1,1) with sum 0 (second occurrence), and (-1,2) with sum 1. Note that we count index pairs, so (0,1), (0,4), and (0,2) are the three valid pairs.

example_2.py — No Valid Pairs

$ Input: nums = [-6,2,5,-2,-7,-1,3], target = -2

› Output: 10

💡 Note: Multiple pairs have sums less than -2. After systematic checking: (-6,-7), (-6,-2), (-6,-1), (-7,2), (-7,5), (-7,-2), (-7,-1), (-7,3), (-2,-1), and others form valid combinations.

example_3.py — Edge Case

$ Input: nums = [1,1], target = 3

› Output: 1

💡 Note: Only one pair (0,1) exists with sum 1+1=2, which is less than target 3, so the answer is 1.

Constraints

1 ≤ nums.length ≤ 50
-50 ≤ nums[i], target ≤ 50
Array contains at least 2 elements

Visualization

Tap to expand

Understanding the Visualization

Sort by Skill

Arrange all players from weakest to strongest skill level

Two Coach Strategy

Position one coach at weakest player, another at strongest

Smart Counting

When sum is valid, count all possible teams the weakest player can form

Efficient Movement

Move coaches strategically to avoid rechecking combinations

Key Takeaway

🎯 Key Insight: Sorting enables us to count multiple valid pairs at once rather than checking each pair individually, dramatically improving efficiency from O(n²) to O(n log n).

Asked in

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

The optimal solution uses the two-pointers technique after sorting the array. The key insight is that once we sort, if nums[left] + nums[right] < target, then nums[left] can pair with all elements from left+1 to right, giving us (right - left) pairs at once. This achieves O(n log n) time complexity, significantly better than the brute force O(n²) approach.

Common Approaches

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

Sorting + Binary Search — Algorithm Steps

Sort the array in ascending order
Initialize count to 0
For each index i from 0 to n-2:
Calculate complement = target - nums[i] - 1 (we want sum < target)
Use binary search to find the rightmost position where nums[j] ≤ complement and j > i
Add the number of valid indices to count
Return the count

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort the array to enable binary search

For Each Element

For each position i, find rightmost valid j using binary search

Count Pairs

Add (j - i) pairs to the total count

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int binarySearchRight(int* arr, int left, int right, int val) {
    int result = left - 1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (arr[mid] <= val) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return result;
}

int countPairs(int* nums, int numsSize, int target) {
    qsort(nums, numsSize, sizeof(int), compare);
    int count = 0;
    
    for (int i = 0; i < numsSize - 1; i++) {
        int complement = target - nums[i] - 1;  // We want sum < target
        int j = binarySearchRight(nums, i + 1, numsSize - 1, complement);
        if (j > i) {
            count += j - i;
        }
    }
    
    return count;
}

int main() {
    int nums[] = {-1, 1, 2, 3, 1};
    int target = 2;
    printf("%d\n", countPairs(nums, 5, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), and we perform binary search O(log n) for each of n elements, giving O(n log n) overall

⚡ Linearithmic

Space Complexity

O(1)

Only constant extra space needed for variables (assuming in-place sorting)

✓ Linear Space

28.4K Views

Medium Frequency

~12 min Avg. Time

892 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

Sorting + Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler