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: 3
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: 2
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.
#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;
} |
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
}
} |
# 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
|
// 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
|
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++;
}
}
} |
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++ 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 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 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 |
<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# 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 |
3
Time Complexity: O(N*(log N)), N=Array length
Auxiliary Space: O(1)