2303-计算应缴税款总额

Raphael Liu Lv10
  2023-09-13 00:47:26 2023-09-13 00:47:26 Created   2023-09-13 16:06:25 2023-09-13 16:06:25 Updated    

给你一个下标从 0 开始的二维整数数组 brackets ，其中 brackets[i] = [upperi, percenti] ，表示第
i 个税级的上限是 upperi ，征收的税率为 percenti 。税级按上限 从低到高排序 （在满足 0 < i < brackets.length 的前提下，upperi-1 < upperi）。

税款计算方式如下：

  • 不超过 upper0 的收入按税率 percent0 缴纳
  • 接着 upper1 - upper0 的部分按税率 percent1 缴纳
  • 然后 upper2 - upper1 的部分按税率 percent2 缴纳
  • 以此类推

给你一个整数 income 表示你的总收入。返回你需要缴纳的税款总额。与标准答案误差不超 10-5 的结果将被视作正确答案。

示例 1：

**输入：** brackets = [[3,50],[7,10],[12,25]], income = 10
**输出：** 2.65000
**解释：**
前 3 的税率为 50% 。需要支付税款 3 * 50% = 1.50 。
接下来 7 - 3 = 4 的税率为 10% 。需要支付税款 4 * 10% = 0.40 。
最后 10 - 7 = 3 的税率为 25% 。需要支付税款 3 * 25% = 0.75 。
需要支付的税款总计 1.50 + 0.40 + 0.75 = 2.65 。

示例 2：

**输入：** brackets = [[1,0],[4,25],[5,50]], income = 2
**输出：** 0.25000
**解释：**
前 1 的税率为 0% 。需要支付税款 1 * 0% = 0 。
剩下 1 的税率为 25% 。需要支付税款 1 * 25% = 0.25 。
需要支付的税款总计 0 + 0.25 = 0.25 。

示例 3：

**输入：** brackets = [[2,50]], income = 0
**输出：** 0.00000
**解释：**
没有收入，无需纳税，需要支付的税款总计 0 。

提示：

  • 1 <= brackets.length <= 100
  • 1 <= upperi <= 1000
  • 0 <= percenti <= 100
  • 0 <= income <= 1000
  • upperi 按递增顺序排列
  • upperi 中的所有值 互不相同
  • 最后一个税级的上限大于等于 income

方法一：直接模拟

思路与算法

设第 i 个税级的上限是 upper}_i ，征收的税率为 percent}i。税级按上限从低到高排序且满足 upper}{i-1} < \textit{upper}_i。

根据题意税款计算方式如下：

  • 不超过 upper}_0 的收入按税率 percent}_0 缴纳；
  • 接着处于 [\textit{upper}_0,\textit{upper}_1] 的部分按税率 percent}_1 缴纳；
  • 接着处于 [\textit{upper}_1,\textit{upper}_2] 的部分按税率 percent}_2 缴纳；
  • 以此类推；

给定的 income 表示总收入，依次计算 income 处于第 i 个区间 [\textit{upper}_{i-1},\textit{upper}_i] 之间的部分为 pay}_i，此时计算公式为 pay}_i = \min(\textit{income},\textit{upper}i) - \textit{upper}{i-1，则在第 i 个征税区间缴纳的税为 tax}_i = \textit{pay}_i \times \textit{percent}i，则征税总额为 totalTax} = \sum\limits{i=0}^{n-1}\textit{tax}_i。

其中第 0 个征税区间为 [0,\textit{upper}_i]，为了计算方便可先进行整数累加，最后再进行浮点数除法计算。

代码

[sol1-Python3]
1
2
3
4
5
6
7
8
9
10
class Solution:
    def calculateTax(self, brackets: List[List[int]], income: int) -> float:
        totalTax = lower = 0
        for upper, percent in brackets:
            tax = (min(income, upper) - lower) * percent
            totalTax += tax
            if income <= upper:
                break
            lower = upper
        return totalTax / 100
[sol1-C++]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution {
public:
    double calculateTax(vector<vector<int>>& brackets, int income) {
        double totalTax = 0;
        int lower = 0;
        for (auto &bracket: brackets) {
            int upper = bracket[0], percent = bracket[1];
            int tax = (min(income, upper) - lower) * percent;
            totalTax += tax;
            if (income <= upper) {
                break;
            }
            lower = upper;
        }
        return (double)totalTax / 100.0;
    }
};
[sol1-Java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution {
    public double calculateTax(int[][] brackets, int income) {
        double totalTax = 0;
        int lower = 0;
        for (int[] bracket : brackets) {
            int upper = bracket[0], percent = bracket[1];
            int tax = (Math.min(income, upper) - lower) * percent;
            totalTax += tax;
            if (income <= upper) {
                break;
            }
            lower = upper;
        }
        return (double) totalTax / 100.0;
    }
}
[sol1-C#]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Solution {
    public double CalculateTax(int[][] brackets, int income) {
        double totalTax = 0;
        int lower = 0;
        foreach (int[] bracket in brackets) {
            int upper = bracket[0], percent = bracket[1];
            int tax = (Math.Min(income, upper) - lower) * percent;
            totalTax += tax;
            if (income <= upper) {
                break;
            }
            lower = upper;
        }
        return (double) totalTax / 100.0;
    }
}
[sol1-C]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#define MIN(a, b) ((a) < (b) ? (a) : (b))

double calculateTax(int** brackets, int bracketsSize, int* bracketsColSize, int income) {
    int totalTax = 0, lower = 0;
    for (int i = 0; i < bracketsSize; i++) {
        int upper = brackets[i][0], percent = brackets[i][1];
        int tax = (MIN(income, upper) - lower) * percent;
        totalTax += tax;
        if (income <= upper) {
            break;
        }
        lower = upper;
    }
    return (double) totalTax / 100.0;
}
[sol1-JavaScript]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
var calculateTax = function(brackets, income) {
    let totalTax = 0;
    let lower = 0;
    for (const bracket of brackets) {
        const upper = bracket[0], percent = bracket[1];
        const tax = (Math.min(income, upper) - lower) * percent;
        totalTax += tax;
        if (income <= upper) {
            break;
        }
        lower = upper;
    }
    return totalTax / 100.0;
};
[sol1-Golang]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
func calculateTax(brackets [][]int, income int) float64 {
    totalTax := 0
    lower := 0
    for _, bracket := range brackets {
        upper, percent := bracket[0], bracket[1]
        tax := (min(income, upper) - lower) * percent
        totalTax += tax
        if income <= upper {
            break
        }
        lower = upper
    }
    return float64(totalTax) / 100
}

func min(a, b int) int {
    if a > b {
        return b
    }
    return a
}

复杂度分析

  • 时间复杂度：O(n)，其中 n 表示数组的长度。我们只需要遍历一遍数组即可。

  • 空间复杂度：O(1)。

 Comments
On this page
2303-计算应缴税款总额