Number of Pairs Satisfying Inequality - Practice Coding Problems

Number of Pairs Satisfying Inequality - Problem

Array Binary Search Divide and Conquer Binary Indexed Tree Segment Tree Merge Sort Ordered Set Hard

Count Valid Pairs with Mathematical Constraint

You are given two integer arrays nums1 and nums2, each of size n, and an integer diff. Your task is to find how many pairs of indices (i, j) satisfy a specific mathematical relationship.

A pair (i, j) is considered valid if:
• 0 ≤ i < j ≤ n - 1 (i must come before j)
• nums1[i] - nums1[j] ≤ nums2[i] - nums2[j] + diff

The challenge lies in efficiently counting these pairs without checking every possible combination, as that would be too slow for large arrays.

Example: If nums1 = [3,2,5], nums2 = [2,5,1], and diff = 2, we need to check pairs (0,1), (0,2), and (1,2) against our inequality constraint.

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [3,2,5], nums2 = [2,5,1], diff = 2

› Output: 2

💡 Note: We check pairs (0,1), (0,2), and (1,2). For (0,2): 3-5 ≤ 2-1+2 → -2 ≤ 3 ✓. For (1,2): 2-5 ≤ 5-1+2 → -3 ≤ 6 ✓. Two pairs satisfy the condition.

example_2.py — All Valid

$ Input: nums1 = [3,2,5], nums2 = [2,2,2], diff = 1

› Output: 3

💡 Note: With nums2 constant, the inequality becomes nums1[i] - nums1[j] ≤ 1. All three pairs (0,1), (0,2), and (1,2) satisfy this condition since differences are small.

example_3.py — Edge Case

$ Input: nums1 = [3,2], nums2 = [1,1], diff = -1

› Output: 0

💡 Note: Only one pair (0,1) to check: 3-2 ≤ 1-1+(-1) → 1 ≤ -1, which is false. With negative diff, the constraint becomes very strict.

Constraints

n == nums1.length == nums2.length
1 ≤ n ≤ 10⁵
-10⁴ ≤ nums1[i], nums2[i] ≤ 10⁴
-10⁴ ≤ diff ≤ 10⁴
Time limit: 2 seconds for all test cases

Visualization

Tap to expand

Understanding the Visualization

Original Problem

Count pairs (i,j) where nums1[i] - nums1[j] ≤ nums2[i] - nums2[j] + diff

Rearrange Terms

Move nums2 terms: nums1[i] - nums2[i] ≤ nums1[j] - nums2[j] + diff

Transform Arrays

Create arr[i] = nums1[i] - nums2[i] for all indices

Simplified Problem

Count pairs where arr[i] ≤ arr[j] + diff with i < j

Key Takeaway

🎯 Key Insight: Mathematical transformation reduces a complex 2-array problem to a simpler 1-array inversion counting problem!

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a mathematical transformation to convert the inequality nums1[i] - nums1[j] ≤ nums2[i] - nums2[j] + diff into a simpler form by creating an array arr[i] = nums1[i] - nums2[i]. This transforms the problem into counting pairs where arr[i] ≤ arr[j] + diff with i < j. Using merge sort with inversion counting, we can solve this in O(n log n) time, which is optimal for this problem compared to the O(n²) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Transform + Merge Sort (Optimal)	O(n log n)	O(n)	Transform the inequality to create a single difference array, then use merge sort to count inversions efficiently
Brute Force (Nested Loops)	O(n²)	O(1)	Check all possible pairs (i,j) where i < j and evaluate the inequality condition

Transform + Merge Sort (Optimal) — Algorithm Steps

Transform the problem by creating arr[i] = nums1[i] - nums2[i] for all i
The condition becomes: count pairs (i,j) where i < j and arr[i] ≤ arr[j] + diff
Use merge sort with modification to count valid pairs during the merge step
During merging, for each element in the left half, count how many elements in the right half satisfy the condition
Return the total count from all merge operations

Visualization

Tap to expand

Step-by-Step Walkthrough

Transform

Create arr = [1, -3, 4] from nums1[i] - nums2[i]

Divide

Split array into smaller subarrays recursively

Count

During merge, count pairs where left[i] ≤ right[j] + diff

Merge

Combine sorted subarrays while maintaining order

Code -

solution.c — C

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

long long mergeSort(long long* arr, long long* temp, int left, int right, int diff) {
    if (left >= right) return 0;
    
    int mid = left + (right - left) / 2;
    long long count = 0;
    count += mergeSort(arr, temp, left, mid, diff);
    count += mergeSort(arr, temp, mid + 1, right, diff);
    
    // Count pairs during merge
    int i = left, j = mid + 1;
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j] + diff) {
            count += right - j + 1;
            i++;
        } else {
            j++;
        }
    }
    
    // Actual merge
    i = left; j = mid + 1; int k = left;
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }
    
    while (i <= mid) temp[k++] = arr[i++];
    while (j <= right) temp[k++] = arr[j++];
    
    for (int idx = left; idx <= right; idx++) {
        arr[idx] = temp[idx];
    }
    
    return count;
}

long long numberOfPairs(int* nums1, int* nums2, int numsSize, int diff) {
    long long* arr = (long long*)malloc(numsSize * sizeof(long long));
    long long* temp = (long long*)malloc(numsSize * sizeof(long long));
    
    for (int i = 0; i < numsSize; i++) {
        arr[i] = nums1[i] - nums2[i];
    }
    
    long long result = mergeSort(arr, temp, 0, numsSize - 1, diff);
    
    free(arr);
    free(temp);
    return result;
}

int main() {
    int nums1[] = {3, 2, 5};
    int nums2[] = {2, 5, 1};
    int diff = 2;
    printf("%lld\n", numberOfPairs(nums1, nums2, 3, diff));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Merge sort has O(n log n) complexity, and we count pairs during each merge operation without additional overhead

⚡ Linearithmic

Space Complexity

O(n)

Need additional space for the transformed array and temporary arrays during merge sort

⚡ Linearithmic Space

31.5K Views

Medium-High Frequency

~25 min Avg. Time

890 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

Transform + Merge Sort (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler