Open In App

Minimum K such that sum of array elements after division by K does not exceed S

Improve
Improve
Like Article
Like
Save
Share
Report

Given an array arr[] of N elements and an integer S. The task is to find the minimum number K such that the sum of the array elements does not exceed S after dividing all the elements by K
Note: Consider integer division.
Examples: 

Input: arr[] = {10, 7, 8, 10, 12, 19}, S = 27 
Output:
After dividing by 3, the array becomes 
{3, 2, 2, 3, 4, 6} and the new sum is 20.
Input: arr[] = {19, 17, 11, 10}, S = 40 
Output:

Naive approach: Iterate for all values of K from 1 to the maximum element in the array plus one not maximum element because if we put k as maximum element then the sum will be one and what if the S is given to us as zero. So we iterate from k=1 to max element in the array plus one. and then sum up the array elements by dividing with K, if the sum does not exceed S then the current value will be the answer. The time complexity of this approach will be O(M * N) where M is the maximum element in the array.

C++




#include <iostream>
#include <numeric> // Required for std::accumulate
 
// Define the FindK function to find the minimum value of K
int FindK(int arr[], int n, int S)
{
    // Initialize K to 1
    int K = 1;
 
    // Enter into a loop to find the minimum value of K
    while (true)
    {
        // Calculate the sum of the array after dividing each element by K
        int sumArr = std::accumulate(arr, arr+n, 0, [=](int a, int b) { return a + b/K; });
 
        // If the resulting sum is less than or equal to S, return K as the answer
        if (sumArr <= S)
        {
            return K;
        }
 
        // Otherwise, increment the value of K and repeat the loop
        K++;
    }
}
 
int main()
{
    // Define the input array and integer
    int arr[] = {10, 7, 8, 10, 12, 19};
    int n = sizeof(arr)/sizeof(arr[0]); // Find the size of the array
    int S = 27;
 
    // Call the FindK function with the input array and integer, and print the result
    std::cout << FindK(arr, n, S) << std::endl; // Output: 3
 
    return 0;
}


Java




import java.util.*;
 
public class Main {
 
    public static int FindK(int arr[], int n, int S) {
        int K = 1;
        while (true) {
          // declare a final variable k and assign the value of K to it
            final int k = K;
            int sumArr = Arrays.stream(arr).reduce(
                    0,
              // use the final variable k in the lambda expression
                    (a, b) -> a + b/k);
            if (sumArr <= S) {
                return K;
            }
            K++;
        }
    }
 
    public static void main(String[] args) {
        int arr[] = {10, 7, 8, 10, 12, 19};
        int n = arr.length;
        int S = 27;
 
        System.out.println(FindK(arr, n, S)); // Output: 3
    }
}


Python3




# Define the input array and integer
arr = [10, 7, 8, 10, 12, 19]
S = 27
 
# Define a function to find the minimum value of K
def find_k(arr, S):
    # Initialize K to 1
    K = 1
    # Enter into a loop to find the minimum value of K
    while True:
        # Calculate the sum of the array after dividing each element by K
        sum_arr = sum([i//K for i in arr])
        # If the resulting sum is less than or equal to S, return K as the answer
        if sum_arr <= S:
            return K
        # Otherwise, increment the value of K and repeat the loop
        K += 1
 
# Call the find_k function with the input array and integer, and print the result
print(find_k(arr, S))  # Output: 3


Javascript




// Define the input array and integer
const arr = [10, 7, 8, 10, 12, 19];
const S = 27;
 
// Define a function to find the minimum value of K
function find_k(arr, S) {
  // Initialize K to 1
  let K = 1;
  // Enter into a loop to find the minimum value of K
  while (true) {
    // Calculate the sum of the array after dividing each element by K
    let sum_arr = arr.reduce((acc, curr) => acc + Math.floor(curr / K), 0);
    // If the resulting sum is less than or equal to S, return K as the answer
    if (sum_arr <= S) {
      return K;
    }
    // Otherwise, increment the value of K and repeat the loop
    K++;
  }
}
 
// Call the find_k function with the input array and integer, and print the result
console.log(find_k(arr, S)); // Output: 3


C#




using System;
using System.Linq;
 
public class MinimumKValue
{
  public static void Main()
  {
    // Define the input array and integer
    int[] arr = {10, 7, 8, 10, 12, 19};
    int S = 27;
 
    // Call the FindK function with the input array and integer, and print the result
    Console.WriteLine(FindK(arr, S)); // Output: 3
  }
 
  // Define a function to find the minimum value of K
  public static int FindK(int[] arr, int S)
  {
    // Initialize K to 1
    int K = 1;
 
    // Enter into a loop to find the minimum value of K
    while (true)
    {
 
      // Calculate the sum of the array after dividing each element by K
      int sumArr = arr.Sum(i => i / K);
 
      // If the resulting sum is less than or equal to S, return K as the answer
      if (sumArr <= S)
      {
        return K;
      }
 
      // Otherwise, increment the value of K and repeat the loop
      K++;
    }
  }
}


Output

3

Efficient approach: An efficient approach is to find the value of K by performing a binary search on the answer. Initiate a binary search on the value of K and a check is done inside it to see if the sum exceeds K then the binary search is performed on the second half or the first half accordingly.
Below is the implementation of the above approach:  

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the minimum value of k
// that satisfies the given condition
int findMinimumK(int a[], int n, int s)
{
    // Find the maximum element
    int maximum = a[0];
    for (int i = 0; i < n; i++) {
        maximum = max(maximum, a[i]);
    }
 
    // Lowest answer can be 1 and the
    // highest answer can be (maximum + 1)
    int low = 1, high = maximum + 1;
 
    int ans = high;
 
    // Binary search
    while (low <= high) {
 
        // Get the mid element
        int mid = (low + high) / 2;
        int sum = 0;
 
        // Calculate the sum after dividing
        // the array by new K which is mid
        for (int i = 0; i < n; i++) {
            sum += (int)(a[i] / mid);
        }
 
        // Search in the second half
        if (sum > s)
            low = mid + 1;
 
        // First half
        else {
            ans = min(ans, mid);
            high = mid - 1;
        }
    }
 
    return ans;
}
 
// Driver code
int main()
{
    int a[] = { 10, 7, 8, 10, 12, 19 };
    int n = sizeof(a) / sizeof(a[0]);
    int s = 27;
 
    cout << findMinimumK(a, n, s);
 
    return 0;
}


Java




// Java implementation of the approach
class GFG
{
     
    // Function to return the minimum value of k
    // that satisfies the given condition
    static int findMinimumK(int a[],
                            int n, int s)
    {
        // Find the maximum element
        int maximum = a[0];
         
        for (int i = 0; i < n; i++)
        {
            maximum = Math.max(maximum, a[i]);
        }
     
        // Lowest answer can be 1 and the
        // highest answer can be (maximum + 1)
        int low = 1, high = maximum + 1;
     
        int ans = high;
     
        // Binary search
        while (low <= high)
        {
     
            // Get the mid element
            int mid = (low + high) / 2;
            int sum = 0;
     
            // Calculate the sum after dividing
            // the array by new K which is mid
            for (int i = 0; i < n; i++)
            {
                sum += (int)(a[i] / mid);
            }
     
            // Search in the second half
            if (sum > s)
                low = mid + 1;
     
            // First half
            else
            {
                ans = Math.min(ans, mid);
                high = mid - 1;
            }
        }
        return ans;
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int a[] = { 10, 7, 8, 10, 12, 19 };
        int n = a.length;
        int s = 27;
     
        System.out.println(findMinimumK(a, n, s));
    }
}   
 
// This code is contributed by AnkitRai01


Python3




# Python3 implementation of the approach
 
# Function to return the minimum value of k
# that satisfies the given condition
def findMinimumK(a, n, s):
     
    # Find the maximum element
    maximum = a[0]
    for i in range(n):
        maximum = max(maximum, a[i])
 
    # Lowest answer can be 1 and the
    # highest answer can be (maximum + 1)
    low = 1
    high = maximum + 1
 
    ans = high
 
    # Binary search
    while (low <= high):
 
        # Get the mid element
        mid = (low + high) // 2
        sum = 0
 
        # Calculate the sum after dividing
        # the array by new K which is mid
        for i in range(n):
            sum += (a[i] // mid)
 
        # Search in the second half
        if (sum > s):
            low = mid + 1
 
        # First half
        else:
            ans = min(ans, mid)
            high = mid - 1
 
    return ans
 
# Driver code
a = [10, 7, 8, 10, 12, 19]
n = len(a)
s = 27
 
print(findMinimumK(a, n, s))
 
# This code is contributed by Mohit Kumar


Javascript




<script>
// javascript implementation of the approach    
// Function to return the minimum value of k
    // that satisfies the given condition
    function findMinimumK(a , n , s) {
        // Find the maximum element
        var maximum = a[0];
 
        for (i = 0; i < n; i++) {
            maximum = Math.max(maximum, a[i]);
        }
 
        // Lowest answer can be 1 and the
        // highest answer can be (maximum + 1)
        var low = 1, high = maximum + 1;
 
        var ans = high;
 
        // Binary search
        while (low <= high) {
 
            // Get the mid element
            var mid = parseInt((low + high) / 2);
            var sum = 0;
 
            // Calculate the sum after dividing
            // the array by new K which is mid
            for (i = 0; i < n; i++) {
                sum += parseInt( (a[i] / mid));
            }
 
            // Search in the second half
            if (sum > s)
                low = mid + 1;
 
            // First half
            else {
                ans = Math.min(ans, mid);
                high = mid - 1;
            }
        }
        return ans;
    }
 
    // Driver code
     
        var a = [ 10, 7, 8, 10, 12, 19 ];
        var n = a.length;
        var s = 27;
 
        document.write(findMinimumK(a, n, s));
 
// This code is contributed by todaysgaurav
</script>


C#




// C# implementation of the approach
using System;
 
class GFG
{
     
    // Function to return the minimum value of k
    // that satisfies the given condition
    static int findMinimumK(int []a,
                            int n, int s)
    {
        // Find the maximum element
        int maximum = a[0];
         
        for (int i = 0; i < n; i++)
        {
            maximum = Math.Max(maximum, a[i]);
        }
     
        // Lowest answer can be 1 and the
        // highest answer can be (maximum + 1)
        int low = 1, high = maximum + 1;
     
        int ans = high;
     
        // Binary search
        while (low <= high)
        {
     
            // Get the mid element
            int mid = (low + high) / 2;
            int sum = 0;
     
            // Calculate the sum after dividing
            // the array by new K which is mid
            for (int i = 0; i < n; i++)
            {
                sum += (int)(a[i] / mid);
            }
     
            // Search in the second half
            if (sum > s)
                low = mid + 1;
     
            // First half
            else
            {
                ans = Math.Min(ans, mid);
                high = mid - 1;
            }
        }
        return ans;
    }
     
    // Driver code
    public static void Main ()
    {
        int []a = { 10, 7, 8, 10, 12, 19 };
        int n = a.Length;
        int s = 27;
     
        Console.WriteLine(findMinimumK(a, n, s));
    }
}
 
// This code is contributed by AnkitRai01


Output: 

3

 

Time Complexity: O(N*(log N)), N=Array length

Auxiliary Space: O(1)



Last Updated : 17 Apr, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads