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 i^th 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>

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 <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;
}

Java

// Java code for the approach
import java.util.Arrays;

public class GFG
{

  // Function to find the maximum number
  // of buckets that can be filled with
  // the amount of water available
  public static int maxBuckets(int[] buckets, int n,
                               int liquid) {
    int filledBuckets = 0;
    int liquidRemaining = liquid;

    // Iterate through the buckets in descending order
    // of size
    for (int i = n-1; i >= 0; i--) {
      if (buckets[i] <= liquidRemaining) {
        filledBuckets
          += liquidRemaining / buckets[i];
        liquidRemaining %= buckets[i];
      }
    }

    return filledBuckets;
  }

  // Driver code
  public static void main(String[] args)
  {

    // Input array
    int[] buckets = { 10, 5, 7, 3, 2 };
    int n = buckets.length;
    int liquid = 20;

    // Function call
    int maxFilledBuckets
      = maxBuckets(buckets, n, liquid);

    // Printing final answer
    System.out.println("Maximum filled buckets: "
                       + maxFilledBuckets);
  }
}

Python3

def max_buckets(buckets, n, liquid):
    filled_buckets = 0
    liquid_remaining = liquid

    # iterate through the buckets in descending order of size
    for i in range(n-1, -1, -1):
        if buckets[i] <= liquid_remaining:
            filled_buckets += liquid_remaining // buckets[i]
            liquid_remaining %= buckets[i]

    return filled_buckets

buckets = [10, 5, 7, 3, 2]
n = len(buckets)
liquid = 20
max_filled_buckets = max_buckets(buckets, n, liquid)
print("Maximum filled buckets: " + str(max_filled_buckets))

C#

using System;

class Gfg {
  static 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;
  }

  static void Main() {
    int[] buckets = {10, 5, 7, 3, 2};
    int n = buckets.Length;
    int liquid = 20;
    int max_filled_buckets = max_buckets(buckets, n, liquid);
    Console.WriteLine("Maximum filled buckets: " + max_filled_buckets);
  }
}

Javascript

function max_buckets(buckets, n, liquid) {
  let filled_buckets = 0;
  let liquid_remaining = liquid;

  // iterate through the buckets in descending order of size
  for (let i = n-1; i >= 0; i--) {
    if (buckets[i] <= liquid_remaining) {
      filled_buckets += Math.floor(liquid_remaining / buckets[i]);
      liquid_remaining %= buckets[i];
    }
  }

  return filled_buckets;
}

let buckets = [10, 5, 7, 3, 2];
let n = buckets.length;
let liquid = 20;
let max_filled_buckets = max_buckets(buckets, n, liquid);
console.log("Maximum filled buckets: " + max_filled_buckets);

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.