Open in App
Not now

# Maximize count of empty water bottles from N filled bottles

• Difficulty Level : Basic
• Last Updated : 26 May, 2022

Given two integers N and E, where N represents the number of full water bottles and E represents the number of empty bottles that can be exchanged for a full water bottle. The task is to find the maximum number of water bottles that can be emptied.

Examples:

Input: N = 9, E = 3
Output: 13
Explanation:
Initially, there are 9 fully filled water bottles.
All of them are emptied to obtain 9 empty bottles. Therefore, count = 9
Then exchange 3 bottles at a time for 1 fully filled bottle.
Therefore, 3 fully filled bottles are obtained.
Then those 3 bottles are emptied to get 3 empty bottles. Therefore, count = 9 + 3 = 12
Then those 3 bottles are exchanged for 1 full bottle which is emptied.
Therefore, count = 9 + 3 + 1 = 13.

Input: N = 7, E = 5
Output: 8
Explanation:
Empty the 7 fully filled water bottles. Therefore, count = 7
Then exchange 5 bottles to obtain 1 fully filled bottle. Then empty that bottle.
Therefore, count = 7 + 1 = 8.

Approach: The following steps have to be followed to solve the problem:

• Store the value of N in a temporary variable, say a.
• Initialize a variable, say s, to store the count of empty bottles and another variable, say b, to store the count of bottles remaining after exchange.
• Now, iterate until a is not equal to 0 and increment s  by a, as it will be the minimum number of bottles that have been emptied.
• Update the following values:
• a to (a + b) / e
• b to N – (a * e)
• N to (a+b)
• Return s as the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the` `// above approach` `#include ` `using` `namespace` `std;`   `// Function to find the maximum` `// bottles that can be emptied` `int` `maxBottles(``int` `n, ``int` `e)` `{` `    ``int` `s = 0, b = 0;` `    ``int` `a = n;`   `    ``// Iterate until a ` `  ``// is non-zero` `    ``while` `(a != 0) {` `      `  `        ``// Add the number of ` `      ``// bottles that are emptied` `        ``s = s + a;`   `        ``// Update a after` `        ``// exchanging empty bottles` `        ``a = (a + b) / e;`   `        ``// Stores the number of bottles` `        ``// left after the exchange` `        ``b = n - (a * e);` `        ``n = a + b;` `    ``}`   `    ``// Return the answer` `    ``return` `s;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `n = 9, e = 3;`   `    ``// Function call` `    ``int` `s = maxBottles(n, e);` `    ``cout << s << endl;` `}`

## C

 `// C program for the above approach` `#include `   `// Function to find the maximum` `// bottles that can be emptied` `int` `maxBottles(``int` `n, ``int` `e)` `{` `    ``int` `s = 0, b = 0;` `    ``int` `a = n;`   `    ``// Iterate until a` `// is non-zero` `    ``while` `(a != 0) {` `    `  `        ``// Add the number of` `    ``// bottles that are emptied` `        ``s = s + a;`   `        ``// Update a after` `        ``// exchanging empty bottles` `        ``a = (a + b) / e;`   `        ``// Stores the number of bottles` `        ``// left after the exchange` `        ``b = n - (a * e);` `        ``n = a + b;` `    ``}`   `    ``// Return the answer` `    ``return` `s;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `n = 9, e = 3;`   `    ``// Function call` `    ``int` `s = maxBottles(n, e);` `    ``printf``(``"%d"``,s);` `}`   `// This code is contributed by allwink45.`

## Java

 `// Java program for the` `// above approach` `import` `java.util.*;`   `class` `GFG{`   `// Function to find the maximum` `// bottles that can be emptied` `static` `int` `maxBottles(``int` `n, ``int` `e)` `{` `    ``int` `s = ``0``, b = ``0``;` `    ``int` `a = n;`   `    ``// Iterate until a ` `    ``// is non-zero` `    ``while` `(a != ``0``) ` `    ``{` `    `  `        ``// Add the number of ` `        ``// bottles that are emptied` `        ``s = s + a;`   `        ``// Update a after` `        ``// exchanging empty bottles` `        ``a = (a + b) / e;`   `        ``// Stores the number of bottles` `        ``// left after the exchange` `        ``b = n - (a * e);` `        ``n = a + b;` `    ``}`   `    ``// Return the answer` `    ``return` `s;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `n = ``9``, e = ``3``;`   `    ``// Function call` `    ``int` `s = maxBottles(n, e);` `    `  `    ``System.out.print(s + ``"\n"``);` `}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program for the` `# above approach`   `# Function to find the maximum` `# bottles that can be emptied` `def` `maxBottles(n, e):` `    `  `    ``s ``=` `0` `    ``b ``=` `0` `    ``a ``=` `n`   `    ``# Iterate until a` `    ``# is non-zero` `    ``while` `(a !``=` `0``):`   `        ``# Add the number of` `        ``# bottles that are emptied` `        ``s ``=` `s ``+` `a`   `        ``# Update a after` `        ``# exchanging empty bottles` `        ``a ``=` `(a ``+` `b) ``/``/` `e`   `        ``# Stores the number of bottles` `        ``# left after the exchange` `        ``b ``=` `n ``-` `(a ``*` `e)` `        ``n ``=` `a ``+` `b`   `    ``# Return the answer` `    ``return` `s`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``n ``=` `9` `    ``e ``=` `3`   `    ``# Function call` `    ``s ``=` `maxBottles(n, e)` `    ``print``(s)`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach ` `using` `System;`   `class` `GFG{`   `// Function to find the maximum` `// bottles that can be emptied` `static` `int` `maxBottles(``int` `n, ``int` `e)` `{` `    ``int` `s = 0, b = 0;` `    ``int` `a = n;`   `    ``// Iterate until a ` `    ``// is non-zero` `    ``while` `(a != 0) ` `    ``{` `    `  `        ``// Add the number of ` `        ``// bottles that are emptied` `        ``s = s + a;`   `        ``// Update a after` `        ``// exchanging empty bottles` `        ``a = (a + b) / e;`   `        ``// Stores the number of bottles` `        ``// left after the exchange` `        ``b = n - (a * e);` `        ``n = a + b;` `    ``}`   `    ``// Return the answer` `    ``return` `s;` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `    ``int` `n = 9, e = 3;`   `    ``// Function call` `    ``int` `s = maxBottles(n, e);` `    `  `    ``Console.Write(s + ``"\n"``);` `}` `}`   `// This code is contributed by code_hunt`

## Javascript

 ``

Output:

`13`

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

My Personal Notes arrow_drop_up
Related Articles