Maximum number of buckets that can be filled
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:
- Calculate the total water availability by calculating the sum of first N natural numbers.
- Sort the array arr[] in ascending order.
- Traverse the given array arr[] and find the sum of array elementsy till that index, say i, where the sum exceeds the total availability.
- After completing the above steps, print the value of index i as the maximum number of buckets that can be filled.
Below is the implementation of the above approach:
C++
// C++ program for the above approach #include <bits/stdc++.h> 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
<script> // Javascript program to implement // the above approach // Function to find the maximum number // of buckets that can be filled with // the amount of water available function getBuckets(arr, N) { // Find the total available water let availableWater = N * (N - 1) / 2; // Sort the array in ascending order arr.sort( function (a, b){ return a - b}); let i = 0, sum = 0; // Check if bucket can be // filled with available water while (sum <= availableWater) { sum += arr[i]; i++; } // Print count of buckets document.write(i - 1); } let arr = [ 1, 5, 3, 4, 7, 9 ]; let N = arr.length; getBuckets(arr, N); </script> |
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 <bits/stdc++.h> 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: " <<max_filled_buckets<<endl; return 0; } |
C
#include <stdio.h> 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; } |
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.
Please Login to comment...