Account Balance After Rounded Purchase
EasyPrompt
Initially, you have a bank account balance of 100 dollars.
You are given an integer purchaseAmount representing the amount you will spend on a purchase in dollars, in other words, its price.
When making the purchase, first the purchaseAmount is rounded to the nearest multiple of 10. Let us call this value roundedAmount. Then, roundedAmount dollars are removed from your bank account.
Return an integer denoting your final bank account balance after this purchase.
Notes:
- 0 is considered to be a multiple of 10 in this problem.
- When rounding, 5 is rounded upward (5 is rounded to 10, 15 is rounded to 20, 25 to 30, and so on).
Example 1:
Input: purchaseAmount = 9
Output: 90
Explanation:
The nearest multiple of 10 to 9 is 10. So your account balance becomes 100 - 10 = 90.
Example 2:
Input: purchaseAmount = 15
Output: 80
Explanation:
The nearest multiple of 10 to 15 is 20. So your account balance becomes 100 - 20 = 80.
Example 3:
Input: purchaseAmount = 10
Output: 90
Explanation:
10 is a multiple of 10 itself. So your account balance becomes 100 - 10 = 90.
Constraints:
0 <= purchaseAmount <= 100
Approaches
3 approaches with complexity analysis and trade-offs.
This approach involves converting the purchaseAmount to a floating-point number to leverage the built-in Math.round() function. The amount is first divided by 10.0, then rounded to the nearest whole number using Math.round(), and finally multiplied back by 10 to get the nearest multiple of 10.
Algorithm
- Convert
purchaseAmountto a floating-point type (e.g.,double). - Divide the value by
10.0. - Use the
Math.round()function to round the result to the nearest integer. This function correctly handles rounding up from .5, which matches the problem's requirement. - Multiply the rounded integer by
10to get theroundedAmount. - Calculate the final balance by subtracting
roundedAmountfrom100. - Return the final balance.
Walkthrough
The core idea is to use the standard library's rounding function. Math.round(x) in Java rounds a float or double to the nearest long. For values ending in .5, it rounds up, which perfectly matches the problem's requirement. The algorithm is as follows:
- Cast
purchaseAmountto adouble. - Divide the result by
10.0. - Apply
Math.round()to this value. - Multiply the rounded value by
10to getroundedAmount. - Subtract
roundedAmountfrom100to get the final balance.
class Solution { public int accountBalanceAfterPurchase(int purchaseAmount) { double amountAsDouble = (double) purchaseAmount / 10.0; int roundedAmount = (int) Math.round(amountAsDouble) * 10; return 100 - roundedAmount; }}Complexity
Time
O(1) - The number of operations (casting, division, rounding, multiplication, subtraction) is constant and does not depend on the size of `purchaseAmount`.
Space
O(1) - Only a few variables are used for intermediate calculations, so the space used is constant.
Trade-offs
Pros
Leverages a well-known standard library function, making the rounding intention clear to developers familiar with it.
Cons
Introduces floating-point arithmetic, which is generally less efficient than pure integer arithmetic.
Can be prone to precision issues in more complex scenarios, although it's safe for the given constraints.
Slightly more verbose due to the need for type casting.
This approach directly implements the rounding rule described in the problem by examining the last digit of the purchaseAmount. An if-else statement is used to decide whether to round the amount up or down based on its last digit.
Algorithm
- Find the last digit of
purchaseAmountusing the modulo operator (purchaseAmount % 10). - Use an
if-elsecondition to check if the last digit is less than 5. - If it is, round down by finding the multiple of 10 just below or equal to
purchaseAmount. This is calculated as(purchaseAmount / 10) * 10. - If the last digit is 5 or greater, round up by finding the multiple of 10 just above
purchaseAmount. This is calculated as(purchaseAmount / 10 + 1) * 10. - Calculate the final balance by subtracting the
roundedAmountfrom100. - Return the final balance.
Walkthrough
The rounding decision depends on whether the last digit is 5 or more. We can get the last digit using the modulo operator (% 10).
- If the last digit is less than 5, we round down. The
roundedAmountis thepurchaseAmountwith its last digit effectively set to zero. This can be calculated as(purchaseAmount / 10) * 10. - If the last digit is 5 or greater, we round up to the next multiple of 10. This can be calculated as
(purchaseAmount / 10 + 1) * 10.
This logic explicitly separates the two cases, making it very easy to read and understand.
class Solution { public int accountBalanceAfterPurchase(int purchaseAmount) { int remainder = purchaseAmount % 10; int roundedAmount; if (remainder < 5) { roundedAmount = (purchaseAmount / 10) * 10; } else { roundedAmount = (purchaseAmount / 10 + 1) * 10; } return 100 - roundedAmount; }}Complexity
Time
O(1) - The solution involves a fixed number of arithmetic operations and one conditional check, making it constant time.
Space
O(1) - A constant amount of extra space is used for variables like `remainder` and `roundedAmount`.
Trade-offs
Pros
The logic is very explicit and easy to follow, as it directly translates the problem's rules into code.
Uses only integer arithmetic, which is efficient and avoids potential floating-point precision issues.
Cons
Slightly more verbose than a purely mathematical approach due to the conditional block.
This is the most concise and efficient approach. It uses a clever mathematical trick with integer division to perform the required rounding in a single expression, avoiding explicit conditional statements or floating-point math.
Algorithm
- Add 5 to the
purchaseAmount. - Perform integer division of the result by 10. This step effectively gets the tens digit, rounded up if the original last digit was 5 or more.
- Multiply the result by 10 to scale it back, resulting in the
roundedAmount. - Calculate the final balance by subtracting
roundedAmountfrom100. - Return the final balance.
Walkthrough
The standard method for rounding an integer x to the nearest multiple of n (where n/2 rounds up) is to calculate ((x + n/2) / n) * n. In our case, n is 10, so we add 5.
The formula ((purchaseAmount + 5) / 10) * 10 correctly calculates the roundedAmount.
- Why it works (e.g.,
purchaseAmount = 12):(12 + 5) / 10 = 17 / 10 = 1(integer division). Then1 * 10 = 10(rounded down). - Why it works (e.g.,
purchaseAmount = 15):(15 + 5) / 10 = 20 / 10 = 2. Then2 * 10 = 20(rounded up).
This single line of calculation elegantly handles both rounding cases. The final balance is then 100 - roundedAmount.
class Solution { public int accountBalanceAfterPurchase(int purchaseAmount) { int roundedAmount = ((purchaseAmount + 5) / 10) * 10; return 100 - roundedAmount; }}Complexity
Time
O(1) - This is the most performant approach in terms of raw operations, involving only a few simple integer arithmetic calculations.
Space
O(1) - No extra space is needed beyond a variable for the result, making it maximally space-efficient.
Trade-offs
Pros
Extremely concise and elegant.
Highly efficient as it uses only simple integer operations and avoids branching (if-statements).
Cons
The mathematical trick might be less intuitive to someone unfamiliar with it compared to an explicit
if-elsestatement.
Solutions
Solution
class Solution {public int accountBalanceAfterPurchase(int purchaseAmount) { int diff = 100, x = 0; for (int y = 100; y >= 0; y -= 10) { int t = Math.abs(y - purchaseAmount); if (t < diff) { diff = t; x = y; } } return 100 - x; }}class Solution {public: int accountBalanceAfterPurchase(int purchaseAmount) { int diff = 100, x = 0; for (int y = 100; y >= 0; y -= 10) { int t = abs(y - purchaseAmount); if (t < diff) { diff = t; x = y; } } return 100 - x; }};class Solution: def accountBalanceAfterPurchase(self, purchaseAmount: int) -> int: diff, x = 100, 0 for y in range(100, - 1, - 10): if (t: = abs(y - purchaseAmount)) < diff: diff = t x = y return 100 - xVideo walkthrough
Newsletter
One sharp idea, every week
System design and interview prep — short enough to finish.
No spam. Unsubscribe anytime.
Practice
Same difficulty — related problems to reinforce the pattern.