Es gab hier einige Probleme mit dem Steuersatzrechner, die von definierten Sätzen abhängen (insbesondere US-Bundessteuersätze), aber keine, die dies für willkürliche Listen getan haben.

Ihre Aufgabe ist es, ein Programm oder eine Funktion zu erstellen, die eine willkürliche Liste von Grenzsteuerklassen verwendet und den effektiven Steuerbetrag berechnet, der auf einen bestimmten Betrag des zu versteuernden Einkommens gezahlt wird.

Ihr Programm nimmt als Eingabe:

• NZahlenpaare im Formular (amt, rate), die jeweils eine Steuerklasse darstellen.

  • amtist die Höhe des zu versteuernden Einkommens, ab der der Steuersatz zu gelten beginnt. Diese Beträge sind alle Ganzzahlen und werden in aufsteigender Reihenfolge angezeigt.

  • rate ist der Steuersatz, ausgedrückt als Dezimalprozentsatz von 0 bis einschließlich 100.

• Die Höhe des steuerpflichtigen Einkommens als nicht negative ganze Zahl.

Wenn für 0 USD keine Rate angegeben ist, wird eine Rate von 0% angenommen.

Alternativ können Sie Ihr Programm nehmen als Eingabe auch zwei Listen (amt1, amt2, ...)und (rate1, rate2, ...), die Mengen und Preise in der gleichen Reihenfolge enthalten.

Ihr Programm wird dann ausgegeben die zu zahlende Steuer entweder auf zwei Dezimalstellen oder abgerundet nach unten auf die nächste ganze Währungseinheit.

Ein Beispiel für eine Eingabe (die neuesten kanadischen Steuerklassen aus dem Jahr 2016 mit der grundlegenden persönlichen Steuergutschrift und nichts anderem):

11474 15
45282 20.5
90563 26
140388 29
200000 33

393216

Und die entsprechende Ausgabe:

108357.07  or  108357

Das kürzeste Programm in einer Sprache, um dies zu tun, gewinnt.

05AB1E, 35 24 Bytes

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

Erläuterung

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

Probieren Sie es online aus

Haskell, 67 66 Bytes

Danke Damien für -1 Byte.

Diese Lösung liegt in Form einer Infixfunktion ?vom Typ vor (Integral b, RealFrac r) => [(r, r)] -> r -> b. Die Hilfsfunktion #führt die erforderlichen Berechnungen durch und ?dient gleichzeitig zur Verarbeitung der E / A-Spezifikationen.

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

Mathematica 85 82 Bytes

Abgeleitet von Josh O'Briens Code in R.

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

Verwendungszweck

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

108357.

Matlab, 79 Bytes

Angenommen, wir können amtund rateals separate Spaltenvektoren:

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

Wenn wir nicht können (dann aist eine zweispaltige Matrix von amtund rate), sind es 87 Bytes.

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

Erläuterung:

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

aist ein Array von Arrays aus Band und Rate, die [[11474, 15], [45282, 20.5], [90563, 26], [140388, 29], [200000, 33]]für das gegebene Beispiel gelten würden, und nist das Einkommen ( 393216).

Schnell, 61 Bytes

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

Ungolfed, mit Testfällen:

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)