Ada beberapa masalah kalkulator tarif pajak di sini yang bergantung pada kurs yang ditentukan (khususnya tarif federal AS), tetapi tidak ada yang melakukannya untuk daftar arbitrer.

Tugas Anda adalah untuk membangun program atau fungsi yang akan mengambil daftar kurung pajak marginal yang sewenang-wenang dan menghitung jumlah pajak efektif yang dibayarkan atas jumlah tertentu dari penghasilan kena pajak.

Program Anda akan menerima sebagai masukan:

• Npasang angka dalam formulir (amt, rate), masing-masing mewakili braket pajak.

  • amtadalah jumlah penghasilan kena pajak yang di atasnya tarif pajak mulai berlaku. Jumlah ini semua akan menjadi bilangan bulat, dan muncul dalam urutan yang meningkat.

  • rate adalah tarif pajak, yang dinyatakan sebagai persentase desimal dari 0 hingga 100 inklusif.

• Jumlah penghasilan kena pajak, sebagai bilangan bulat negatif

Jika tidak ada kurs yang ditentukan untuk $ 0, kurs tersebut diasumsikan 0%.

Atau, program Anda juga dapat mengambil dua daftar sebagai input (amt1, amt2, ...)dan (rate1, rate2, ...), berisi jumlah dan tarif dalam urutan yang sama.

Program Anda kemudian akan menampilkan hutang pajak, baik untuk dua tempat desimal, atau bulat turun ke unit mata uang seluruh terdekat.

Input contoh (tanda kurung pajak Kanada terbaru, dari 2016, dengan kredit pajak pribadi dasar diterapkan dan tidak ada yang lain):

11474 15
45282 20.5
90563 26
140388 29
200000 33

393216

Dan output yang sesuai:

108357.07  or  108357

Program terpendek dalam bahasa apa pun untuk melakukan ini akan menang.

05AB1E, 35 24 byte

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

Penjelasan

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

Cobalah online

Haskell, 67 66 byte

Terima kasih Damien untuk -1 byte.

Solusi ini dalam bentuk fungsi infix ?, tipe (Integral b, RealFrac r) => [(r, r)] -> r -> b. Fungsi helper #,, melakukan perhitungan yang diperlukan sambil ?berfungsi untuk menangani spesifikasi IO.

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

Mathematica 85 82 byte

Berasal dari kode Josh O'Brien di R.

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

Pemakaian

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

108357

Matlab, 79 byte

Dengan asumsi kita dapat mengambil amtdan ratesebagai vektor kolom terpisah:

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

Jika kita tidak bisa (maka itu aadalah matriks dua kolom amtdan rate) 87 byte.

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

Penjelasan:

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

aadalah array array band dan rate, yang akan menjadi [[11474, 15], [45282, 20.5], [90563, 26], [140388, 29], [200000, 33]]contoh yang diberikan, dan nmerupakan penghasilan ( 393216).

Swift, 61 byte

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

Tidak disatukan, dengan kasus uji:

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)