Gringotts n'est pas seulement un coffre-fort, mais une institution financière réputée et des sorciers ont également besoin de prêts. Puisque vous ne voulez pas être foutu par les gobelins Gringotts, vous avez décidé que ce serait une bonne idée d'écrire un programme pour calculer l'intérêt. L'intérêt n'est composé que chaque année.

Votre tâche consiste à calculer le montant total dû après intérêts compte tenu du principal, du taux d'intérêt et du temps (années entières), fonctionnant en dénominations entières d'argent sorcier, arrondi au Knut entier le plus proche. Il y a 29 boutons de bronze dans une faucille d'argent et 17 faucilles dans un galion d'or.

Exemple

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 et règles

• L'entrée et la sortie peuvent être dans n'importe quel format pratique. Vous devez prendre Knuts, Faucilles, Galions, taux d'intérêt et temps. Tous, sauf le taux d'intérêt, seront des nombres entiers. Le taux d'intérêt est par incréments de 0,125%.
• L'argent d'entrée n'est pas garanti d'être canonique (c'est-à-dire que vous pouvez avoir 29 Knuts ou plus et 17 Sickles ou plus.)
• La sortie doit être la représentation canonique. (c'est-à-dire moins de 29 nœuds et moins de 17 faucilles)
• Les totaux dus, jusqu'à 1 000 gallions, devraient être précis à moins de 1 knut par an d'intérêt par rapport aux calculs de précision arbitraires.
  • Vous pouvez arrondir après chaque année d'intérêt ou seulement à la fin. Les calculs de référence peuvent en tenir compte pour les contrôles de précision.

Bon golf!

R , 70 62 octets

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

Essayez-le en ligne!

Prend l'entrée comme d: dépôt dans les knuts, faucilles, galions; i: taux d'intérêt sous forme décimale; y: années. Produit le dépôt final dans les nœuds, les faucilles, les galions. Merci à @Giuseppe pour avoir utilisé la multiplication matricielle pour économiser quelques octets (et indiqué comment éviter d'avoir à boucler à 1e99).

Python 3.8 (pré-version) , 75 74 71 octets

-1 octets grâce à @EmbodimentofIgnorance
-3 octets grâce à @xnor

Cela prend Knuts, Faucilles et Galions comme des entiers, l'intérêt comme un flottant (décimal, pas un pourcentage) et des années comme un int. Il renvoie un tuple contenant le nombre après intérêt de Knuts, Sickles et Galleons, respectivement.

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

Usage:

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

Essayez-le en ligne!

APL + WIN, 37 28 26 octets

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

2 octets économisés grâce au lirtosiast

Essayez-le en ligne! Gracieuseté de Dyalog Classic

Explication:

(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 octets

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

Essayez-le en ligne!

Je suis surpris d'avoir réussi à mettre cela dans un lambda anonyme! Surtout la partie où c'est plus *qu'autre chose. Prend l'entrée commeinterest rate (e.g. 0.0725), years, [Knuts, Sickles, Galleons] et renvoie une liste de devises dans le même ordre.

Explication:

 (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

Gelée , 29 octets

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

Un programme complet acceptant arguments: rate; [Galleons, Sickles, Knuts]; years.
Impressions [Galleons, Sickles, Knuts].

Essayez-le en ligne!

Planchers à la fin de toute la durée.
÷ȷ2peut être supprimé si nous acceptons le taux sous forme de rapport plutôt que de pourcentage.

Comment?

“¢×ø‘©×\ - 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)

Ensemble Intel 8087 FPU, 86 octets

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

Non assemblé et documenté:

; 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

Mis en œuvre en tant que MACRO (essentiellement une fonction), il s'agit d'un code machine non spécifique au système d'exploitation utilisant uniquement le coprocesseur Intel 80x87 FPU / math pour le calcul.

Exemple de programme de test avec sortie:

    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

Production

Japt, 48 octets

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

Mon premier essai chez Japt, pour la prime de @ Shaggy! Inutile de dire que ce n'est pas très golfique :(

Essayez-le en ligne!

Haskell , 73 octets

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

Essayez-le en ligne!

Merci à @Laikoni pour deux octets.

Les sales trucs: le nombre de pièces en entrée est en virgule flottante ( Double), tandis que le nombre de pièces en sortie est intégral ( Integer). Le résultat est une paire imbriquée ((Galleons, Sickles), Knotts)pour éviter d'avoir à s'aplatir en triple.

Explication

-- 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 octets

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

Exécuter et déboguer

L'entrée est des valeurs séparées par des espaces. interest years knuts sickles galleons

La sortie est séparée par des retours à la ligne.

knuts
sickles
galleons

TI-BASIC (TI-84), 96 90 octets

: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)}

L'entrée est Ansune liste de 5 éléments: Knuts, Faucilles, Galions, Intérêt (décimal) et Temps (années).
La sortie est enAns entrée et est automatiquement imprimée à la fin du programme.

Non golfé:

: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)}

Exemple:

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

Explication:

:SetUpEditor C
:Ans→∟C

Une nouvelle liste,, ∟Cest créée et y Ansest stockée.

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

Les Knuts, Faucilles et Galions sont convertis en Knuts et stockés dans T.

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

Prend le montant de Knuts et lui applique des intérêts composés.
L'intérêt est calculé ici.

:remainder(iPart(T),493→R

Stocke la I nteger partie de Tmodulo 493 en R. Utilisé pour raccourcir le nombre d'octets.

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

Évalue une liste avec 3 éléments (Knuts, Faucilles et Galions). La liste est automatiquement stockée dans Ans.

Remarque: le nombre d'octets est évalué en prenant le nombre d'octets donné dans [MEM] → [2] → [7] (liste des programmes dans la RAM) et en soustrayant la quantité de caractères dans le nom du programme et 8 octets supplémentaires utilisés pour le programme:

103 - 5 - 8 = 90 octets

K, 46 octets

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

c stocker la liste pour la conversion de base

t est la fonction qui calcule le montant total

Exemple d'utilisation:

t[103 16 23;7.25;3]

écrit (128;4;24.29209)

Explication:

• c/:x transformer la liste (galion; faucille; knuts) en kuts

• 1+y%100 calculer le taux d'intérêt (exemple 1,0725 pour un taux de 7,25%)

• lambda {z(y*)\x}fait le travail: itérer 3 fois, en appliquant interes * main principale, et retourne la main finale.

• c\: génère galion, faucilles, knuts à partir de knuts

NOTE.- si vous n'avez pas besoin d'une fonction de noms, nous pouvons utiliser un lambda, économisant 2 octets {c\:{z(y*)/x}[c/:x;1+y%100;z]}inputArgs

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

(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;

Prend inout comme un tuple nommé avec 3 valeurs représentant les knuts, faucilles et galions, et le taux d'intérêt en double (pas un pourcentage). Je souhaite vraiment que C # ait un opérateur d'exponentation. Math.Pow est beaucoup trop long :(

Essayez-le en ligne!

Lot, 171 octets

@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%

Prend les entrées sous forme d'arguments de ligne de commande dans l'ordre Galions, Faucilles, Noeuds, intérêt, années. L'intérêt est un pourcentage mais exprimé sans le signe%. Tronque après chaque année. La sortie est dans l'ordre Galions, Faucilles, Noeuds. Prend en charge au moins 5000 gallions. Explication:

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

Le lot n'a qu'une arithmétique entière. Heureusement, le taux d'intérêt est toujours un multiple de 0.125. Nous commençons par diviser sur la virgule décimale, de sorte que cela idevient la partie entière du taux d'intérêt et fla fraction décimale. Ceux-ci sont ensuite multipliés par 8. Le premier chiffre de fest maintenant le nombre de huitièmes du taux d'intérêt en pourcentage.

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

Celui-ci est ensuite extrait en utilisant le tranchage de chaîne et ajouté pour donner un taux d'intérêt au 1 / 800ème. Le nombre de Knuts est également calculé.

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

Calculez et ajoutez l'intérêt de chaque année.

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

Reconvertissez en galions et faucilles.

05AB1E (hérité) , 24 octets

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

Port de la réponse Perl 6 de @JoKing , alors assurez-vous de lui aussi voter positivement si vous aimez cette réponse!

J'utilise la version héritée en raison d'un bogue dans la nouvelle version où £ne fonctionne pas sur les entiers, donc un transtypage explicite en chaîne §(entre le second •et 3) est requis (jusqu'à ce que le bogue soit corrigé).

Prend l'intérêt en décimal, suivi de l'année, suivi de la liste des [Knuts, Faucilles, Galions].

Essayez-le en ligne.

Explication:

>                      # 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)

Voir cette astuce de mes 05AB1E (section Comment compresser les grands entiers? ) Pour comprendre pourquoi •1ýÑ•est 119493.

APL (NARS), 37 caractères, 74 octets

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

traduction de la très bonne et très peu d'octets de la solution APL par l'utilisateur de Graham en une solution qui utilise une fonction au lieu de l'entrée standard ... test et comment l'utiliser:

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

(je ne dis pas que j'avais compris l'algorithme)

Perl 5 , 70 octets

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

Essayez-le en ligne!