Sum of Floored Pairs - Practice Coding Problems

Sum of Floored Pairs - Problem

Given an integer array nums, you need to calculate the sum of all floored divisions between every pair of elements in the array.

More specifically, for every pair of indices i and j where 0 <= i, j < nums.length, compute floor(nums[i] / nums[j]) and sum all these values together.

The floor function returns the largest integer less than or equal to the division result. For example, floor(7/3) = 2 and floor(5/2) = 2.

Important: Since the result can be extremely large, return the answer modulo 10⁹ + 7.

Example: For array [2, 5, 9], we calculate: floor(2/2) + floor(2/5) + floor(2/9) + floor(5/2) + floor(5/5) + floor(5/9) + floor(9/2) + floor(9/5) + floor(9/9) = 1 + 0 + 0 + 2 + 1 + 0 + 4 + 1 + 1 = 10

Input & Output

example_1.py — Basic Case

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

› Output: 10

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

example_2.py — With Duplicates

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

› Output: 49

💡 Note: All 49 pairs (7×7) give floor(7/7) = 1, so the sum is 49 × 1 = 49

example_3.py — Edge Case

$ Input: nums = [1]

› Output: 1

💡 Note: Only one pair: floor(1/1) = 1

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
Return result modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Count Pizza Sizes

Instead of handling each pizza individually, count how many pizzas of each size we have

Calculate Serving Ratios

For each unique pizza size pair, calculate how many servings the larger makes from the smaller

Multiply by Quantities

Multiply the serving ratio by the count of both pizza sizes

Sum All Combinations

Add up all the serving calculations to get the total

Key Takeaway

🎯 Key Insight: By grouping identical values and using frequency multiplication, we transform an O(n²) problem into O(k²) where k is the number of unique elements, providing massive speedup for arrays with duplicates.

Asked in

G Google 28 a Amazon 22 f Meta 15 ⊞ Microsoft 12

The optimal approach uses frequency counting to group identical values and avoid redundant calculations. Instead of computing O(n²) individual divisions, we compute O(k²) where k is the number of unique values, then multiply by their frequencies. This dramatically improves performance when there are many duplicate values in the input array.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Calculate floor(nums[i]/nums[j]) for every pair (i,j) and sum the results
Frequency Count + Mathematical Optimization	O(n log n + k²)	O(n)	Use frequency counting and mathematical properties to avoid redundant calculations

Brute Force (Nested Loops) — Algorithm Steps

Initialize result sum to 0
Use outer loop for index i from 0 to n-1
Use inner loop for index j from 0 to n-1
Add floor(nums[i] / nums[j]) to result
Return result modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with result = 0, prepare to check all pairs

Outer Loop

For each element nums[i], we'll divide it by every element

Inner Loop

For current nums[i], divide by each nums[j] and add floor result

Accumulate

Sum up all floor(nums[i]/nums[j]) values

Code -

solution.c — C

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

int sumOfFlooredPairs(int* nums, int numsSize) {
    const int MOD = 1000000007;
    long long result = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = 0; j < numsSize; j++) {
            result = (result + nums[i] / nums[j]) % MOD;
        }
    }
    
    return (int) result;
}

int main() {
    int nums[1000];
    int count = 0;
    int num;
    
    while (scanf("%d", &num) == 1) {
        nums[count++] = num;
        if (getchar() == '\n') break;
    }
    
    printf("%d\n", sumOfFlooredPairs(nums, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We have nested loops, each running n times, giving us n × n operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a constant amount of extra space for variables

✓ Linear Space

67.2K Views

Medium-High Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler