Fred ist ein quasi freundlicher Typ, aber in Wirklichkeit ist er gemein.

Aus diesem Grund lebt Fred alleine in einer kleinen Wohnung in Los Altos, CA. Fred ist so gemein, weil er sich sehr für Wasser interessiert. Er braucht daher Ihre Hilfe, um herauszufinden, wie hoch seine Wasserrechnung ist.

Ihre Aufgabe ist es, eine Funktion oder ein Programm zu schreiben, die / das seine Wasserrechnung unter Berücksichtigung der als Eingabe verwendeten Wassermenge zurückgibt (die immer eine ganze Zahl ist).

Der Wasserverbrauch erfolgt in Stufen. Dies bedeutet, dass es je nach Wassermenge Preisspannen gibt.

Dies sind die Ebenen, ihre Preise und die Wassermengen, denen sie entsprechen:

Tier I
   First 10 Ccf: $3.8476/Ccf
Tier II
   Next 17 Ccf: $4.0932/Ccf
Tier III
   All subsequent water: $4.9118/Ccf

Für n Hunderte Kubikfuß (Ccf) fallen außerdem die folgenden zusätzlichen Gebühren an:

CPUC fee: 1.5% of above charges
LIRA quantity surcharge: $0.047*n
PBOP amoritization surcharge: $0.004*n

Die Summe der Gebühren für Tier I, Tier II, Tier III, CPUC, LIRA und PBOP ergibt die gesamte Wasserrechnung. Diese Summe sollten Sie entweder zurückgeben oder auf die Konsole drucken, auf zwei Dezimalstellen gerundet.

Hier sind zwei Beispiele:

Input: 15
... Calculations which you do not need to output but here to help explain:
Tier I: 10*3.8476 = 38.476
Tier II: (15-10)*4.0932 = 20.466
Tier III: 0*4.9118 = 0
Tiers sum: 58.942
CPUC: 1.5% of 58.942 = 0.88413
LIRA: 0.047*15 = 0.705
PBOP: 0.004*15 = 0.06
Total sum: 58.942 + 0.88413 + 0.705 + 0.06 = 60.59113
...
Output: 60.59

Input: 100
... Calculations which you do not need to output but here to help explain:
Tier I: 10*3.8476 = 38.476
Tier II: 17*4.0932 = 69.5844
Tier III: (100-10-17)*4.9118 = 358.5614
Tiers sum: 466.6218
CPUC: 1.5% of  = 6.999327
LIRA: 0.047*100 = 4.7
PBOP: 0.004*100 = 0.4
Total sum: 478.721127
...
Output: 478.72

Dies ist Code Golf, also gewinnt der kürzeste Code in Bytes!

Pyth, 55 41 Bytes

.R+s*Vv.",9t¬®Ï0NwÝ"lMcUQ,T27*.051Q2

Der Code enthält nicht druckbare Zeichen. Hier ist also ein xxdHexdump.

00000000: 2e52 2b73 2a56 762e 222c 3904 1874 c2ac  .R+s*Vv.",9..t..
00000010: c2ae c280 c293 c38f 301c 4e77 c39d 226c  ........0.Nw.."l
00000020: 4d63 5551 2c54 3237 2a2e 3035 3151 32    McUQ,T27*.051Q2

Erläuterung

1. ."…"ist eine gepackte Zeichenfolge, die enthält 3.8476,4.0932,4.9118.
2. vwertet das zum Tupel aus (3.8476, 4.0932, 4.9118). Dies sind die Preise der Stufen multipliziert mit der hinzugefügten CPUC.
3. UQerzeugt den Bereich 0… n-1.
4. c… ,T27Teilt diesen Bereich bei den Indizes 10 und 27 mit zusätzlichen leeren Listen am Ende auf, wenn der Bereich zu kurz ist.
5. lM ermittelt die Länge jedes Teils und gibt die Wassermenge für jede Stufe an.
6. *V multipliziert dies mit dem Tupel aus Schritt 2, um die Preise für die Ebenen zu erhalten.
7. s summiert die Ergebnisse.
8. +… *Q.051Addiert die Eingabe multipliziert mit 0,051, dh LIRA + PBOP.
9. .R… 2Rundet das Ergebnis auf 2 Dezimalstellen.

Probieren Sie es online aus.

Mathematica, 83 76 69 Bytes

1.015{3.8476,.2456(b=Boole)[#>10],.8186b[#>27],51/1015}&~Array~#~Total~2~Round~.01&

Anonyme Funktion, die ein Array der drei Ebenen in der ersten Spalte plus LIRA und PBOP erstellt, die in der vierten Spalte als Zahl mit beliebiger Genauigkeit dargestellt werden. Das Ganze wird mit multipliziert 1.015und alle Elemente des Arrays werden summiert und gerundet .01. Da 51/1015*1.015dies gewünscht wird, ist 0.051die Ausgabe genau so genau wie die Spezifikation in OP.

Eine kürzere Lösung in 76 Bytes , wie ich in meinem Kommentar unter der Perl-Lösung vorgeschlagen habe

{3.956314,.249284(b=Boole)[#>10],.830879b[#>27]}&~Array~#~Total~2~Round~.01&

Dabei 1.015wird von Anfang an in die Preise einbezogen, und dann werden LIRA und PBOP über der ersten Stufe hinzugefügt.

73 Bytes (aber ich zögere es, meine Byteanzahl zu aktualisieren, da dies der einfachen Perl-Lösung ziemlich nahe kommt):

69 Bytes - ah was zum Teufel, das Golfen hat auch einige Mühe gekostet.

.01Round[395.6314#+{24.9284,83.0879}.(UnitStep[#-1]#&/@{#-10,#-27})]&

BEARBEITEN bezüglich Gleitkommafehlers
Die ersten drei Iterationen meiner Antwort sind in ihrer Dezimaldarstellung tatsächlich genau, da alle beteiligten Koeffizienten abschließende Dezimaldarstellungen haben. Da es sich bei den Koeffizienten jedoch explizit um Gleitkommazahlen handelt, die binär gespeichert sind und nicht terminierende binäre Darstellungen aufweisen, beginnen ausreichend große Eingaben, Fehler in den niedrigstwertigen Ziffern der binären Darstellung zu akkumulieren. Ich würde vermuten, wenn der Gleitkomma so groß ist, dass er nur 3-4 Stellen rechts vom Dezimalpunkt passt, können wir Fehler von etwa 1 Cent erwarten. Eine genaue Antwort finden Sie weiter unten .

72 Bytes, etwas immun gegen Schwebeungenauigkeiten

.01Round[{3956314,249284,830879}.(UnitStep[#-1]#&)/@(#-{0,10,27})/10^4]&

Die Multiplikation mit der Führung .01erfolgt im allerletzten Schritt. Bis zu diesem Zeitpunkt werden alle Berechnungen mit ganzen Zahlen durchgeführt. Dies bedeutet, dass, wenn das .01weggelassen wird, ein genaues Ergebnis erzielt wird , das jedoch in Cent und nicht in Dollar ausgedrückt wird. Natürlich wandelt die Multiplikation mit einem Float das Ganze in einen Float um, und wie bereits erwähnt, muss es klein genug sein, um in 64 Bit zu passen und trotzdem genau zu sein .01.

05AB1E, 64 58 51 Bytes

0T27¹)vy¹‚ï{0è})¥•_ÄÄ™wu24@•2'.:7ô)ø€PO¹"5.1"*+ïTn/

Erklärt

0T27¹)                                               # list of price brackets
      vy¹‚ï{0è})                                     # min of each with input
                ¥                                    # calculate deltas to get amounts within each bracket
                 •_ÄÄ™wu24@•2'.:7ô                   # list of price rates with CPUC included
                                  )ø                 # zip with amounts for each rate
                                    €PO              # multiply amounts by their rates and sum
                                       ¹"5.1"*+      # add LIRA/PBOP
                                               ïTn/  # round to 2 decimals

Probieren Sie es online aus

Perl 5, 73 Bytes

Die offensichtliche Lösung. 72 Bytes plus 1 für -nestatt -e.

printf'%.2f',$_*3.956314+($_-10)*($_>10)*.249284+($_-27)*($_>27)*.830879

5 Bytes dank LLlAMnYP gespeichert . Vielen Dank!

Oracle SQL 11.2, 151 Bytes

SELECT ((DECODE(SIGN(:1-10),1,10,:1)*3.8476)+(DECODE(SIGN(:1-27),1,17,:1-10)*4.0932)+(DECODE(SIGN(:1-27),-1,0,:1-27)*4.9118))*1.015+:1*0.051 FROM DUAL;

Nicht Golf gespielt

SELECT ((DECODE(SIGN(:1-10),1,10,:1)*3.8476)+
       (DECODE(SIGN(:1-27),1,17,:1-10)*4.0932)+
       (DECODE(SIGN(:1-27),-1,0,:1-27)*4.9118))*1.015+
       :1*0.051
FROM DUAL

JavaScript ES6, 77 Bytes

x=>(x>27?(x-27)*4.985477+109.681:(x>10?(x-10)*4.1546+39.053:x*3.9053))+.051*x

Nicht Golf gespielt

f = x => {
  if (x > 27) {
    res = (x - 27) * 4.985477 + 109.681306
  } else if (x > 10) {
    res = (x - 10) * 4.154598 + 39.05314
  } else {
    res = x * 3.905314
  }
  return res + 0.051 * x
}

Ich habe die LIRA- und PBOP-Koeffizienten berücksichtigt. Die zusätzlichen 1,5% werden am Ende hinzugefügt.

Wahrscheinlich nicht die effizienteste Lösung in Bezug auf Golf, aber etwas anders als die von Perl.

Gleitkommafehler sollten bei größeren Zahlen auftreten und können durch Hinzufügen von 1 oder 2 zusätzlichen Bytes zu jedem Koeffizienten behoben werden.

f=x=>(x>27?(x-27)*4.985477+109.681:(x>10?(x-10)*4.1546+39.053:x*3.9053))+.051*x

console.log(f(15))
console.log(f(100))
console.log(f(200000))

R , 52 Bytes

approxfun(c(0,10,27,10^6),c(0,39.56,111.06,5036475))

Probieren Sie es online aus!

Erzeugt eine lineare Approximationsfunktion basierend auf den Werten meiner vorherigen Antwort bei 0,10,27 und 10 ^ 6. Der Haken: Die Obergrenze für den Eingang liegt bei 10 ^ 6.

approxfun(mit ecdf, stepfun, splinefun, etc.) ist einer der vielen schönen Eigenschaften R.

VBA, 88 Bytes

Function W(V):W=Round(.051*V+.203*(V*19.238-(V-10)*(V>10)*1.228-(V-27)*(V>27)*4.093),2)
 

Der Basiszinssatz und die Differenzsätze für die höhere Nutzung wurden mit 5 multipliziert und der CPUC-Gebührenmultiplikator durch 5 (0,203) geteilt.

Der VB-Editor fügt eine End FunctionZeile hinzu, weshalb der Terminal-Zeilenvorschub enthalten ist.

Pyth - 58 51 Bytes

.Rs+*Bs*V++m3.8476Tm4.0932 17m4.9118Qm1Q.015*.051Q2

Testsuite .