Water Bottles II - Practice Coding Problems

Water Bottles II - Problem

Math Simulation Medium

Water Bottles II

You're at a recycling center with a unique bottle exchange program! You start with numBottles full water bottles and can participate in an exchange program where you trade empty bottles for full ones.

The Rules:
• You can drink any number of full bottles (turning them into empty bottles)
• You can exchange numExchange empty bottles for 1 full bottle
• After each exchange, the exchange rate increases by 1 (making future exchanges more expensive)
• You cannot split exchanges - you must exchange exactly numExchange empty bottles at once

Goal: Return the maximum number of water bottles you can drink.

Example: If you have 3 full bottles and the initial exchange rate is 1:
1. Drink 3 bottles → 3 empty bottles
2. Exchange 1 empty for 1 full (rate becomes 2) → 2 empty + 1 full
3. Drink 1 bottle → 3 empty bottles
4. Exchange 2 empty for 1 full (rate becomes 3) → 1 empty + 1 full
5. Drink 1 bottle → 2 empty bottles
6. Cannot exchange anymore (need 3 empty, only have 2)

Total bottles drunk: 5

Input & Output

example_1.py — Python

$ Input: numBottles = 13, numExchange = 6

› Output: 15

💡 Note: Start with 13 bottles, drink all → 13 empty bottles. Exchange 6 empty for 1 full (rate becomes 7) → 7 empty + 1 full. Drink 1 full → 8 empty bottles. Exchange 7 empty for 1 full (rate becomes 8) → 1 empty + 1 full. Drink 1 full → 2 empty bottles. Cannot exchange anymore (need 8, have 2). Total: 13 + 1 + 1 = 15.

example_2.py — Python

$ Input: numBottles = 10, numExchange = 3

› Output: 13

💡 Note: Start with 10 bottles, drink all → 10 empty bottles. Exchange 9 empty for 3 full (3 exchanges at rate 3, rate becomes 4) → 1 empty + 3 full. Drink 3 full → 4 empty bottles. Exchange 4 empty for 1 full (rate becomes 5) → 0 empty + 1 full. Drink 1 full → 1 empty bottle. Cannot exchange (need 5, have 1). Total: 10 + 3 + 0 = 13.

example_3.py — Python

$ Input: numBottles = 1, numExchange = 1

› Output: 2

💡 Note: Start with 1 bottle, drink it → 1 empty bottle. Exchange 1 empty for 1 full (rate becomes 2) → 0 empty + 1 full. Drink 1 full → 1 empty bottle. Cannot exchange (need 2, have 1). Total: 1 + 1 = 2.

Visualization

Tap to expand

Understanding the Visualization

Initial Drinking

Drink all your starting bottles - they're now empty and ready for recycling

First Exchange

Trade your empty bottles at the initial exchange rate for new full bottles

Rate Increase

The recycling center increases their exchange rate, making future trades more expensive

Repeat Process

Continue drinking and exchanging until you don't have enough empty bottles

Final Count

Sum up all the bottles you've consumed throughout the entire process

Key Takeaway

🎯 Key Insight: Since the exchange rate increases after each use, we must simulate the process step-by-step rather than using a mathematical formula. The efficiency comes from batch-processing exchanges at each rate level.

Time & Space Complexity

Time Complexity

⏱️

O(√n)

Same as brute force - limited by exchange rate progression

✓ Linear Growth

Space Complexity

O(1)

Constant extra space for tracking variables

✓ Linear Space

Constraints

1 ≤ numBottles ≤ 100
1 ≤ numExchange ≤ 100
The exchange rate increases by 1 after each successful exchange

Asked in

f Meta 35 a Amazon 28 G Google 22 Apple 18

The optimal approach uses simulation to model the bottle exchange process. We repeatedly drink all full bottles, then exchange empty bottles at the current rate. The key insight is that the dynamic exchange rate prevents mathematical shortcuts, making simulation the most efficient approach with O(√n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Simulation	O(√n)	O(1)	Enhanced simulation with optimized exchange calculations
Brute Force Simulation	O(√n)	O(1)	Simulate the entire drinking and exchanging process step by step

Optimized Simulation — Algorithm Steps

Drink all initial bottles and count them
Track empty bottles after drinking
For each exchange rate, calculate maximum possible exchanges
Update bottle counts efficiently
Continue until no more exchanges possible

Visualization

Tap to expand

Step-by-Step Walkthrough

Batch Calculation

Calculate all exchanges possible at current rate

Efficient Update

Update all counts in one operation

Rate Progression

Move to next exchange rate level

Code -

solution.c — C

#include <stdio.h>

int maxBottlesDrunk(int numBottles, int numExchange) {
    int totalDrunk = numBottles;
    int emptyBottles = numBottles;
    
    while (emptyBottles >= numExchange) {
        // Calculate how many full bottles we can get
        int exchangesPossible = emptyBottles / numExchange;
        int remainingEmpty = emptyBottles % numExchange;
        
        // After drinking the new bottles, they become empty too
        emptyBottles = remainingEmpty + exchangesPossible;
        totalDrunk += exchangesPossible;
        
        // Exchange rate increases
        numExchange++;
    }
    
    return totalDrunk;
}

int main() {
    int numBottles, numExchange;
    scanf("%d %d", &numBottles, &numExchange);
    printf("%d\n", maxBottlesDrunk(numBottles, numExchange));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(√n)

Same as brute force - limited by exchange rate progression

✓ Linear Growth

Space Complexity

O(1)

Constant extra space for tracking variables

✓ Linear Space

Constraints

1 ≤ numBottles ≤ 100
1 ≤ numExchange ≤ 100
The exchange rate increases by 1 after each successful exchange

42.8K Views

Medium Frequency

~15 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler