# Leetcode – Water Bottles Solution

One of the strengths of programming is its ability to model and solve real-world problems, and the “Water Bottles” problem on Leetcode is no exception. This problem is deceptively simple but can be approached in a variety of ways, each with its own set of trade-offs. In this in-depth article, we’ll explore the problem statement, various methods to solve it, analyze the time and space complexities.

## Problem Statement

Given numBottles full water bottles, you can exchange numExchange empty water bottles for one full water bottle. The task is to find the maximum number of water bottles you can drink.

#### Example

Input: numBottles = 9, numExchange = 3
Output: 13
Explanation: You can exchange 3 empty bottles to get 1 full water bottle.
Number of water bottles you can drink: 9 + 3 + 1 = 13.

## The Iterative Approach

A simple iterative solution is the most intuitive way to approach this problem. You can keep drinking the water bottles and exchanging them until you can’t exchange any more.

Python Code:

def numWaterBottles(numBottles, numExchange):
total = numBottles
empty = numBottles

while empty >= numExchange:
new_bottles = empty // numExchange
total += new_bottles
empty = new_bottles + empty % numExchange

# Test the function
print(numWaterBottles(9, 3))  # Output should be 13

### Time Complexity

The time complexity for this approach is O(numBottles).

### Space Complexity

The space complexity is O(1) as we’re using a constant amount of extra space.

## The Recursive Approach

The problem can also be solved recursively, which might make it easier to understand for those who are more comfortable with recursion.

Python Code:

def numWaterBottles(numBottles, numExchange):
if numBottles < numExchange:
return numBottles

new_bottles = numBottles // numExchange
remaining_bottles = numBottles % numExchange

return numBottles + numWaterBottles(new_bottles + remaining_bottles, numExchange) - remaining_bottles

# Test the function
print(numWaterBottles(9, 3))  # Output should be 13

### Time Complexity

The time complexity is the same as the iterative approach, O(numBottles).

### Space Complexity

The space complexity here would be O(numBottles) due to the recursive stack.

## The Mathematical Approach

If you analyze the problem carefully, you can deduce a mathematical formula to solve it. However, finding that formula is non-trivial and may not be the best approach for a timed coding interview.

### Time and Space Complexity

The mathematical approach, if formulated, would have a time and space complexity of O(1).

## Edge Cases and Further Considerations

1. Zero Bottles: What if numBottles is zero? In this case, the answer should be zero as well.
2. One Bottle: What if numBottles is one? In this case, you cannot make any exchanges, and you can drink only that one bottle.
3. Exchange Requirement: What if numExchange is greater than numBottles? You won’t be able to make an initial exchange but can still drink numBottles.

## Conclusion

The “Water Bottles” problem is a great exercise for thinking about problem-solving from multiple perspectives. Whether it’s employing straightforward iterative methods, using recursion for more elegant code, or delving into a potential mathematical solution, each approach has its pros and cons. This problem not only allows you to practice coding but also prompts you to think deeply about optimization, real-world applications, and edge cases.