Find the Smallest Divisor Given a Threshold

Find the Smallest Divisor Given a Threshold - Problem

Find the Smallest Divisor Given a Threshold

You're given an array of integers nums and an integer threshold. Your task is to find the smallest positive divisor such that when you divide each element in the array by this divisor and sum up all the results, the total is less than or equal to the threshold.

Here's the catch: each division result must be rounded up to the nearest integer (ceiling function). For example:
• 7 ÷ 3 = 2.33... rounds up to 3
• 10 ÷ 2 = 5.0 stays 5
• 1 ÷ 4 = 0.25 rounds up to 1

Goal: Find the minimum divisor that keeps the sum within the threshold limit. The problem guarantees a solution exists.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1, 2, 5, 9], threshold = 6

› Output: 5

💡 Note: With divisor 5: ceil(1/5) + ceil(2/5) + ceil(5/5) + ceil(9/5) = 1 + 1 + 1 + 2 = 5 ≤ 6. Smaller divisors like 4 give sum = 6, but we want the smallest, so 5 is correct.

example_2.py — Edge Case

$ Input: nums = [44, 22, 33, 11, 1], threshold = 5

› Output: 44

💡 Note: With divisor 44: ceil(44/44) + ceil(22/44) + ceil(33/44) + ceil(11/44) + ceil(1/44) = 1 + 1 + 1 + 1 + 1 = 5 ≤ 5. This is exactly at the threshold.

example_3.py — Small Array

$ Input: nums = [2, 3, 5, 7, 11], threshold = 11

› Output: 3

💡 Note: With divisor 3: ceil(2/3) + ceil(3/3) + ceil(5/3) + ceil(7/3) + ceil(11/3) = 1 + 1 + 2 + 3 + 4 = 11 ≤ 11. Perfect match at threshold.

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
1 ≤ nums[i] ≤ 10⁶
nums.length ≤ threshold ≤ 10⁶
Important: The test cases guarantee that a solution exists

Visualization

Tap to expand

Understanding the Visualization

Set up the delivery problem

Pizzas: [1, 2, 5, 9], Capacity limit: 6 deliveries

Try different bag configurations

Test various numbers of bags using binary search

Calculate delivery load

For each configuration, count total delivery portions needed

Find optimal solution

Minimum bags that keep total deliveries ≤ capacity

Key Takeaway

🎯 Key Insight: The problem has a monotonic property - if divisor X works, then X+1 also works. This makes binary search perfect for finding the minimum solution efficiently.

Asked in

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

The optimal solution uses binary search on the answer space. Since larger divisors always produce smaller sums (monotonic property), we can efficiently search for the minimum viable divisor in O(n log(max(nums))) time instead of the brute force O(n × max(nums)) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search (Optimal)	O(n × log(max(nums)))	O(1)	Use binary search on the answer space to efficiently find the minimum divisor
Brute Force (Linear Search)	O(n × max(nums))	O(1)	Try every divisor starting from 1 until we find one that works

Binary Search (Optimal) — Algorithm Steps

Set search bounds: left = 1, right = max(nums)
While left < right, calculate mid = (left + right) // 2
Calculate sum of ceiling divisions with mid as divisor
If sum ≤ threshold, search left half (right = mid)
If sum > threshold, search right half (left = mid + 1)
Return left when left == right

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize bounds

Set left=1, right=max(nums)

Test middle value

Calculate mid and sum with mid as divisor

Narrow search space

If sum ≤ threshold, search left; else search right

Code -

solution.c — C

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

int calculateSum(int* nums, int numsSize, int divisor) {
    int sum = 0;
    for (int i = 0; i < numsSize; i++) {
        sum += (nums[i] + divisor - 1) / divisor; // Ceiling division
    }
    return sum;
}

int smallestDivisor(int* nums, int numsSize, int threshold) {
    int left = 1;
    int right = nums[0];
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] > right) right = nums[i];
    }
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (calculateSum(nums, numsSize, mid) <= threshold) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return left;
}

int main() {
    int nums[] = {1, 2, 5, 9};
    int threshold = 6;
    printf("%d\n", smallestDivisor(nums, 4, threshold));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × log(max(nums)))

Binary search runs in O(log(max(nums))) iterations, and each iteration processes all n elements to calculate the sum

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for binary search variables

✓ Linear Space

125.0K Views

Medium-High Frequency

~15 min Avg. Time

2.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

Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler