Skip to content
Related Articles

Related Articles

Minimum number of bottles required to fill K glasses

View Discussion
Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 15 Jun, 2022

Given N glasses having water, and a list A of each of their capacity. The task is to find the minimum number of bottles required to fill out exactly K glasses. The capacity of each bottle is 100 units.
 

Examples:  

Input: N = 4, K = 3, arr[] = {200, 150, 140, 300} 
Output:
We have to fill out exactly 3 glasses. 
So we fill out 140, 150, 200 whose sum is 490, so we need 5 bottles for this.
Input: N = 5, K = 4, arr[] = {1, 2, 3, 2, 1} 
Output:

Approach: To fill out exactly K glasses, take the K glasses with the least capacity. So for this sort the list of given capacities. The final answer will be the ceiling value of (Sum of capacities of 1st k glasses) / (Capacity of 1 bottle).
Below is the implementation of the above approach:
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// function to calculate minimum glasses
double Min_glass(int n, int k,
                            int a[])
{
    // sort the array based on
    // their capacity
  
    int sum = 0;
  
    // taking sum of capacity
    // of first k glasses
    for (int i = 0; i < k; i++)
        sum += a[i];
  
    // calculate the answer
    double ans = ceil((double)sum /
                            (double)100);
  
    return ans;
}
 
// Driver code
int main()
{
 
    int n = 4;
    int k = 3;
    int a[] = { 200, 150, 140, 300 };
    sort(a, a+n);
    cout << Min_glass(n, k, a);
 
    return 0;
}
 
// This code is contributed by target_2.

C




// C implementation of the approach
#include <stdio.h>
#include<math.h>
 
// function to calculate minimum glasses
double Min_glass(int n, int k,int a[])
{
   
    // sort the array based on
    // their capacity
    int sum = 0;
 
    // taking sum of capacity
    // of first k glasses
    for (int i = 0; i < k; i++)
        sum += a[i];
 
    // calculate the answer
    double ans = ceil((double)sum /
                            (double)100);
 
    return ans;
}
 
// Driver code
int main()
{
 
    int n = 4;
    int k = 3;
    int temp=0;
    int a[] = { 200, 150, 140, 300 };
    int length = sizeof(a)/sizeof(a[0]); 
   
      // swapping the array in ascending order
    for (int i = 0; i < length; i++) {    
        for (int j = i+1; j < length; j++) {    
           if(a[i] > a[j]) {   
               temp = a[i];   
               a[i] = a[j];   
               a[j] = temp;   
           }    
        }    
    }   
    printf("%.0f",Min_glass(n, k, a));
 
    return 0;
}
 
// This code is contributed by allwink45.

Java




// Java implementation of the
// above approach
import java.util.*;
 
class GFG
{
// function to calculate minimum glasses
public static double Min_glass(int n, int k,
                            int[] a)
{
    // sort the array based on
    // their capacity
 
    int sum = 0;
 
    // taking sum of capacity
    // of first k glasses
    for (int i = 0; i < k; i++)
        sum += a[i];
 
    // calculate the answer
    double ans = Math.ceil((double)sum /
                            (double)100);
 
    return ans;
}
 
// Driver code
public static void main(String[] args)
{
    int n = 4;
    int k = 3;
    int[] a = { 200, 150, 140, 300 };
    Arrays.sort(a);
    System.out.println(Min_glass(n, k, a));
}
}
 
// This code is contributed by mits

Python3




# Python3 implementation of the above approach
from math import ceil
 
# Function to calculate minimum glasses
def Min_glass(n, k, a):
  
    # sort the array based on their capacity
    a.sort()
 
    # calculate the answer
    return ceil(sum(a[:k]) / 100)
  
# Driver code
if __name__ == "__main__":
  
    n, k = 4, 3
    a = [200, 150, 140, 300
 
    print(Min_glass(n, k, a))
 
# This code is contributed by Rituraj Jain

C#




// C# implementation of the
// above approach
using System;
 
class GFG
{
// function to calculate minimum glasses
public static double Min_glass(int n, int k,
                               int []a)
{
    // sort the array based on
    // their capacity
 
    int sum = 0;
 
    // taking sum of capacity
    // of first k glasses
    for (int i = 0; i < k; i++)
        sum += a[i];
 
    // calculate the answer
    double ans = Math.Ceiling((double)sum /
                              (double)100);
 
    return ans;
}
 
// Driver code
public static void Main()
{
    int n = 4;
    int k = 3;
    int[] a = { 200, 150, 140, 300 };
    Array.Sort(a);
    Console.WriteLine(Min_glass(n, k, a));
}
}
 
// This code is contributed
// by Soumik Mondal

PHP




<?php
// PHP implementation of the above approach
 
// function to calculate minimum glasses
function Min_glass($n, $k, $a)
{
    // sort the array based on
    // their capacity
    sort($a);
 
    $sum = 0;
 
    // taking sum of capacity
    // of first k glasses
    for ($i = 0; $i < $k; $i++)
        $sum += $a[$i];
 
    // calculate the answer
    $ans = ceil($sum /100);
 
    return $ans;
}
 
// Driver code
$n = 4;
$k = 3;
$a = array( 200, 150, 140, 300 );
 
echo Min_glass($n, $k, $a);
 
// This code is contributed
// by akt_mit
?>

Javascript




<script>
 
// Javascript implementation of the
// above approach
 
// Function to calculate minimum glasses
function Min_glass(n, k, a)
{
     
    // Sort the array based on
    // their capacity
    var sum = 0;
 
    // Taking sum of capacity
    // of first k glasses
    for(var i = 0; i < k; i++)
        sum += a[i];
 
    // Calculate the answer
    var ans = parseInt(Math.ceil(sum / 100));
 
    return ans;
}
 
// Driver Code
var n = 4;
var k = 3;
var a = [ 200, 150, 140, 300 ];
a.sort();
 
document.write(Min_glass(n, k, a));
 
// This code is contributed by Ankita saini
 
</script>

Output: 

5

 

Time Complexity: O(nlog(n))
Auxiliary Space: O(1)
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!