Gringotts ist nicht nur ein Tresor, sondern auch ein angesehenes Finanzinstitut und Zauberer benötigen Kredite. Da Sie nicht von den Gringotts-Goblins verarscht werden möchten, haben Sie beschlossen, ein Programm zur Zinsberechnung zu schreiben. Die Zinsen werden nur jährlich berechnet.

Ihre Aufgabe ist es, den geschuldeten Gesamtbetrag nach Zinsen unter Berücksichtigung des Kapitals, des Zinssatzes und der Zeit (ganze Jahre) zu berechnen und dabei auf den nächsten ganzen Knut abzurunden. Es gibt 29 Bronzeknoten in einer Silbernen Sichel und 17 Sicheln in einer Goldenen Galeone.

Beispiel

Loan taken out:
 23 Knuts
 16 Sickles
103 Galleons
@ 7.250%
For 3 years

Total owed after interest:
 24 Knuts
  4 Sickles
128 Galleons

Notizen und Regeln

• Die Ein- und Ausgabe kann in jedem beliebigen Format erfolgen. Sie müssen Knuts, Sicheln, Galeonen, Zinssatz und Zeit berücksichtigen. Alle außer dem Zinssatz sind ganze Zahlen. Der Zinssatz wird in Schritten von 0,125% angegeben.
• Es wird nicht garantiert, dass das eingegebene Geld kanonisch ist (dh Sie können 29 oder mehr Knuts und 17 oder mehr Sicheln haben.)
• Die Ausgabe muss die kanonische Darstellung sein. (dh weniger als 29 Knuts und weniger als 17 Sicheln)
• Geschuldete Summen von bis zu 1.000 Galeonen sollten im Vergleich zu willkürlichen Präzisionsberechnungen auf 1 Knut pro Jahr genau sein.
  • Sie können nach jedem Jahr des Interesses oder nur am Ende abrunden. Referenzberechnungen können dies für Genauigkeitsprüfungen berücksichtigen.

Viel Spaß beim Golfen!

R , 70 62 Bytes

function(d,i,y)(x=d%*%(a=c(1,29,493))*(1+i)^y)%/%a%%c(29,17,x)

Probieren Sie es online!

Nimmt Eingabe als d: Einzahlung in Knuts, Sicheln, Galeonen; i: Zinssatz als Dezimalzahl; y: Jahre. Endgültige Einzahlung in Knuts, Sicheln, Galeonen. Vielen Dank an @ Giuseppe für die Verwendung der Matrixmultiplikation, um einige Bytes zu sparen (und für den Hinweis, dass kein Zeilenumbruch bei 1e99 erforderlich ist).

Python 3.8 (Vorabversion) , 75 74 71 Byte

-1 Bytes dank @EmbodimentofIgnorance
-3 Bytes dank @xnor

Dies nimmt Knuts, Sickles und Galleons als Ints, Interesse als Float (dezimal, nicht prozentual) und Jahre als Int. Es wird ein Tupel zurückgegeben, das die Nummer nach Interesse von Knuts, Sickles bzw. Galleons enthält.

lambda K,S,G,R,Y:((k:=int((K+G*493+S*29)*(1+R)**Y))%29,k//29%17,k//493)

Verwendung:

>>> print(I(23,16,103,0.0725,3))
(24, 4, 128)

Probieren Sie es online!

APL + WIN, 37 28 26 Bytes

⌊a⊤((a←0 17 29)⊥⎕)×(1+⎕)*⎕

2 Bytes gespart dank Lirtosiast

Probieren Sie es online! Mit freundlicher Genehmigung von Dyalog Classic

Erläuterung:

(1+⎕)*⎕ prompts for years followed by decimal interest rate and calculates
         compounding multiplier

((a←0 17 29)⊥⎕) prompts for Galleons, Sickles and Knuts and converts to Knuts

⌊a⊤ converts back to Galleons, Sickles and Knuts and floor 
    after applying compound interest. 

Perl 6 , 47 Bytes

((1+*)*** *(*Z*1,29,493).sum+|0).polymod(29,17)

Probieren Sie es online!

Ich bin überrascht, dass ich es geschafft habe, einen anonymen Whatever Lambda zu erstellen! Besonders der Teil, wo es mehr ist *als alles andere. Übernimmt die Eingabe als interest rate (e.g. 0.0725), years, [Knuts, Sickles, Galleons]und gibt eine Liste der Währungen in derselben Reihenfolge zurück.

Erläuterung:

 (1+*)           # Add one to the interest rate
      ***        # Raise to the power of the year
          *      # And multiply by
           (*Z*1,29,493).sum      # The number of Knuts in the input
                            +|0   # And floor it
(                              ).polymod(29,17)   # Get the modulos after divmoding by 29 and 17

Gelee , 29 Bytes

“¢×ø‘©×\
÷ȷ2‘*⁵×÷¢S×¢d®U1¦Ṫ€Ḟ

Ein volles Programm zu akzeptieren Argumente rate; [Galleons, Sickles, Knuts]; years.
Druckt [Galleons, Sickles, Knuts].

Probieren Sie es online!

Fußböden am Ende der gesamten Laufzeit.
÷ȷ2kann entfernt werden, wenn wir den Satz eher als Verhältnis als als Prozentsatz akzeptieren.

Wie?

“¢×ø‘©×\ - Link 1 multipliers: no arguments
“¢×ø‘    - list of code-age indices = [1,17,29]
     ©   - (copy this to the register for later use)
       \ - reduce by:
      ×  -   multiplication  = [1,17,493]

÷ȷ2‘*⁵×÷¢S×¢d®U1¦Ṫ€Ḟ - Main Link
 ȷ2                  - 10^2 = 100
÷                    - divide = rate/100
   ‘                 - increment = 1+rate/100
     ⁵               - 5th command line argument (3rd input) = years
    *                - exponentiate = (1+rate/100)^years --i.e. multiplicand
      ×              - multiply (by the borrowed amounts)
        ¢            - call last Link as a nilad
       ÷             - divide (all amounts in Galleons)
         S           - sum (total Galleons owed)
           ¢         - call last Link as a nilad
          ×          - multiply (total owed in each of Galleons, Sickles, Knuts)
             ®       - recall from register = [1,17,29]
            d        - divmod (vectorises) = [[G/1, G%1], [S/17, S^17], [K/17, K%17]]
              U1¦    - reverse first one = [[G%1, G/1], [S/17, S%17], [K/17, K%17]]
                 Ṫ€  - tail €ach = [G/1, S%17, K%17]
                   Ḟ - floor (vectorises)

Intel 8087 FPU-Assembly, 86 Byte

d9e8 d906 7f01 dec1 8b0e 8301 d9e8 d8c9 e2fc df06 7901 df06 8701 df06
7b01 df06 8501 df06 7d01 dec9 dec1 dec9 dec1 dec9 9bd9 2e89 01df 0687
01df 0685 01d9 c1de c9d9 c2d9 f8d8 f2df 1e7b 01d8 fadf 1e7d 01d9 c9d9
f8df 1e79 01

Zerlegt und dokumentiert:

; calculate P+I of loan from wizard
; input:
;   G: number of Galleons (mem16)
;   S: number of Sickles (mem16)
;   K: number of Knuts (mem16)
;   R: interest rate (float)
;   T: time in years (mem16)
;   GS: Galleons to Sickles exchange rate (mem16)
;   SK: Sickles to Knuts exchange rate (mem16)
; output:
;   G: number of Galleons (mem16)
;   S: number of Sickles (mem16)
;   K: number of Knuts (mem16)
WIZ_INT_CALC    MACRO   G, S, K, R, T, GS, SK
                LOCAL   LOOP_EXP
                    ; - calculate interet rate factor
    FLD1            ; load 1
    FLD   R         ; load interest rate
    FADD            ; ST = rate + 1
    MOV   CX, T     ; Exponent is count for loop
    FLD1            ; load 1 into ST as initial exponent value
LOOP_EXP:           ; loop calculate exponent
    FMUL  ST,ST(1)  ; multiply ST = ST * ST(1)
    LOOP  LOOP_EXP
                    ; - convert demonimations to Knuts
    FILD  K         ; load existing Knuts
    FILD  SK        ; load Sickles to Knuts rate 
    FILD  S         ; load existing Sickles
    FILD  GS        ; load Galleons-to-Sickles exchange rate
    FILD  G         ; load existing Galleons
    FMUL            ; multiply galleons to get sickles
    FADD            ; add existing sickles
    FMUL            ; multiply sickles to get knuts
    FADD            ; add existing knuts
    FMUL            ; calculate P+I (P in Knuts * Interest factor)
                    ; - redistribute demonimations to canonical form
    FLDCW  FRD      ; put FPU in round-down mode
    FILD   SK       ; load Sickles to Knuts rate
    FILD   GS       ; load Galleons-to-Sickles exchange rate
    FLD    ST(1)    ; copy Galleons-to-Sickles exchange rate to stack for later
    FMUL            ; multiply to get Galleons-to-Knuts rate
    FLD    ST(2)    ; push original total Knuts from ST(2) into ST (lost by FPREM)
    FPREM           ; get remainder
    FDIV   ST,ST(2) ; divide remainder to get number of Sickles
    FISTP  S        ; store Sickles to S
    FDIVR  ST,ST(2) ; divide to get number of Galleons
    FISTP  G        ; store Galleons to G
    FXCH            ; swap ST, ST(1) for FPREM
    FPREM           ; get remainder to get number of Knuts
    FISTP  K        ; store Knuts to K
        ENDM

Als MACRO (im Grunde genommen eine Funktion) implementiert, ist dies kein betriebssystemspezifischer Maschinencode, für dessen Berechnung nur der Intel 80x87 FPU / Mathe-Coprozessor verwendet wird.

Beispiel Testprogramm mit Ausgabe:

    FINIT           ; reset FPU

    WIZ_INT_CALC    G,S,K,R,T,GS,SK     ; do the "Wizardy"

    MOV  AX, K      ; display Knuts
    CALL OUTDEC     ; generic decimal output routine
    CALL NL         ; CRLF

    MOV  AX, S      ; display Sickles
    CALL OUTDEC     ; generic decimal output routine
    CALL NL         ; CRLF

    MOV  AX, G      ; display Galleons
    CALL OUTDEC     ; generic decimal output routine
    CALL NL         ; CRLF

    RET             ; return to DOS

K   DW  23          ; initial Kunts
S   DW  16          ; initial Sickles
G   DW  103         ; initial Galleons
R   DD  0.0725      ; interest rate
T   DW  3           ; time (years)
GS  DW  17          ; Galleons to Sickles exchange rate
SK  DW  29          ; Sickles to Knuts exchange rate
FRD DW  177FH       ; 8087 control word to round down

Ausgabe

Japt, 48 Bytes

XÄ pY *(U*493+V*29+W)f
Uu493
[Uz493 ,Vz29 ,Vu29]

Mein erster Versuch bei Japt, für @ Shaggy's Kopfgeld! Unnötig zu sagen, das ist nicht sehr golfen :(

Probieren Sie es online!

Haskell , 73 Bytes

(g#s)k r n|(x,y)<-truncate((493*g+29*s+k)*(1+r)^n)%29=(x%17,y)
(%)=divMod

Probieren Sie es online!

Danke an @Laikoni für zwei Bytes.

Die schmutzigen Tricks: Die Anzahl der Münzen in der Eingabe ist Gleitkomma ( Double), während die Anzahl der Münzen in der Ausgabe ganzzahlig ist ( Integer). Das Ergebnis ist ein verschachteltes Paar ((Galleons, Sickles), Knotts), um zu vermeiden, dass es zu einem Tripel abgeflacht wird.

Erläuterung

-- Define a binary operator # that
-- takes the number of Galleons
-- and Slivers and produces a
-- function taking the number of
-- Knots, the rate, and the
-- number of years and producing
-- the result.
(g#s) k r n
   -- Calculate the initial value
   -- in Knotts, calculate the
   -- final value in Knotts,
   -- and divide to get the number
   -- of Galleons and the
   -- remainder.
  |(x,y)<-truncate((493*g+29*s+k)*(1+r)^n)%29
  -- Calculate the number of Slivers
  -- and remaining Knotts.
  =(x%17,y)
(%)=divMod

Stax , 24 Bytes

»♀(╪M╢ú!!«ε◘÷╛SI►U/)-f!ö

Führen Sie es aus und debuggen Sie es

Die Eingabe erfolgt durch Leerzeichen getrennt. interest years knuts sickles galleons

Die Ausgabe erfolgt in Zeilenumbrüchen.

knuts
sickles
galleons

TI-BASIC (TI-84), 96 bis 90 Bytes

:SetUpEditor C:Ans→∟C:∟C(1)+29∟C(2)+493∟C(3)→T:T(1+∟C(4))^∟C(5)→T:remainder(iPart(T),493→R:{remainder(R,29),iPart(R/29),iPart(T/493)}

Eingabe ist Ans eine Liste mit 5 Elementen: Knoten, Sicheln, Galeonen, Zinsen (dezimal) und Zeit (Jahre).
Die Ausgabe erfolgt in Ansund wird automatisch ausgedruckt, wenn das Programm abgeschlossen ist.

Nicht golfen:

:SetUpEditor C 
:Ans→∟C
:∟C(1)+29∟C(2)+493∟C(3)→T
:T(1+∟C(4))^∟C(5)→T
:remainder(iPart(T),493→R
:{remainder(R,29),iPart(R/29),iPart(T/493)}

Beispiel:

{32,2,5,0.05,5}
       {32 2 5 .05 5}
prgmCDGF1
            {12 10 6}

Erläuterung:

:SetUpEditor C
:Ans→∟C

Eine neue Liste, ∟C wird erstellt und Ansdarin gespeichert.

:∟C(1)+29∟C(2)+493∟C(3)→T

Die Knuts, Sicheln und Galeonen werden in Knuts umgewandelt und in gespeichert T .

:T(1+∟C(4))^∟C(5)→T

Nimmt die Menge an Knuts und wendet Zinseszinsen darauf an.
Zinsen werden hier berechnet.

:remainder(iPart(T),493→R

Speichert den I nteger Part von Tmodulo 493 in R. Wird verwendet, um die Byteanzahl zu verkürzen.

:{remainder(R,29),iPart(R/29),iPart(T/493)}

Wertet eine Liste mit 3 Elementen aus (Knuts, Sickles und Galleons). Die Liste wird automatisch in gespeichert Ans.

Hinweis: Die Byteanzahl wird anhand der in [MEM] angegebenen Byteanzahl ausgewertet. → [2] → [7] (Programmliste im RAM) angegebene Byteanzahl abgezogen wird und die Anzahl der Zeichen im Programmnamen sowie weitere 8 für das Programm verwendete Bytes abgezogen werden:

103 - 5 - 8 = 90 Bytes

K, 46 Bytes

c:1000 17 29
t:{c\:{z(y*)/x}[c/:x;1+y%100;z]}

c Speichern Sie die Liste für die Basiskonvertierung

t ist die Funktion, die den Gesamtbetrag berechnet

Anwendungsbeispiel:

t[103 16 23;7.25;3]

schreibt (128;4;24.29209)

Erläuterung:

• c/:x Verwandle die Liste (Galeone; Sichel; Knuts) in Kuts

• 1+y%100 Zinssatz berechnen (Beispiel 1.0725 für 7,25% Satz)

• lambda {z(y*)\x}erledigt die Arbeit: dreimal iterieren, interes * main anwenden und final main zurückgeben.

• c\: erzeugt Galeone, Sicheln, Knuts aus Knuts

HINWEIS: Wenn Sie keine Namensfunktion benötigen, können wir ein Lambda verwenden, das 2 Bytes spart {c\:{z(y*)/x}[c/:x;1+y%100;z]}inputArgs

C # (Visual C # Interactive Compiler) , 86 Byte

(a,b,c)=>((k=(int)((a.a*493+a.b*29+a.c)*Math.Pow(1+b,c)))/493,(k%=493)/29,k%29);int k;

Nimmt inout als benanntes Tupel mit 3 Werten auf, die Knuts, Sicheln und Galeonen darstellen, und dem Zinssatz als Double (kein Prozentsatz). Ich wünschte wirklich, C # hätte einen Exponentationsoperator. Math.Pow ist viel zu lang :(

Probieren Sie es online!

Batch, 171 Bytes

@set i=%4
@set/af=0,i=8*%i:.=,f=%,f*=8
@set/ai+=%f:~,1%,k=%1*493+%2*29+%3
@for /l %%y in (1,1,%5)do @set/ak+=k*i/800
@set/ag=k/493,s=k/29%%17,k%%=29
@echo %g% %s% %k%

Nimmt Eingaben als Befehlszeilenargumente in der Reihenfolge Galeonen, Sicheln, Knuts, Interesse, Jahre auf. Zins ist ein Prozentsatz, der jedoch ohne das% -Zeichen ausgedrückt wird. Nach jedem Jahr abgeschnitten. Die Ausgabe erfolgt in der Reihenfolge Galeonen, Sicheln, Knuts. Unterstützt mindestens 5000 Galeonen. Erläuterung:

@set i=%4
@set/af=0,i=8*%i:.=,f=%,f*=8

Batch hat nur ganzzahlige Arithmetik. Glücklicherweise ist der Zinssatz immer ein Vielfaches von 0.125. Wir beginnen mit der Aufteilung auf den Dezimalpunkt, sodass dieser izum ganzzahligen Teil des Zinssatzes und fdes Dezimalbruchs wird. Diese werden dann mit 8 multipliziert. Die erste Ziffer von fist jetzt die Zahl der Achtel des prozentualen Zinssatzes.

@set/ai+=%f:~,1%,k=%1*493+%2*29+%3

Dieses wird dann mit Hilfe von String-Slicing extrahiert und zu einem Zinssatz von 1/800 addiert. Die Anzahl der Knuts wird ebenfalls berechnet.

@for /l %%y in (1,1,%5)do @set/ak+=k*i/800

Berechnen und addieren Sie die jährlichen Zinsen.

@set/ag=k/493,s=k/29%%17,k%%=29
@echo %g% %s% %k%

Konvertiere zurück zu Galeonen und Sicheln.

05AB1E (Legacy) , 24 Byte

>Im•1ýÑ•3L£I*O*ï29‰ć17‰ì

Port of @JoKings Perl 6-Antwort , also stelle sicher, dass du ihn auch positiv bewertest, wenn dir diese Antwort gefällt!

Ich verwende die Vorgängerversion aufgrund eines Fehlers in der neuen Version, bei dem £Ganzzahlen nicht berücksichtigt werden, also eine explizite Umwandlung in Zeichenfolgen §(zwischen der zweiten •und der zweiten Version)3 ) erforderlich ist (bis der Fehler behoben ist).

Nimmt das Interesse als Dezimalzahl, gefolgt von dem Jahr, gefolgt von der Liste von [Knuts, Sickles, Galleons].

Probieren Sie es online aus.

Erläuterung:

>                      # Increase the (implicit) interest decimal by 1
                       #  i.e. 0.0725 → 1.0725
 Im                    # Take this to the power of the year input
                       #  i.e. 1.0725 and 3 → 1.233...
•1ýÑ•                  # Push compressed integer 119493
     3L                # Push list [1,2,3]
       £               # Split the integer into parts of that size: [1,19,493]
        I*             # Multiply it with the input-list
                       #  i.e. [1,19,493] * [23,16,103] → [23,464,50779]
          O            # Take the sum of this list
                       #  i.e. [23,464,50779] → 51266
           *           # Multiply it by the earlier calculated number
                       #  i.e. 51266 * 1.233... → 63244.292...
            ï          # Cast to integer, truncating the decimal values
                       #  i.e. 63244.292... → 63244
             29‰       # Take the divmod 29
                       #  i.e. 63244 → [2180,24]
                ć      # Extract the head; pushing the remainder-list and head separately
                       #  i.e. [2180,24] → [24] and 2180
                 17‰   # Take the divmod 17 on this head
                       #  i.e. 2180 → [128,4]
                    ì  # And prepend this list in front of the remainder-list
                       #  i.e. [24] and [128,4] → [128,4,24]
                       # (which is output implicitly as result)

Sehen Sie sich meinen Tipp 05AB1E (Abschnitt Wie komprimiere ich große ganze Zahlen? ) An, um zu verstehen, warum dies so •1ýÑ•ist 119493.

APL (NARS), 37 Zeichen, 74 Byte

{(x y z)←⍵⋄⌊¨a⊤(z⊥⍨a←0 17 29)×x*⍨1+y}

Übersetzung der sehr guten und sehr wenigen Bytes APL-Lösung von Graham-Benutzern in eine Lösung, die eine Funktion anstelle der Standardeingabe verwendet ... Test und Verwendung:

  f←{(x y z)←⍵⋄⌊¨a⊤(z⊥⍨a←0 17 29)×x*⍨1+y}
  f 3 0.0725 (103 16 23)
128 4 24

(Ich sage nicht, dass ich den Algorithmus verstanden habe)

Perl 5 , 70 Bytes

$,=$";say 0|($_=(<>+<>*29+<>*493)*(1+<>)**<>)/493,0|($_%=493)/29,$_%29

Probieren Sie es online!