Interesse composto ... con i soldi dei maghi

15

Gringotts non è solo un caveau, ma anche un istituto finanziario affidabile e maghi hanno bisogno di prestiti. Dato che non vuoi essere fregato dai goblin Gringott, hai deciso che sarebbe una buona idea scrivere un programma per calcolare l'interesse. L'interesse è composto solo annualmente.

Il tuo compito è calcolare l'importo totale dovuto dopo gli interessi in base al capitale, al tasso di interesse e al tempo (interi anni), operando in interi tagli di denaro del mago, arrotondando per difetto all'intero Knut più vicino. Ci sono 29 Knuts in bronzo in una falce d'argento e 17 falci in un galeone d'oro.

Esempio

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

Total owed after interest:
 24 Knuts
  4 Sickles
128 Galleons

Note e regole

  • L'input e l'output possono essere in qualsiasi formato conveniente. Devi prendere Knuts, Sickles, Galleons, tasso di interesse e tempo. Tutti tranne il tasso di interesse saranno numeri interi. Il tasso di interesse è in incrementi dello 0,125%.
  • Il denaro in entrata non è garantito per essere canonico (cioè puoi avere 29 o più Knuts e 17 o più Falci.)
  • L'output deve essere la rappresentazione canonica. (cioè meno di 29 Knuts e meno di 17 falci)
  • I totali dovuti, fino a 1.000 Galeoni, dovrebbero essere accurati entro 1 Knut all'anno di interesse rispetto ai calcoli di precisione arbitrari.
    • Puoi arrotondare per eccesso dopo ogni anno di interesse o solo alla fine. I calcoli di riferimento possono tenerne conto per i controlli di precisione.

Buon golf!

code-golf  math 
— Beefster
fonte
4
Possiamo prendere il tasso di interesse come decimale anziché come percentuale? (ad esempio, 0.0725invece di 7.25)
— Shaggy
@Shaggy Mi piacerebbe anche saperlo
— senox13
Se il prestito è esattamente 1 Knut e l'interesse è del 99% all'anno e il termine è 1 anno, il risultato dovrebbe essere "1 Knut" o "2 Knuts"?
— Chas Brown
In altre parole, chiarisci il significato matematico della fraserounding down
— senox13
1
@ChasBrown: 1 Knut. Tronca / funzione pavimento all'intero Knut più vicino.
— Beefster

Risposte:

6

R , 70 62 byte

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

Provalo online!

Accetta input come d: deposito in nodi, falci, galeoni; i: tasso di interesse come decimale; y: anni. Emette il deposito finale in nodi, falci, galeoni. Grazie a @Giuseppe per aver utilizzato la moltiplicazione di matrici per salvare alcuni byte (e sottolineare come evitare la necessità di avvolgere a 1e99).

— Nick Kennedy
fonte
Non conosco R; cosa ti fa vincere?
— Dfeuer
@dfeuer vengono prese mod 1e99, quindi se i tuoi galeoni salgono così in alto scenderanno a zero
— Nick Kennedy
Quello che mi chiedo è quello che guadagni prendendo loro mod 1e99.
— Dfeuer
La maggior parte delle funzioni R sono vettorializzate. In questo caso, sto passando l'output attraverso la %%funzione, che è mod. Idealmente, vorrei lasciare soli i galeoni, ma prendere un numero infinito mod restituisce NaN, e quindi ho appena usato un numero davvero grande (ma uno che è piccolo in byte). Le alternative che ho escogitato sono più lunghe (ad es. [ Tio.run/##JYrLCsIwEEV/… Provalo online!])
— Nick Kennedy
@NickKennedy potresti anche fare 9e99... Inoltre, puoi giocare a golf fino a 63 byte
— Giuseppe
4

Python 3.8 (pre-release) , 75 74 71 byte

-1 byte grazie a @EmbodimentofIgnorance
-3 byte grazie a @xnor

Questo prende Knuts, Sickles e Galleons come ints, l'interesse come un float (decimale, non percentuale) e gli anni come int. Restituisce una tupla contenente il numero dopo l'interesse di Knuts, Sickles e Galleons, rispettivamente.

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

Uso:

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

Provalo online!

— senox13
fonte
Buona pesca. Risposta di aggiornamento
— senox13
La domanda dice operating in whole denominations of wizard money, rounding down. Ho rounding downpensato che chop off everything after the decimal point.usare l'intestazione suona sicuramente come un modo più semplice di fare le cose. Lo farò per post futuri, grazie
— senox13
Sembra molto più "troncare" che "arrotondare"; ma ho chiesto chiarimenti all'OP (perché nit-picking è il nome del gioco qui su PPCG :)).
— Chas Brown
Non sono in disaccordo con te, questo è solo il significato che ho sempre visto usato per arrotondare per difetto, perché arrotondi sempre all'intero sotto il tuo risultato. Altrimenti è solo un normale arrotondamento. Lasciare decidere l'OP è una buona idea
— senox13
Cordiali saluti, un trucco utile per rendere testabili le funzioni anonime su TIO è quello di inserire I\=l'intestazione in questo modo . Inoltre, sembra che k//29//17possa essere k//493.
— xnor
3

APL + WIN, 37 28 26 byte

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

2 byte salvati grazie a lirtosiast

Provalo online! Per gentile concessione di Dyalog Classic

Spiegazione:

(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.
— Graham
fonte
⌊a⊤(⎕⊥⍨a←0 17 29)×⎕*⍨1+⎕per 24?
— Lirtosiast
@lirtosiast Grazie ma temo che il mio antico interprete APL + WIN non abbia la funzione ⍨. In ogni caso, invialo come soluzione APL personalizzata.
— Graham
@lirtosiast Grazie ancora ho preso i 2 byte risultanti dall'assegnazione a a.
— Graham
3

Perl 6 , 47 byte

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

Provalo online!

Sono sorpreso di essere riuscito a ottenere questo in un lambda qualunque Anonimo! Soprattutto la parte in cui è più *s di ogni altra cosa. Accetta input interest rate (e.g. 0.0725), years, [Knuts, Sickles, Galleons]e restituisce un elenco di valute nello stesso ordine.

Spiegazione:

 (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
— Jo King
fonte
Sono sorpreso che tu non abbia trovato un modo per far sì che anche il numero di Knuts / Sickles / Galleon si adattasse ai whatevers. Quindi sarebbe solo eh, come ************************* ;-)
— user0721090601
@guifa I Whatevers sono gli input, quindi ce ne possono essere solo 3 (anche se posso dividere l'input di valuta per alcuni più *s ma più byte). Il resto della *s proviene dalla moltiplicazione ( *) e dagli esponenziali ( **)
— Jo King
Intendevo dire se avessi anche i tassi di conversione (il numero 29/17). Ma ovviamente è stato uno scherzo perché è necessario utilizzare quei numeri più di una volta. Scusa se il mio umorismo non è passato
— user0721090601
2

Gelatina , 29 byte

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

Un programma completo di accettare argomenti: rate; [Galleons, Sickles, Knuts]; years.
Stampe [Galleons, Sickles, Knuts].

Provalo online!

Pavimenti alla fine dell'intero periodo.
÷ȷ2può essere rimosso se possiamo accettare il tasso come rapporto anziché come percentuale.

Come?

“¢×ø‘©×\ - 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)
— Jonathan Allan
fonte
2

Assemblea FPU Intel 8087, 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

Non assemblato e documentato:

; 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

Implementato come MACRO (sostanzialmente una funzione), si tratta di un codice macchina non specifico del sistema operativo che utilizza solo il coprocessore Intel 80x87 FPU / matematica per il calcolo.

Esempio di programma di test con output:

    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

Produzione

inserisci qui la descrizione dell'immagine

— 640KB
fonte
1

Haskell , 73 byte

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

Provalo online!

Grazie a @Laikoni per due byte.

I trucchi sporchi: il numero di monete nell'input è in virgola mobile ( Double), mentre il numero di monete nell'output è integrale ( Integer). Il risultato è una coppia nidificata ((Galleons, Sickles), Knotts)per evitare di appiattire su una tripla.

Spiegazione

-- 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
— dfeuer
fonte
1
Salvare due byte con (truncate$ ... )-> truncate( ... )e (g#s)k r nanziché c g s k r n.
— Laikoni
@Laikoni, grazie mille!
— Dfeuer
@Laikoni, apprezzerei molto se tu potessi trovarmi un paio di byte in codegolf.stackexchange.com/questions/55960/… , se hai tempo.
— Dfeuer
1
Lo esaminerò quando troverò il tempo. Nel frattempo, posso indicarti la nostra chat room di Monads and Men di Haskell e anche questa domanda che potresti apprezzare dati i tuoi poliglotti Hugs / GHC.
— Laikoni,
1

Stax , 24 byte

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

Esegui ed esegui il debug

L'input è valori separati da spazio. interest years knuts sickles galleons

L'output è separato da una nuova riga.

knuts
sickles
galleons
— ricorsivo
fonte
1

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

: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'input è Ansun elenco con 5 voci: Knuts, Sickles, Galleons, Interest (decimal) e Time (anni).
L'uscita è inAns e viene stampato automaticamente al termine del programma.

Un-giocato a 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)}

Esempio:

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

Spiegazione:

:SetUpEditor C
:Ans→∟C

Viene ∟Ccreato un nuovo elenco e Ansviene archiviato in esso.

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

I Knuts, Sickles e Galleons vengono convertiti in Knuts e conservati in T.

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

Prende la quantità di Knuts e applica ad esso interessi composti.
L'interesse è calcolato qui.

:remainder(iPart(T),493→R

Memorizza l' ho nteger Parte del Tmodulo 493 in R. Utilizzato per abbreviare il conteggio dei byte.

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

Valuta un elenco con 3 elementi (Knuts, Sickles e Galleons). L'elenco viene automaticamente archiviato in Ans.

Nota: il conteggio dei byte viene valutato prendendo il conteggio dei byte indicato in [MEM] → [2] → [7] (elenco dei programmi nella RAM) e sottraendo la quantità di caratteri nel nome del programma e altri 8 byte utilizzati per il programma:

103-5-8 = 90 byte

— Tau
fonte
0

K, 46 byte

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

c memorizza l'elenco per la conversione di base

t è la funzione che calcola l'importo totale

Usa esempio:

t[103 16 23;7.25;3]

scrive (128;4;24.29209)

Spiegazione:

  • c/:x trasforma la lista (galeone; falce; nodi) in kuts

  • 1+y%100 calcolare il tasso di interesse (esempio 1.0725 per il tasso del 7,25%)

  • lambda {z(y*)\x}fa il lavoro: iterare 3 volte, applicando interes * main, e restituisce final principale.

  • c\: genera galeone, falci, nodi da nodi

NOTA.- se non hai bisogno di una funzione names, possiamo usare un lambda, risparmiando 2 byte {c\:{z(y*)/x}[c/:x;1+y%100;z]}inputArgs

— J. Sendra
fonte
0

Lotto, 171 byte

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

Accetta input come argomenti da riga di comando nell'ordine Galleons, Sickles, Knuts, interest, years. L'interesse è una percentuale ma espresso senza il segno%. Tronca dopo ogni anno. L'output è nell'ordine Galleons, Sickles, Knuts. Supporta almeno 5000 Galeoni. Spiegazione:

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

Il batch ha solo aritmetica intera. Fortunatamente, il tasso di interesse è sempre un multiplo di 0.125. Iniziamo dividendo sul punto decimale, in modo che idiventi la parte intera del tasso di interesse e fla frazione decimale. Questi vengono poi moltiplicati per 8. La prima cifra di fè ora il numero di ottavi nel tasso di interesse percentuale.

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

Questo viene quindi estratto usando lo slicing delle stringhe e aggiunto per dare un tasso di interesse in 1/800. Viene anche calcolato il numero di Knuts.

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

Calcola e aggiungi gli interessi di ogni anno.

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

Converti di nuovo in Galleons and Sickles.

— Neil
fonte
0

05AB1E (legacy) , 24 byte

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

Porta della risposta Perl 6 di @JoKing , quindi assicurati di votare anche lui se ti piace questa risposta!

Sto usando la versione legacy a causa di un bug nella nuova versione in cui £non funziona su numeri interi, quindi è richiesto un cast esplicito su stringa §(tra il secondo •e 3) (fino a quando il bug non viene risolto).

Prende l'interesse come decimale, seguito dall'anno, seguito dall'elenco di [Knuts, Sickles, Galleons].

Provalo online.

Spiegazione:

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

Vedere questo 05AB1E punta del mio (sezione Come comprimere grandi numeri interi? ) Per capire il motivo per cui •1ýÑ•è 119493.

— Kevin Cruijssen
fonte
0

APL (NARS), 37 caratteri, 74 byte

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

traduzione della molto buona e pochissima soluzione di byte APL da parte dell'utente Graham in una soluzione che utilizza una funzione anziché lo standard input ... test e come usarla:

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

(non dico di aver capito l'algoritmo)

— RosLuP
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.