Gringotts isn't just a vault, but a reputable financial institution and wizards need loans too. Since you don't want to be screwed over by the Gringotts goblins, you decided it would be a good idea to write a program to calculate interest. Interest is compounded only yearly.

Your task is to calculate total owed amount after interest given the principal, interest rate, and time (whole years), operating in whole denominations of wizard money, rounding down. There are 29 Bronze Knuts in a Silver Sickle and 17 Sickles in a Gold Galleon.

Example

Loan taken out:

 23 Knuts

 16 Sickles

103 Galleons

@ 7.250%

For 3 years



Total owed after interest:

 24 Knuts

  4 Sickles

128 Galleons

Notes and Rules

• Input and output may be in any convenient format. You must take in Knuts, Sickles, Galleons, interest rate, and time. All but interest rate will be whole numbers. The interest rate is in increments of 0.125%.


• Input money is not guaranteed to be canonical (i.e. you can have 29 or more Knuts and 17 or more Sickles.)


• Output must be the canonical representation. (i.e. less than 29 Knuts and less than 17 Sickles)


• Totals owed, up to 1,000 Galleons, should be accurate to within 1 Knut per year of interest when compared with arbitrary precision calculations.
  
  
  
  
  • You may round down after each year of interest or only at the end. Reference calculations can take this into account for accuracy checks.
  
  
  
  

Happy golfing!

Jelly, 29 bytes

“¢×ø‘©×

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

A full program accepting arguments: rate; [Galleons, Sickles, Knuts]; years.

Prints [Galleons, Sickles, Knuts].

Try it online!

Floors at the end of the entire term.
÷ȷ2 may be removed if we may accept the rate as a ratio rather than a percentage.

How?

“¢×ø‘©× - 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,483]



÷ȷ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)

K, 46 Bytes

c:1000 17 29

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

c store the list for base-conversion

t is the function that calculates total amount

Use example:

t[103 16 23;7.25;3]

writes (128;4;24.29209)

Explanation:

• c/:x transform the list (galleon; sickle; knuts) to kuts




• 1+y%100 calculate rate of interest (example 1.0725 for 7.25% rate)




• lambda {z(y*)x} does the work: iterate 3 times, applying interes*main, and returns final main.




• c: generates galleon, sickles, knuts from knuts

NOTE.- if you don't need a names-function, we can use a lambda, saving 2 bytes
{c:{z(y*)/x}[c/:x;1+y%100;z]}inputArgs

C# (Visual C# Interactive Compiler), 85 bytes

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

Takes inout as a named tuple with 3 values representing knuts, sickles, and galleons, and interest rate as a double (not a percentage). I really wish C# had an exponentation operator. Math.Pow is way too long :(

Try it online!

Python 3.8 (pre-release), 75 74 bytes

-1 bytes thanks to @EmbodimentofIgnorance

This takes Knuts, Sickles, and Galleons as ints, interest as a float (decimal, not percentage), and years as an int. It returns a tuple containing the number after interest of Knuts, Sickles, and Galleons, respectively.

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

Usage:

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

print(I(23,16,103,0.0725,3))

Try it online!

APL+WIN, 37 bytes

⌊n,17 29⊤493×n←(+/⎕÷1 17 493)×(1+⎕)*⎕

Try it online! Courtesy of Dyalog Classic

Explanation:

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

         compounding multiplier



n←(+/⎕÷1 17 493) prompts for Galleons, Sickles and Knuts and converts to decimal Galleons



⌊n,17 29⊤493× converts decimal Galleons after applying compound interest, 

              converts back to Galleons, Sickles and Knuts and rounds down