最多可装满的水桶数量

给定一个数组arr [] ，该数组由N个存储桶的容量组成，其中arr [i]表示第i^个存储桶的容量。如果可用水总量是数组索引(基于1的索引)的总和，则任务是找到可以用可用水完全充满的最大水桶数。

例子：

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.
Therefore, the total buckets that can be fully filled with water is 4.

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

方法：可以很好地解决给定的问题。请按照以下步骤解决给定的问题：

• 通过计算前N个自然数的总和来计算总可用水量。
• 以升序对数组arr []进行排序。
• 遍历给定的数组arr []并找到数组elementy的总和，直到该索引(即i)为止，该总和超过了总可用性。
• 完成上述步骤后，将索引i的值打印为可以填充的最大存储桶数。

下面是上述方法的实现：

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

 
    // 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);
   

输出：

4

时间复杂度： O(N * log N)
辅助空间： O(1)