Welcome to Subscribe On Youtube
2303. Calculate Amount Paid in Taxes
Description
You are given a 0indexed 2D integer array brackets
where brackets[i] = [upper_{i}, percent_{i}]
means that the i^{th}
tax bracket has an upper bound of upper_{i}
and is taxed at a rate of percent_{i}
. The brackets are sorted by upper bound (i.e. upper_{i1} < upper_{i}
for 0 < i < brackets.length
).
Tax is calculated as follows:
 The first
upper_{0}
dollars earned are taxed at a rate ofpercent_{0}
.  The next
upper_{1}  upper_{0}
dollars earned are taxed at a rate ofpercent_{1}
.  The next
upper_{2}  upper_{1}
dollars earned are taxed at a rate ofpercent_{2}
.  And so on.
You are given an integer income
representing the amount of money you earned. Return the amount of money that you have to pay in taxes. Answers within 10^{5}
of the actual answer will be accepted.
Example 1:
Input: brackets = [[3,50],[7,10],[12,25]], income = 10 Output: 2.65000 Explanation: Based on your income, you have 3 dollars in the 1^{st} tax bracket, 4 dollars in the 2^{nd} tax bracket, and 3 dollars in the 3^{rd} tax bracket. The tax rate for the three tax brackets is 50%, 10%, and 25%, respectively. In total, you pay 3 * 50% + 4 * 10% + 3 * 25% = 2.65 in taxes.
Example 2:
Input: brackets = [[1,0],[4,25],[5,50]], income = 2 Output: 0.25000 Explanation: Based on your income, you have 1 dollar in the 1^{st} tax bracket and 1 dollar in the 2^{nd} tax bracket. The tax rate for the two tax brackets is 0% and 25%, respectively. In total, you pay 1 * 0% + 1 * 25% = 0.25 in taxes.
Example 3:
Input: brackets = [[2,50]], income = 0 Output: 0.00000 Explanation: You have no income to tax, so you have to pay a total of 0 in taxes.
Constraints:
1 <= brackets.length <= 100
1 <= upper_{i} <= 1000
0 <= percent_{i} <= 100
0 <= income <= 1000
upper_{i}
is sorted in ascending order. All the values of
upper_{i}
are unique.  The upper bound of the last tax bracket is greater than or equal to
income
.
Solutions
Solution 1: Simulation
We traverse brackets
, and for each tax bracket, we calculate the tax amount for that bracket, then accumulate it.
The time complexity is $O(n)$, where $n$ is the length of brackets
. The space complexity is $O(1)$.

class Solution { public double calculateTax(int[][] brackets, int income) { int ans = 0, prev = 0; for (var e : brackets) { int upper = e[0], percent = e[1]; ans += Math.max(0, Math.min(income, upper)  prev) * percent; prev = upper; } return ans / 100.0; } }

class Solution { public: double calculateTax(vector<vector<int>>& brackets, int income) { int ans = 0, prev = 0; for (auto& e : brackets) { int upper = e[0], percent = e[1]; ans += max(0, min(income, upper)  prev) * percent; prev = upper; } return ans / 100.0; } };

class Solution: def calculateTax(self, brackets: List[List[int]], income: int) > float: ans = prev = 0 for upper, percent in brackets: ans += max(0, min(income, upper)  prev) * percent prev = upper return ans / 100

func calculateTax(brackets [][]int, income int) float64 { var ans, prev int for _, e := range brackets { upper, percent := e[0], e[1] ans += max(0, min(income, upper)prev) * percent prev = upper } return float64(ans) / 100.0 }

function calculateTax(brackets: number[][], income: number): number { let ans = 0; let prev = 0; for (const [upper, percent] of brackets) { ans += Math.max(0, Math.min(income, upper)  prev) * percent; prev = upper; } return ans / 100; }

impl Solution { pub fn calculate_tax(brackets: Vec<Vec<i32>>, income: i32) > f64 { let mut res = 0f64; let mut pre = 0i32; for bracket in brackets.iter() { res += f64::from(income.min(bracket[0])  pre) * f64::from(bracket[1]) * 0.01; if income <= bracket[0] { break; } pre = bracket[0]; } res } }