Find the Smallest Divisor Given a Threshold

Find the Smallest Divisor Given a Threshold - Problem

Given an array of integers nums and an integer threshold, we will choose a positive integer divisor, divide all the array elements by it, and sum the division's result.

Find the smallest divisor such that the result mentioned above is less than or equal to threshold.

Each result of the division is rounded to the nearest integer greater than or equal to that element (ceiling function). For example: 7/3 = 3 and 10/2 = 5.

The test cases are generated so that there will be an answer.

Input & Output

Example 1 — 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 give larger sums, so 5 is the answer.

Example 2 — Larger Threshold

$ 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

Example 3 — 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

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
1 ≤ nums[i] ≤ 10⁶
nums.length ≤ threshold ≤ 10⁶

Visualization

Tap to expand

Asked in

a Amazon 15 f Facebook 12 G Google 8

The key insight is that as the divisor increases, the sum of ceiling divisions decreases monotonically. This allows us to use binary search on the answer space from 1 to max(nums). For each candidate divisor, we calculate the sum of ceil(nums[i]/divisor) and check if it's ≤ threshold. Best approach is binary search with Time: O(n × log(max(nums))), Space: O(1).

Common Approaches

✓ Dfs

⏱️ Time: N/A Space: N/A

Binary Search on Answer Space

⏱️ Time: O(n × log(max(nums))) Space: O(1)

Since larger divisors produce smaller sums, we can binary search on the divisor value. Search between 1 and max(nums) to find the smallest divisor that satisfies the threshold condition.

Brute Force Linear Search

⏱️ Time: O(n × max(nums)) Space: O(1)

Start with divisor = 1 and incrementally test each divisor. For each divisor, calculate the sum of ceiling divisions and check if it's within the threshold.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int parseArray(char* str, int* nums) {
    int count = 0;
    int i = 0;
    int len = strlen(str);
    
    while (i < len) {
        if (str[i] >= '0' && str[i] <= '9') {
            int num = 0;
            while (i < len && str[i] >= '0' && str[i] <= '9') {
                num = num * 10 + (str[i] - '0');
                i++;
            }
            nums[count++] = num;
        } else {
            i++;
        }
    }
    return count;
}

int ceiling_divide(int a, int b) {
    return (a + b - 1) / b;
}

int calculateSum(int* nums, int size, int divisor) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += ceiling_divide(nums[i], divisor);
    }
    return sum;
}

int smallestDivisor(int* nums, int size, int threshold) {
    int left = 1;
    int right = 0;
    
    // Find the maximum element to set the right boundary
    for (int i = 0; i < size; i++) {
        if (nums[i] > right) {
            right = nums[i];
        }
    }
    
    int result = right;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        int sum = calculateSum(nums, size, mid);
        
        if (sum <= threshold) {
            result = mid;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    return result;
}

int main() {
    char line[1000];
    int nums[100000];
    int threshold;
    
    // Read the array line
    fgets(line, sizeof(line), stdin);
    int size = parseArray(line, nums);
    
    // Read the threshold
    scanf("%d", &threshold);
    
    int result = smallestDivisor(nums, size, threshold);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear Space

87.4K Views

Medium Frequency

~25 min Avg. Time

2.2K 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