Soft Drink Promotions: Calculate Your Free Bottles (Python)

Have you ever wondered how to maximize your rewards in a loyalty program? 🤔 Today we will unravel the algorithm behind optimizing Juan’s “thirst.”

🔮 Problem Statement

Juan is a soft drink enthusiast. His favorite soft drink has an attractive promotion: for every promo number of empty bottles Juan returns, he receives a new soft drink bottle for free. The problem is, given that Juan has money amount of money and each bottle costs cost, how many soft drink bottles in total can Juan enjoy, maximizing the use of the promotion?

Parameters:

• money: Amount of money Juan has (integer).
• cost: Cost per bottle (integer).
• promo: Number of bottles needed to get a free bottle (integer).

Return:

• Total number of soft drinks Juan can get (integer).

Examples:

promotions(10, 2, 5) -> 6
promotions(12, 4, 4) -> 3
promotions(10, 2, 2) -> 9

Additional Notes:

• Juan will always use the promotion until he no longer has enough bottles to exchange.

🧩 Step-by-Step Solution

Let’s analyze how we transform the problem into code, step by step, as if we were building a thirsty automaton:

First, we define the promotions function that receives the money, the cost of each bottle, and the amount of bottles needed to get a new one for free. This is the foundation on which we will build our maximization mechanism.

def promotions(money, cost, promo):

Then, we calculate the initial amount of soft drinks Juan can buy with his money. We use integer division (//) because we are only interested in the complete bottles he can acquire. This is the starting point of Juan’s adventure.

	soda = money // cost

We initialize the bottles variable with the same value as soda. This variable will track the total number of bottles Juan has available to exchange. It’s like Juan’s “exchange available” counter.

	bottles = soda

We enter a while loop that runs as long as Juan has enough bottles to exchange. This loop represents the continuous cycle of buying, consuming, and exchanging bottles.

	while bottles >= promo:

Inside the loop, we use divmod to calculate how many free bottles Juan can get and how many bottles he has left over. divmod is like having an assistant that automatically counts how many groups of promo bottles Juan has and how many loose bottles he has left.

		free, rest = divmod(bottles, promo)

We update the total number of soft drinks Juan has obtained by adding the free bottles he got. Each free bottle is a victory, a step further in maximizing Juan’s “thirst.”

		soda += free

Finally, we update the number of bottles Juan has available to exchange. This number will be the sum of the free bottles he obtained plus the bottles that were left over from the previous exchange. It’s Juan’s “stock” of bottles after each round of exchanges.

		bottles = free + rest

Once Juan no longer has enough bottles to exchange (the while loop ends), the function returns the total number of soft drinks he was able to obtain. This is the final result, the maximum potential of soft drinks Juan was able to unlock.

	return soda

Here is the complete solution:

def promotions(money, cost, promo):
	"level: medium; points: 6"
	soda = money // cost
	bottles = soda
	while bottles >= promo:
		free, rest = divmod(bottles, promo)
		soda += free
		bottles = free + rest
	return soda

🧠 Key Concepts

Integer division (//) is crucial here because it allows us to obtain only the integer part of the result of a division, which is essential when working with discrete quantities such as the number of bottles. We don’t want “half a bottle,” we want to know how many complete bottles Juan can buy.

The divmod function is a gem that combines two operations (division and modulo) into one. It returns both the quotient and the remainder of the division, allowing us to calculate the free bottles and remaining bottles efficiently. It’s like a mathematical “two for one.”

while loops are fundamental to the iterative logic of this problem. They allow us to simulate the repeated process of exchanging bottles until there are not enough left. It’s the code representation of Juan’s “insatiable thirst.”

Tuples are immutable data structures used here to store the results of divmod. Multiple assignment allows us to unpack the elements of the tuple (quotient and remainder) into individual variables (free and rest) in a concise and readable way.

Accumulation (e.g., soda += free) is a common pattern in programming that involves adding values to a variable in each iteration of a loop. In this case, we accumulate the total number of soft drinks Juan has obtained.

Did you know that divmod in Python is more efficient than using the / and % operators separately? Internally, it performs the division only once and returns both results, optimizing performance.

💫 Final Thoughts

A possible improvement to this code would be to consider scenarios with variable bottle costs or more complex promotions (e.g., promotions that require different amounts of bottles for different rewards). We could also explore the use of dynamic programming to optimize the calculation in cases with a large number of iterations.

This problem, although simple, illustrates how fundamental programming principles (such as loops, divisions, and accumulations) can be used to model and solve real-world problems, such as optimizing rewards in a loyalty program. 🤖

I hope you found this analysis helpful and entertaining. If you enjoyed unraveling this algorithm, feel free to explore other articles on my blog! I invite you to immerse yourself in the fascinating world of code and discover how we can transform everyday problems into elegant and efficient solutions. 🚀