Given two integers N and K. Create an array of N positive integers such the sum of all elements of the array is divisible by K and therefore the maximum element within the array is that the minimum possible.

You have to seek out the utmost element of that array.

Example:

 Input : N=5, K=11

Output : 3



Explanation : We can create the array as [2, 2, 2, 2, 3]. The sum of the array is 11 which is divisible by K=11 and the maximum element is 3 which is minimum possible in this case.

Input : N=4, K=3

Output : 2

Explanation : We can create the array as [1, 2, 1, 2]. The sum of the array is 6 which is divisible by K=3 and the maximum element is 2 which is minimum possible in this case.

Approach : Since we have to take all N positive numbers, the minimum value we can assume is 1. The number of arrays is initially N * 1 = N.

Now, there exist two possible cases –

1. If K is bigger than or equal N: If we make the sum of the array is adequate to K, then we will observe the utmost element also will be minimized. So, now we've to make an array consisting of N positive integers whose Sum is K. we will distribute K/N to all or any the N places. If the sum of the array remains not adequate to K then, we'll increment one element by K-(N*(K/N)). Thus, we will find the minimum possible maximum element. And, we are distributing K/N values to every place in order that any element doesn't become so big.
2. If K is a smaller amount than N: Since the initial sum is N, so we've increment our Sum such Sum is divisible by K and therefore the Sum is that the minimum possible. The Sum has got to be minimum because we've to attenuate our maximum element too. Let’s say the optimal Sum is S. So, S has got to divisible by K and S are going to be greater than or adequate to N. Now, this has become an equivalent because the 1st case.
   Let, in both cases, the Optimal sum is S. So, giving the floo
    
3. In both cases the optimal sum is S. So if you assign the minimum value of S/N to elements N-1 and the maximum value of Sum/K to the remaining elements, the sum becomes equal to S and is also divisible by .

Now, Between the floor value of sum/N and the ceiling value of sum/N, ceil value will be greater. Finally, the maximum element will the ceil value of sum/N. 

Below is the implementation of the above approach :

// Java Program to Minimize the maximum element of an array

import java.io.*;
import java.lang.*;
import java.util.*;
public class Main {
	public static void main(String[] args)
	{
		// Given
		int N = 5;
		int K = 11;

		System.out.println("N is " +N);
		System.out.println("K is " +K);
	
		// variable sum stores the optimal Sum
		int sum = 0;

		// the first case
		if (K >= N) {
		
			// the optimal sum will be K
			// as we have to keep the sum as minimum as
			// possible and the sum has to divisible by K
			sum = K;
		}

		// the second case
		else {
		
			// we have to increment sum as
			// the sum is divisible by K
			// and sum is greater than or equal to N

			// the ceiling value of N/K will give the
			// minimum value that has to be multiplied by K
			// to get the optimal sum
			int times = (int)Math.ceil((double)N / (double)K);
		
			sum = times * K;
		}

		// maximum_element will the ceil value of sum/N
		int maximum_element
			= (int)Math.ceil((double)sum / (double)N);

		// print the maximum_element as answer
		System.out.println("Maximum element is " +maximum_element);
	}
}

Output

N is 5
K is 11
Maximum element is 3

Time Complexity: O(1)

Auxiliary Space: O(1)