Maximum number of buckets that can be filled

• Difficulty Level : Easy
• Last Updated : 23 Mar, 2023

Given an array arr[] consisting of capacities of N buckets where arr[i] denotes the capacity of the ith bucket. If the total amount of water available is the sum of array indices (1-based indexing), the task is to find the maximum number of buckets that can be filled with the available water. The bucket will be considered filled if it has at least 1 liter in it.

Examples:

Input: arr[] = {1, 5, 3, 4, 7, 9}
Output: 4
Explanation:
Total available water = Sum of arrayindices of arr[] = 1 + 2 + 3 + 4 + 5 = 15.
Sorting the array in ascending order modifies the array to {1, 3, 4, 5, 7, 9}.
Fill the bucket having capacity 1, then . Now, available water = 14.
Fill the bucket having capacity 3 . Now, available water = 11.
Fill bucket having capacity 4. Now, available water = 7.
Fill bucket having capacity 5. Now, available water = 2. in this case it is filled with more than 1 liter so this bucket  is also considered.
Therefore, the total buckets that can be fully filled with water is 4.

Input: arr[] = {2, 5, 8, 3, 2, 10, 8}
Output: 5

Approach: The given problem can be solved Greedily. Follow the steps below to solve the given problem:

Below is the implementation of the above approach:

C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the maximum number``// of buckets that can be filled with``// the amount of water available``int` `getBuckets(``int` `arr[], ``int` `N)``{``    ``// Find the total available water``    ``int` `availableWater = N * (N - 1) / 2;` `    ``// Sort the array in ascending order``    ``sort(arr, arr + N);` `    ``int` `i = 0, sum = 0;` `    ``// Check if bucket can be``    ``// filled with available water``    ``while` `(sum <= availableWater) {``        ``sum += arr[i];``        ``i++;``    ``}` `    ``// Print count of buckets``    ``cout << i - 1;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 5, 3, 4, 7, 9 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``getBuckets(arr, N);` `    ``return` `0;``}`

Java

 `// Java program for the above approach``import` `java.util.*;``public` `class` `GFG``{``  ` `  ``// Function to find the maximum number``  ``// of buckets that can be filled with``  ``// the amount of water available``  ``static` `void` `getBuckets(``int``[] arr, ``int` `N)``  ``{``    ``// Find the total available water``    ``int` `availableWater = N * (N - ``1``) / ``2``;` `    ``// Sort the array in ascending order``    ``Arrays.sort(arr);` `    ``int` `i = ``0``, sum = ``0``;` `    ``// Check if bucket can be``    ``// filled with available water``    ``while` `(sum <= availableWater) {``      ``sum += arr[i];``      ``i++;``    ``}` `    ``// Print count of buckets``    ``System.out.println(i - ``1``);``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int``[] arr = { ``1``, ``5``, ``3``, ``4``, ``7``, ``9` `};``    ``int` `N = arr.length;` `    ``getBuckets(arr, N);``  ``}``}` `// This code is contributed by divyesh072019.`

Python3

 `# Python3 program for the above approach` `# Function to find the maximum number``# of buckets that can be filled with``# the amount of water available``def` `getBuckets(arr, N) :` `    ``# Find the total available water``    ``availableWater ``=` `N ``*` `(N ``-` `1``) ``/``/` `2` `    ``# Sort the array in ascending order``    ``arr.sort()` `    ``i, ``Sum` `=` `0``, ``0` `    ``# Check if bucket can be``    ``# filled with available water``    ``while` `(``Sum` `<``=` `availableWater) :``        ``Sum` `+``=` `arr[i]``        ``i ``+``=` `1` `    ``# Print count of buckets``    ``print``(i ``-` `1``, end ``=` `"")` `arr ``=` `[ ``1``, ``5``, ``3``, ``4``, ``7``, ``9` `]``N ``=` `len``(arr)` `getBuckets(arr, N);` `# This code is contributed by divyeshrabadiya07.`

C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;``using` `System.Linq;` `class` `GFG``{``  ` `  ``// Function to find the maximum number``  ``// of buckets that can be filled with``  ``// the amount of water available``  ``static` `void` `getBuckets(``int``[] arr, ``int` `N)``  ``{``    ` `    ``// Find the total available water``    ``int` `availableWater = N * (N - 1) / 2;` `    ``// Sort the array in ascending order``    ``Array.Sort(arr);``    ``int` `i = 0, sum = 0;` `    ``// Check if bucket can be``    ``// filled with available water``    ``while` `(sum <= availableWater)``    ``{``      ``sum += arr[i];``      ``i++;``    ``}` `    ``// Print count of buckets``    ``Console.Write(i - 1);``  ``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int``[] arr = { 1, 5, 3, 4, 7, 9 };``    ``int` `N = arr.Length;` `    ``getBuckets(arr, N);``}``}` `// This code is contributed by splevel62.`

Javascript

 ``

Output:

`4`

Time Complexity: O(N*log N)
Auxiliary Space: O(1)

Another Approach:

1. Define a function max_buckets() that takes an array of bucket sizes, the number of buckets, and the amount of liquid as input and returns the maximum number of buckets that can be filled with the given liquid.

2. Initialize two variables filled_buckets and liquid_remaining to 0 and the given liquid, respectively.

3. Iterate through the buckets in descending order of size, starting from the largest bucket size.

4. For each bucket, check if its size is less than or equal to the remaining liquid. If it is, calculate how many times the bucket can be filled with the remaining liquid using integer division and add the result to the filled_buckets variable. Also, update the liquid_remaining variable by subtracting the amount of liquid used to fill the bucket.

5. If the size of the bucket is greater than the remaining liquid, move on to the next bucket.

6. After iterating through all the buckets, return the value of filled_buckets.

7. In the main() function, initialize an array of bucket sizes, the number of buckets, and the amount of liquid.

8.Call the max_buckets() function with the input arguments and store the result in a variable max_filled_buckets.

9.Print the value of max_filled_buckets using printf().

C++

 `#include ``using` `namespace` `std;` `int` `max_buckets(``int` `buckets[], ``int` `n, ``int` `liquid) {``  ``int` `filled_buckets = 0;``  ``int` `liquid_remaining = liquid;` `  ``// iterate through the buckets in descending order of size``  ``for` `(``int` `i = n-1; i >= 0; i--) {``    ``if` `(buckets[i] <= liquid_remaining) {``      ``filled_buckets += liquid_remaining / buckets[i];``      ``liquid_remaining %= buckets[i];``    ``}``  ``}` `  ``return` `filled_buckets;``}` `int` `main() {``  ``int` `buckets[] = {10, 5, 7, 3, 2};``  ``int` `n = ``sizeof``(buckets) / ``sizeof``(buckets[0]);``  ``int` `liquid = 20;``  ``int` `max_filled_buckets = max_buckets(buckets, n, liquid);``  ``cout<<``"Maximum filled buckets: "``<

C

 `#include ` `int` `max_buckets(``int` `buckets[], ``int` `n, ``int` `liquid) {``    ``int` `filled_buckets = 0;``    ``int` `liquid_remaining = liquid;` `    ``// iterate through the buckets in descending order of size``    ``for` `(``int` `i = n-1; i >= 0; i--) {``        ``if` `(buckets[i] <= liquid_remaining) {``            ``filled_buckets += liquid_remaining / buckets[i];``            ``liquid_remaining %= buckets[i];``        ``}``    ``}``    ` `    ``return` `filled_buckets;``}` `int` `main() {``    ``int` `buckets[] = {10, 5, 7, 3, 2};``    ``int` `n = ``sizeof``(buckets) / ``sizeof``(buckets[0]);``    ``int` `liquid = 20;``    ``int` `max_filled_buckets = max_buckets(buckets, n, liquid);``    ``printf``(``"Maximum filled buckets: %d\n"``, max_filled_buckets);``    ``return` `0;``}`

Output

`Maximum filled buckets: 10`

The time complexity of this algorithm is O(nlogn), where n is the number of buckets, due to the use of the modulo operator, which takes logarithmic time. However, in practice, the algorithm is likely to be faster than the previous solution because it avoids the overhead of calling the qsort() function.

The space complexity of this algorithm is O(1), as it only uses a few constant variables.

My Personal Notes arrow_drop_up