# Minimum count of balls in a bag

Posted: 10 Mar, 2021
Difficulty: Moderate

## PROBLEM STATEMENT

#### After performing the operations, let ‘X’ be the maximum number of balls in a bag. The task is to find the minimum possible value of ‘X’ and return it.

##### Example:
``````ARR = [5, 7], N = 2, M = 2

Perform the following two operations on ‘ARR’:
1. Divide the bag with 7 balls into 3 and 4. New ARR = [3, 4, 5].
2. Divide the bag with 5 balls into 1 and 4. New ARR = [1, 3, 4, 4].

The bag with the maximum number of balls has 4 balls. Hence, the minimum possible value of ‘X’ is 4. Return 4 as the answer.
``````
##### Note:
``````1. You can perform any number of operations between [0, M], both included.
``````
##### Input format:
``````The first line of input contains an integer ‘T’ which denotes the number of test cases. Then, the ‘T’ test cases follow.

The first line of each test case contains two space-separated integers, ‘N’ and ‘M’, denoting the size of array ‘ARR’ and the maximum number of operations.

The second line of each test case contains ‘N’ space-separated integers denoting the elements of array ‘ARR’.
``````
##### Output format:
``````For every test case, return the minimum possible value of ‘X’.
``````
##### Note:
``````You do not need to print anything; it has already been taken care of. Just implement the function.
``````
##### Constraints:
``````1 <= T <= 10
1 <= N, M <= 10^3
1 <= ARR[i] <= 10^6

Time limit: 1 sec
`````` Approach 1

Let 'X' be the maximum number of balls in a bag that we desire. Let ‘COUNT[i]’ be the number of operations that we need to perform on ‘ARR[i]’ such that the new bags made from it contain less than or equal to 'X' balls. Consider the following examples:

If we want 'X' to be ‘4’, then:

‘ARR[i] = 5’, after splitting we get [4, 1], so ‘COUNT[i] = 1’

‘ARR[i] = 8’, after splitting we get [4, 4] so ‘COUNT[i] = 1’

‘ARR[i] = 9’, after splitting we get [4, 5] => [4, 4, 1] so ‘COUNT[i] = 2’

‘ARR[i] = 12’, after splitting we get [4, 8] => [4, 4, 4] so ‘COUNT[i] = 2’

‘ARR[i] = 13’, after splitting we get [4, 9] => [4, 4, 5] => [4, 4, 4, 1] so ‘COUNT[i] = 3’

‘ARR[i] = 15’, after splitting we get [4, 11] => [4, 4, 7] => [4, 4, 4, 3] so ‘COUNT[i] = 3’

After observing we can see that: ‘COUNT[i] = (ARR[i] - 1)/x’. This is because if 'X' divides ‘ARR[i]’ then we don’t need to split the last bag, see the above two examples where ‘ARR[i] = 12’ and ‘ARR[i] = 13’ for more clarity.

Let ‘OPERATIONS’ be the number of operations we need to perform on ‘ARR’ to get the desired 'X', ‘OPERATIONS = summation(COUNT[i])’. Let ‘HIGH’ be the maximum number of balls in a bag. So, 'X' varies from 1 to ‘HIGH’. We now iterate through the values of 'X' until we find a value that has ‘OPERATIONS’ less than or equal to ‘m’. Following are the steps to obtain 'X':

• Initialize two integers ‘HIGH = the maximum number of balls in a bag’ and 'RESULT'. Use 'RESULT' to store the answer.
• Run a loop where 'X' ranges from 1 to ‘HIGH’:
• ‘OPERATIONS = 0’
• Run a loop where ‘i’ ranges from 0 to ‘N-1’:
• ‘OPERATIONS += (ARR[i] - 1)/X’
• If ‘OPERATIONS’ is less than equal to ‘M’, then:
• ‘RESULT = X’
• Break the loop.
• Return 'RESULT' as the answer.