Đã có một số vấn đề về máy tính thuế suất ở đây phụ thuộc vào tỷ lệ xác định (cụ thể là thuế suất liên bang Hoa Kỳ), nhưng không có vấn đề nào được thực hiện cho các danh sách tùy ý.

Nhiệm vụ của bạn là xây dựng một chương trình hoặc chức năng sẽ lấy một danh sách tùy ý các khung thuế cận biên và tính toán số tiền thuế có hiệu lực được trả cho một khoản thu nhập chịu thuế nhất định.

Chương trình của bạn sẽ lấy làm đầu vào:

• Ncác cặp số trong mẫu (amt, rate), mỗi số đại diện cho một khung thuế.

  • amtlà mức thu nhập chịu thuế mà trên đó mức thuế suất bắt đầu được áp dụng. Tất cả số tiền này sẽ là số nguyên và xuất hiện theo thứ tự tăng dần.

  • rate là thuế suất, được biểu thị dưới dạng phần trăm thập phân từ 0 đến 100.

• Số tiền thu nhập chịu thuế, như một số nguyên không âm.

Nếu không có tỷ lệ nào được chỉ định cho $ 0, tỷ lệ được giả định là 0%.

Ngoài ra, chương trình của bạn cũng có thể lấy làm hai danh sách đầu vào (amt1, amt2, ...)và (rate1, rate2, ...), chứa số lượng và tỷ lệ theo cùng một thứ tự.

Chương trình của bạn sau đó sẽ xuất thuế phải nộp, thành hai chữ số thập phân hoặc làm tròn xuống toàn bộ đơn vị tiền tệ gần nhất.

Một ví dụ đầu vào (khung thuế gần đây nhất của Canada, từ năm 2016, với tín dụng thuế cá nhân cơ bản được áp dụng và không có gì khác):

11474 15
45282 20.5
90563 26
140388 29
200000 33

393216

Và đầu ra tương ứng của nó:

108357.07  or  108357

Chương trình ngắn nhất trong bất kỳ ngôn ngữ nào để làm điều này chiến thắng.

05AB1E, 35 24 byte

vy³ï‚{0è)˜}³ï‚˜¥²ø€PTn/O

Giải trình

vy                         # for each amount
  ³ï‚                      # pair with taxable income
     {0è                   # get min
        )˜}                # add to list
           ³ï‚˜            # add income to the end of the list
               ¥           # get deltas
                ²ø         # zip with tax rates
                  €P       # map product on each pair of [amount in tax bracket,rate]
                    Tn/    # divide by 100
                       O   # sum
                           # implicitly display result

Dùng thử trực tuyến

Haskell, 67 66 byte

Cảm ơn Damien cho -1 byte.

Giải pháp này ở dạng hàm infix ?, loại (Integral b, RealFrac r) => [(r, r)] -> r -> b. Hàm trợ giúp #, thực hiện các tính toán cần thiết trong khi ?phục vụ để xử lý các thông số kỹ thuật IO.

a?b=floor$reverse a#b
((m,p):r)#i|v<-min i m=p/100*(i-v)+r#v
_#_=0

Toán học 85 82 byte

Bắt nguồn từ mã của Josh O'Brien trong R.

d_~f~i_:=Tr@Thread[Differences@((i~Min~#&/@d[[All,1]]~Append~∞))d[[All,2]]/100.]

Sử dụng

f[{{11474, 15}, {45282, 20.5}, {90563, 26}, {140388, 29}, {200000, 33}}, 393216]

108357.

Matlab, 79 byte

Giả sử chúng ta có thể lấy amtvà ratelàm các vectơ cột riêng biệt:

function[]=f(a,b,c)
t=sort([0;a;c]);fix(sum(diff(t).*[0;b/100].*(t(2:end)<=c)))

Nếu chúng ta không thể (thì đó alà ma trận hai cột amtvà rate), đó là 87 byte.

function[]=f(a,c)
t=sort([0;a(:,1);c]);fix(sum(diff(t).*[0;a(:,2)/100].*(t(2:end)<=c)))

Giải trình:

f(a,b,c)           -- takes amt, rate and income
[0;a;c]            -- gives a vector of amounts with 0 and the income amount
t=sort(...)        -- sort this vector
diff(t)            -- gives us amounts to be taxed in every bracket
diff(t).*[0;b/100] -- tax in every bracket
.*(t(2:end)<=c)    -- take only entries lower than the income
sum(...)           -- sum everything
fix(...)           -- round towards 0

JavaScript (ES6), 60 byte

(a,n)=>a.map(([b,r])=>{t+=n>b&&(n-b)*(r-p);p=r},p=t=0)|t/100

alà một mảng các dải của dải và tỷ lệ, sẽ là [[11474, 15], [45282, 20.5], [90563, 26], [140388, 29], [200000, 33]]ví dụ đã cho và nlà thu nhập ( 393216).

Swift, 61 byte

zip(zip(m+[i],[0]+m).map{$0-$1},[0]+r).map{$0*$1}.reduce(0,+)

Ungolfed, với các trường hợp thử nghiệm:

struct TaxContext {
    let marginLowerBound: [Double]
    let rates: [Double]
}

// ungolfed
extension TaxContext {
    func calcAfterTaxIncome(_ income: Double) -> Double {
        //drop first element (0), append income
        let upper = marginLowerBound + [income]
        let lower = [0] + marginLowerBound

        let incomeInEachMargin = zip(upper, lower)
            .map{ upperBound, lowerBound in upperBound - lowerBound }

        let taxInEachMargin = zip(incomeInEachMargin, [0]+rates)
            .map{ incomeInMargin, rate in incomeInMargin * rate }

        let totalTax = taxInEachMargin.reduce(0, +)

        print(upper)
        print(lower)
        print(incomeInEachMargin)
        print(rates)
        print(taxInEachMargin)

        return totalTax    
    }
}

// golfed
extension TaxContext {
    // computed properties to serve as aliases for the golfed version
    var m: [Double] { return self.marginLowerBound }
    var r: [Double] { return self.rates }

    func f(_ i: Double) -> Double {
        return zip(zip(m+[i],[0]+m).map{$0-$1},[0]+r).map{$0*$1}.reduce(0,+)
    }
}

let testCase1 = TaxContext(
    marginLowerBound: [10_000, 20_000, 30_000],
    rates: [0.1, 0.2, 0.3, 0.4]
)
let result1 = testCase1.calcAfterTaxIncome(70_000)
print(result1)


let testCase2 = TaxContext(
    marginLowerBound: [11474 , 45282, 90563, 140388, 200000],
    rates: [0.15, 0.205, 0.26, 0.29, 0.33]
)
let result2 = testCase2.calcAfterTaxIncome(393216)
print(result2)