Geek wants to water n plants (numbered from 0 to n-1), where planti requires arr[i] units of water daily. Geek has to use buckets of the same size and can not use a bucket more than once a day. Also, Geek does not waste any water. Find the minimum number of buckets Geek needs to use daily for watering the plants.
Note: Each bucket can be designated for only one plant after receiving a fresh refill of water at the beginning of each day.
Examples:
Input: N = 4, arr[] = {2, 6, 4, 10}
Output: 11
Explanation: Geek will use buckets of size 2 units daily. Then Geek will need 1, 3, 2, and 5 numbers of buckets for plant 0, plant 1, plant 2, and plant 3 respectively daily.Input: N = 1, arr[] = {5}
Output: 1
Explanation: Geek will use a bucket of size 5 units daily. Then Geek will need 1 bucket for plant 0 daily.
Approach:
Since all bucket sizes should be the same, and one bucket is used for only one plant, we can deduce that the bucket size should be the common divisor of all elements in the array. As we need to determine the minimum number of buckets required for watering all the plants, we will calculate the greatest common divisor (GCD) of all the elements in the array.
Steps to solve this problem:
Initially, we take one variable named gcd_val to store the greatest common divisor of all elements of the array. It is initialized by the value 0.
- Using a loop, we will traverse the given array and, for each element of the array, we will calculate its GCD using the Euclidean Algorithm. In the C++ language, we can use a built-in function(i.e. __gcd(a,b)) for calculating GCD.
- Now, we have taken another variable called ans to store the answer to the problem. Initially, the value of the variable is 0.
- Now, for every element of the array, we will divide each element of the array by the value stored inside the gcdval variable, and the division result will be added to the answer variable, ans.
- Finally, we will return the ans variable as an answer, i.e., the minimum number of buckets required for watering the plants.
Below is the implementation of the above approach.
#include <bits/stdc++.h> using namespace std;
// Function to calculate minimum number buckets required for // watering the plants daily long long minimumBuckets( int N, int arr[])
{ // code here
// This variable is used to store the gcd value of every
// element of the array
int gcdval = 0;
for ( int i = 0; i < N; i++) {
// using Euclidian algorithm we can calculate GCD
gcdval = __gcd(gcdval, arr[i]);
}
// Declared ans variable to store the answer of the
// problem
long long ans = 0;
for ( int i = 0; i < N; i++) {
// For each element of the array we divide the
// element by their gcd value,gcdval
ans += (arr[i] / gcdval) + (arr[i] % gcdval);
}
// Finally return the answer
return ans;
} // Driver function int main()
{ // Number of Plants
int N = 4;
// arr[i] represent the amount of water required for
// i'th plants per day
int arr[] = { 2, 6, 4, 10 };
cout << "Minimum number of buckets required: "
<< minimumBuckets(N, arr) << endl;
return 0;
} |
#include <stdio.h> #include <stdlib.h> // Function to return gcd of a and b int gcd( int a, int b)
{ if (a == 0)
return b;
return gcd(b % a, a);
} // Function to calculate the minimum number of buckets // required for watering the plants daily long long minimumBuckets( int N, int arr[])
{ // This variable is used to store the GCD value of every
// element of the array
int gcdval = 0;
for ( int i = 0; i < N; i++) {
// Using Euclidean algorithm to calculate GCD
gcdval = gcd(gcdval, arr[i]);
}
// Declared ans variable to store the answer of the
// problem
long long ans = 0;
for ( int i = 0; i < N; i++) {
// For each element of the array, we divide the
// element by their GCD value, gcdval
ans += (arr[i] / gcdval) + (arr[i] % gcdval);
}
// Finally return the answer
return ans;
} // Driver function int main()
{ // Number of Plants
int N = 4;
// arr[i] represents the amount of water required for
// i'th plants per day
int arr[] = { 2, 6, 4, 10 };
long long result = minimumBuckets(N, arr);
printf ("Minimum number of buckets required: %lld\n",
result);
return 0;
} |
import java.util.Arrays;
public class MinimumBuckets {
// Function to calculate the minimum number of buckets required for watering the plants daily
static long minimumBuckets( int N, int [] arr) {
// This variable is used to store the gcd value of every element of the array
int gcdVal = 0 ;
for ( int i = 0 ; i < N; i++) {
// Using Euclidean algorithm to calculate GCD
gcdVal = gcd(gcdVal, arr[i]);
}
// Declared ans variable to store the answer of the problem
long ans = 0 ;
for ( int i = 0 ; i < N; i++) {
// For each element of the array, divide the element by their gcd value (gcdVal)
ans += (arr[i] / gcdVal) + (arr[i] % gcdVal);
}
// Finally, return the answer
return ans;
}
// Function to calculate GCD using Euclidean algorithm
static int gcd( int a, int b) {
while (b != 0 ) {
int temp = b;
b = a % b;
a = temp;
}
return a;
}
// Driver function
public static void main(String[] args) {
// Number of Plants
int N = 4 ;
// arr[i] represents the amount of water required for i'th plants per day
int [] arr = { 2 , 6 , 4 , 10 };
System.out.println( "Minimum number of buckets required: " + minimumBuckets(N, arr));
}
} // This code is contributed by shivamgupta310570 |
def minimum_buckets(N, arr):
# Function to calculate GCD using Euclidean algorithm
def gcd(a, b):
while b ! = 0 :
temp = b
b = a % b
a = temp
return a
# This variable is used to store the gcd value of every element of the array
gcd_val = 0
for i in range (N):
# Using Euclidean algorithm to calculate GCD
gcd_val = gcd(gcd_val, arr[i])
# Declared ans variable to store the answer of the problem
ans = 0
for i in range (N):
# For each element of the array, divide the element by their gcd value (gcd_val)
ans + = (arr[i] / / gcd_val) + (arr[i] % gcd_val)
# Finally, return the answer
return ans
# Driver function if __name__ = = "__main__" :
# Number of Plants
N = 4
# arr[i] represents the amount of water required for i'th plant per day
arr = [ 2 , 6 , 4 , 10 ]
print ( "Minimum number of buckets required:" , minimum_buckets(N, arr))
|
using System;
public class GFG {
// Function to calculate the minimum number of buckets
// required for watering the plants daily
static long MinimumBuckets( int N, int [] arr)
{
// This variable is used to store the gcd value of
// every element of the array
int gcdVal = 0;
for ( int i = 0; i < N; i++) {
// Using Euclidean algorithm to calculate GCD
gcdVal = GCD(gcdVal, arr[i]);
}
// Declared ans variable to store the answer of the
// problem
long ans = 0;
for ( int i = 0; i < N; i++) {
// For each element of the array, divide the
// element by their gcd value (gcdVal)
ans += (arr[i] / gcdVal) + (arr[i] % gcdVal);
}
// Finally, return the answer
return ans;
}
// Function to calculate GCD using Euclidean algorithm
static int GCD( int a, int b)
{
while (b != 0) {
int temp = b;
b = a % b;
a = temp;
}
return a;
}
// Driver function
public static void Main( string [] args)
{
// Number of Plants
int N = 4;
// arr[i] represents the amount of water required
// for i'th plants per day
int [] arr = { 2, 6, 4, 10 };
Console.WriteLine(
"Minimum number of buckets required: "
+ MinimumBuckets(N, arr));
}
} |
// Function to calculate the minimum number of buckets required for watering the plants daily function minimumBuckets(N, arr) {
// This variable is used to store the gcd value of every element of the array
let gcdVal = 0;
// Using Euclidean algorithm to calculate GCD
for (let i = 0; i < N; i++) {
gcdVal = gcd(gcdVal, arr[i]);
}
// Declared ans variable to store the answer of the problem
let ans = 0;
for (let i = 0; i < N; i++) {
// For each element of the array, divide the element by their gcd value (gcdVal)
ans += Math.floor(arr[i] / gcdVal) + (arr[i] % gcdVal);
}
// Finally, return the answer
return ans;
} // Function to calculate GCD using Euclidean algorithm function gcd(a, b) {
while (b !== 0) {
let temp = b;
b = a % b;
a = temp;
}
return a;
} // Driver function function main() {
// Number of Plants
const N = 4;
// arr[i] represents the amount of water required for i'th plants per day
const arr = [2, 6, 4, 10];
console.log( "Minimum number of buckets required: " + minimumBuckets(N, arr));
} // Invoke the main function main(); |
Minimum number of buckets required: 11
Time Complexity: O(N*logP)
Auxiliary Space: O(1)