## 1283. Find the Smallest Divisor Given a Threshold

Given an array of integers `nums` and an integer `threshold`, we will choose a positive integer `divisor`, divide all the array 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. (For example: `7/3 = 3` and `10/2 = 5`).

It is guaranteed that there will be an answer.

Example 1:

```Input: nums = [1,2,5,9], threshold = 6
Output: 5
Explanation: We can get a sum to 17 (1+2+5+9) if the divisor is 1.
If the divisor is 4 we can get a sum of 7 (1+1+2+3) and if the divisor is 5 the sum will be 5 (1+1+1+2).
```

Example 2:

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

Example 3:

```Input: nums = [21212,10101,12121], threshold = 1000000
Output: 1
```

Example 4:

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

Constraints:

• `1 <= nums.length <= 5 * 104`
• `1 <= nums[i] <= 106`
• `nums.length <= threshold <= 106`

## Rust Solution

``````struct Solution;

impl Solution {
fn smallest_divisor(nums: Vec<i32>, threshold: i32) -> i32 {
let mut l = 1;
let mut r = 1_000_000;
while l < r {
let m = l + (r - l) / 2;
let mut sum = 0;
for &x in &nums {
if x % m == 0 {
sum += x / m;
} else {
sum += x / m + 1;
}
}
if sum > threshold {
l = m + 1;
} else {
r = m;
}
}
l
}
}

#[test]
fn test() {
let nums = vec![1, 2, 5, 9];
let threshold = 6;
let res = 5;
assert_eq!(Solution::smallest_divisor(nums, threshold), res);
let nums = vec![2, 3, 5, 7, 11];
let threshold = 11;
let res = 3;
assert_eq!(Solution::smallest_divisor(nums, threshold), res);
let nums = vec!;
let threshold = 5;
let res = 4;
assert_eq!(Solution::smallest_divisor(nums, threshold), res);
}
``````

Having problems with this solution? Click here to submit an issue on github.