Sum of Floored Pairs

Sum of Floored Pairs - Problem

Given an integer array nums, return the sum of floor(nums[i] / nums[j]) for all pairs of indices 0 <= i, j < nums.length in the array.

Since the answer may be too large, return it modulo 10^9 + 7.

The floor() function returns the integer part of the division.

Input & Output

Example 1 — Basic Case

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

› Output: 12

💡 Note: All pairs: floor(2/2)=1, floor(2/5)=0, floor(2/1)=2, floor(5/2)=2, floor(5/5)=1, floor(5/1)=5, floor(1/2)=0, floor(1/5)=0, floor(1/1)=1. Sum = 1+0+2+2+1+5+0+0+1 = 12

Example 2 — Small Array

$ Input: nums = [7,7,7,7,7,7,7]

› Output: 49

💡 Note: All elements are 7, so floor(7/7)=1 for all 49 pairs (7×7), giving sum = 49

Example 3 — Edge Case

$ Input: nums = [1,1]

› Output: 2

💡 Note: Two pairs: floor(1/1)=1, floor(1/1)=1. Sum = 1+1 = 2

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to avoid computing every individual pair by using frequency counting or binary search optimization. The brute force O(n²) approach works but can be optimized using frequency maps for arrays with duplicates or binary search for sorted ranges. Best approach depends on data characteristics: frequency counting for many duplicates, binary search for unique values. Time: O(n²) to O(n² log n), Space: O(1) to O(n)

Common Approaches

✓ Binary Search with Sorted Array

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

Sort the array first, then for each numerator, use binary search to find ranges of denominators that give the same quotient value. This reduces the number of operations significantly.

Brute Force - Check All Pairs

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

For each element at position i, divide it by every element at position j (including itself) and sum all the floor division results. This directly implements the problem definition.

Frequency Count Optimization

⏱️ Time: O(k²) Space: O(k)

Instead of checking every pair individually, count how many times each number appears, then for each unique value calculate how many times it contributes to each quotient result.

Binary Search with Sorted Array — Algorithm Steps

Sort the array
For each numerator value
Use binary search to find quotient ranges
Calculate contribution of each range

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort

Sort array to enable binary search

Range

Find ranges of denominators with same quotient

Count

Multiply quotient by range size

Code -

solution.c — C

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

static int nums[100000];

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

int lowerBound(int* arr, int size, int target, int start) {
    int left = start, right = size;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

int upperBound(int* arr, int size, int target, int start) {
    int left = start, right = size;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] <= target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

int solution(int* nums, int numsSize) {
    const int MOD = 1000000007;
    qsort(nums, numsSize, sizeof(int), compare);
    long long total = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int numerator = nums[i];
        int j = 0;
        
        while (j < numsSize) {
            int quotient = numerator / nums[j];
            if (quotient == 0) {
                break;
            }
            
            int minDenom = numerator / (quotient + 1) + 1;
            int maxDenom = numerator / quotient;
            
            int right = upperBound(nums, numsSize, maxDenom, j);
            int left = lowerBound(nums, numsSize, minDenom, j);
            
            if (left < right) {
                int count = right - left;
                total = (total + (long long) quotient * count) % MOD;
                j = right;
            } else {
                j++;
            }
        }
    }
    
    return total;
}

int main() {
    char line[200000];
    fgets(line, sizeof(line), stdin);
    
    int count = 0;
    char* p = line;
    
    // Skip '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        long val = strtol(p, &p, 10);
        nums[count++] = (int)val;
    }
    
    int result = solution(nums, count);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

Sorting takes O(n log n), then for each of n elements we do O(n log n) binary searches

✓ Linear Growth

Space Complexity

O(1)

Only uses a few variables if sorting in place

✓ Linear Space

23.5K Views

Medium Frequency

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

Binary Search with Sorted Array — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler