Bunga Majemuk ... dengan Uang Wisaya

15

Gringotts bukan hanya lemari besi, tetapi lembaga keuangan dan penyihir terkemuka juga membutuhkan pinjaman. Karena Anda tidak ingin dikacaukan oleh para goblin Gringotts, Anda memutuskan untuk menulis sebuah program untuk menghitung bunga. Bunga hanya diperparah setiap tahun.

Tugas Anda adalah untuk menghitung jumlah total utang setelah bunga diberikan pokok, tingkat bunga, dan waktu (sepanjang tahun), yang beroperasi di seluruh denominasi uang penyihir, dibulatkan ke seluruh Knut terdekat. Ada 29 Bronze Knuts di Silver Sickle dan 17 Sickles di Gold Galleon.

Contoh

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

Total owed after interest:
 24 Knuts
  4 Sickles
128 Galleons

Catatan dan Aturan

  • Input dan output mungkin dalam format apa pun yang nyaman. Anda harus menerima Knuts, Sickles, Galleon, suku bunga, dan waktu. Semua kecuali suku bunga akan menjadi bilangan bulat. Tingkat bunga adalah sebesar 0,125%.
  • Uang input tidak dijamin kanonik (yaitu, Anda dapat memiliki 29 Knuts atau lebih dan 17 atau lebih Sabit.)
  • Keluaran harus berupa representasi kanonik. (yaitu kurang dari 29 Knuts dan kurang dari 17 Sabit)
  • Total utang, hingga 1.000 Galleon, harus akurat hingga dalam 1 Knut per tahun yang diminati bila dibandingkan dengan perhitungan presisi yang arbitrer.
    • Anda dapat membulatkan setelah setiap tahun bunga atau hanya di akhir. Perhitungan referensi dapat memperhitungkan ini untuk pemeriksaan akurasi.

Selamat bermain golf!

code-golf  math 
— Beefster
sumber
4
Bisakah kita mengambil tingkat bunga sebagai desimal daripada persentase? (mis. 0.0725alih-alih 7.25)
— Shaggy
@ Shaggy Saya juga ingin tahu ini
— senox13
Jika pinjamannya tepat 1 Knut, dan bunganya 99% per tahun, dan jangka waktu 1 tahun, haruskah hasilnya "1 Knut" atau "2 Knut"?
— Chas Brown
Dengan kata lain, harap perjelas arti matematika dari frasarounding down
— senox13
1
@ChasBrown: 1 Knut. Memotong / fungsi lantai ke seluruh Knut terdekat.
— Beefster

Jawaban:

6

R , 70 62 byte

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

Cobalah online!

Mengambil input sebagai d: menyetor knut, sabit, galleon; i: suku bunga sebagai desimal; y: tahun. Menghasilkan setoran akhir dalam knuts, sabit, galleon. Terima kasih kepada @Giuseppe untuk menggunakan perkalian matriks untuk menghemat beberapa byte (dan menunjukkan bagaimana menghindari keharusan untuk membungkus pada 1e99).

— Nick Kennedy
sumber
Saya tidak tahu R; apa yang membuat mereka membungkus menang Anda?
— dfeuer
@ PDFer mereka diambil mod 1e99, jadi jika galleon Anda mendapatkan setinggi itu mereka akan turun ke nol
— Nick Kennedy
Yang saya ingin tahu adalah apa yang Anda peroleh dengan membawa mereka mod 1e99.
— dfeuer
Sebagian besar fungsi R adalah vektor. Dalam hal ini, saya melewatkan output melalui %%fungsi, yaitu mod. Idealnya, saya ingin meninggalkan galleon sendirian, tetapi mengambil sejumlah mod tanpa batas mengembalikan NaN, jadi saya baru saja menggunakan jumlah yang sangat besar (tetapi yang kecil dalam byte). Alternatif yang saya buat lebih panjang (mis. [ Tio.run / ##JYrLCsIwEEV/... Coba online!])
— Nick Kennedy
@NickKennedy yang bisa Anda lakukan 9e99juga ... Anda juga dapat bermain golf hingga 63 byte
— Giuseppe
4

Python 3.8 (pra-rilis) , 75 74 71 byte

-1 byte terima kasih kepada @EmbodimentofIgnorance
-3 byte terima kasih kepada @xnor

Ini membutuhkan Knuts, Sickles, dan Galleon sebagai int, bunga sebagai float (desimal, bukan persentase), dan tahun sebagai int. Ini mengembalikan tuple yang berisi nomor setelah bunga Knuts, Sickles, dan Galleons, masing-masing.

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

Pemakaian:

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

Cobalah online!

— senox13
sumber
Tangkapan yang bagus. Memperbarui jawaban
— senox13
Pertanyaannya adalah operating in whole denominations of wizard money, rounding down. Aku mengambil rounding downberarti chop off everything after the decimal point.Menggunakan header pasti terdengar seperti cara yang lebih mudah untuk melakukan sesuatu. Saya akan melakukannya untuk posting selanjutnya, terima kasih
— senox13
Kedengarannya lebih seperti "memotong" daripada "pembulatan"; tetapi saya telah meminta OP untuk klarifikasi (karena nit-picking adalah nama permainan di sini di PPCG :)).
— Chas Brown
Saya tidak setuju dengan Anda, itu hanya makna yang selalu saya lihat digunakan untuk pembulatan ke bawah, karena Anda selalu membulatkan ke bilangan bulat di bawah hasil Anda. Kalau tidak, itu hanya pembulatan normal. Membiarkan OP memutuskan adalah ide yang bagus
— senox13
FYI, trik yang berguna untuk membuat fungsi anonim dapat diuji pada TIO adalah dengan memasukkan I\=header seperti ini . Juga, sepertinya k//29//17bisa k//493.
— xnor
3

APL + WIN, 37 28 26 byte

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

2 byte disimpan berkat lirtosiast

Cobalah online! Atas perkenan Dyalog Classic

Penjelasan:

(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
sumber
⌊a⊤(⎕⊥⍨a←0 17 29)×⎕*⍨1+⎕untuk 24?
— lirtosiast
@ lirtosiast Terima kasih, tetapi saya takut penerjemah APL + WIN saya yang lama tidak memiliki fungsi ⍨. Dengan segala cara kirimkan ini sebagai solusi APL Anda sendiri.
— Graham
@ lirtosiast Terima kasih lagi saya telah mengambil 2 byte yang dihasilkan dari penugasan ke a.
— Graham
3

Perl 6 , 47 byte

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

Cobalah online!

Saya terkejut saya berhasil membuat ini menjadi lambda Apapun anonim! Terutama bagian di mana itu lebih *dari apa pun. Mengambil input sebagaiinterest rate (e.g. 0.0725), years, [Knuts, Sickles, Galleons] dan mengembalikan daftar mata uang dalam urutan yang sama.

Penjelasan:

 (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
sumber
Saya terkejut Anda tidak menemukan cara untuk juga mendapatkan jumlah Knuts / Sickles / Galleon juga agar sesuai dengan apa pun. Maka itu hanya akan menjadi eh, seperti ************************* ;-)
— user0721090601
@guifa The whatevers adalah input, sehingga ada dapat hanya benar-benar menjadi 3 dari mereka (meskipun saya dapat membagi input mata uang untuk beberapa lebih *s tetapi lebih byte). Sisanya *berasal dari perkalian ( *) dan eksponensial ( **)
— Jo King
Maksud saya jika Anda mendapatkan tingkat konversi (angka 29/17) ke dalamnya juga. Tapi tentu saja itu lelucon karena Anda perlu menggunakan angka-angka itu lebih dari sekali. Maaf jika humor saya tidak masuk
— user0721090601
2

Jelly , 29 byte

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

Sebuah program penuh menerima argumen: rate; [Galleons, Sickles, Knuts]; years.
Cetakan [Galleons, Sickles, Knuts].

Cobalah online!

Lantai di akhir masa.
÷ȷ2dapat dihapus jika kami dapat menerima tarif sebagai rasio daripada persentase.

Bagaimana?

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

Perakitan 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

Belum dirakit dan didokumentasikan:

; 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

Diimplementasikan sebagai MACRO (pada dasarnya fungsi), ini adalah kode mesin non-OS khusus menggunakan hanya Intel 80x87 FPU / matematika co-prosesor untuk perhitungan.

Contoh program uji dengan 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

Keluaran

masukkan deskripsi gambar di sini

— 640KB
sumber
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

Cobalah online!

Terima kasih kepada @Laikoni untuk dua byte.

Trik kotor: jumlah koin dalam input adalah floating point ( Double), sedangkan jumlah koin dalam output adalah integral ( Integer). Hasilnya adalah pasangan bersarang ((Galleons, Sickles), Knotts)untuk menghindari meratakan ke tiga.

Penjelasan

-- 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
sumber
1
Simpan dua byte dengan (truncate$ ... )-> truncate( ... )dan (g#s)k r nbukannya c g s k r n.
— Laikoni
@Laikoni, terima kasih banyak!
— dfeuer
@Laikoni, saya sangat menghargai jika Anda dapat menemukan saya beberapa byte di codegolf.stackexchange.com/questions/55960/… , jika Anda punya waktu.
— dfeuer
1
Saya akan memeriksanya ketika saya menemukan waktu. Sementara itu, saya dapat mengarahkan Anda ke ruang obrolan Haskell kami Of Monads and Men dan juga pertanyaan ini yang mungkin Anda nikmati karena poligot Hugs / GHC Anda.
— Laikoni
1

Stax , 24 byte

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

Jalankan dan debug itu

Input adalah nilai yang dipisahkan ruang. interest years knuts sickles galleons

Output dipisahkan baris baru.

knuts
sickles
galleons
— rekursif
sumber
1

TI-BASIC (TI-84), 96 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)}

Input adalah Ans, daftar dengan 5 item: Knuts, Sickles, Galleons, Bunga (desimal), dan Waktu (tahun).
Output dalamAns dan secara otomatis dicetak ketika program selesai.

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

Contoh:

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

Penjelasan:

:SetUpEditor C
:Ans→∟C

Daftar baru,, ∟Cdibuat dan Ansdisimpan di dalamnya.

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

Knuts, Sickles, dan Galleon dikonversi menjadi Knuts dan disimpan menjadi T.

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

Mengambil jumlah Knuts dan menerapkan bunga majemuk untuk itu.
Bunga dihitung di sini.

:remainder(iPart(T),493→R

Toko yang saya nteger Bagian dari Tmodulo 493 menjadi R. Digunakan untuk mempersingkat jumlah byte.

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

Mengevaluasi daftar dengan 3 item (Knuts, Sickles, dan Galleons). Daftar ini disimpan secara otomatis Ans.

Catatan: Jumlah byte dievaluasi dengan mengambil jumlah byte yang diberikan dalam [MEM] → [2] → [7] (daftar program dalam RAM) dan mengurangi jumlah karakter dalam nama program dan 8 byte tambahan yang digunakan untuk program:

103 - 5 - 8 = 90 byte

— Tau
sumber
0

K, 46 Bytes

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

c simpan daftar untuk konversi basis

t adalah fungsi yang menghitung jumlah total

Gunakan contoh:

t[103 16 23;7.25;3]

menulis (128;4;24.29209)

Penjelasan:

  • c/:x mengubah daftar (galleon; sabit; knuts) menjadi kuts

  • 1+y%100 menghitung suku bunga (misalnya 1,0725 untuk suku bunga 7,25%)

  • lambda {z(y*)\x}melakukan pekerjaan: iterate 3 kali, menerapkan interes * main, dan mengembalikan main final.

  • c\: menghasilkan galleon, sabit, knuts dari knuts

CATATAN.- jika Anda tidak memerlukan fungsi-nama, kita dapat menggunakan lambda, menghemat 2 byte {c\:{z(y*)/x}[c/:x;1+y%100;z]}inputArgs

— J. Sendra
sumber
0

Batch, 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%

Mengambil input sebagai argumen baris perintah dalam urutan Galleon, Sabit, Knuts, bunga, tahun. Bunga adalah persentase tetapi dinyatakan tanpa tanda%. Potong setelah setiap tahun. Output dalam urutan Galleon, Sabit, Knuts. Mendukung setidaknya 5.000 Galleon. Penjelasan:

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

Batch hanya memiliki bilangan aritmatika. Untungnya, suku bunga selalu kelipatan 0.125. Kita mulai dengan membagi titik desimal, sehingga imenjadi bagian bilangan bulat dari suku bunga dan ffraksi desimal. Ini kemudian dikalikan dengan 8. Digit pertama fsekarang adalah angka delapan dalam tingkat bunga persentase.

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

Ini kemudian diekstraksi menggunakan string slicing dan ditambahkan untuk memberikan tingkat bunga dalam 1/800-an. Jumlah Knuts juga dihitung.

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

Hitung dan tambahkan bunga setiap tahun.

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

Konversi kembali ke Galleon dan Sabit.

— Neil
sumber
0

05AB1E (warisan) , 24 byte

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

Port dari @JoKing 's Perl 6 menjawab , jadi pastikan untuk menghapusnya juga jika Anda suka jawaban ini!

Saya menggunakan versi lawas karena bug di versi baru di mana £tidak bekerja pada bilangan bulat, jadi diperlukan pelemparan eksplisit ke string §(antara yang kedua •dan 3) (sampai bug diperbaiki).

Mengambil bunga sebagai desimal, diikuti oleh tahun, diikuti oleh daftar [Knuts, Sickles, Galleons].

Cobalah online.

Penjelasan:

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

Lihat ini 05AB1E ujung tambang (bagian Cara kompres bilangan bulat besar? ) Untuk memahami mengapa •1ýÑ•adalah 119493.

— Kevin Cruijssen
sumber
0

APL (NARS), 37 char, 74 byte

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

terjemahan dari solusi APL byte yang sangat baik dan sangat sedikit oleh pengguna Graham ke solusi yang menggunakan satu fungsi alih-alih input standar ... tes dan cara menggunakannya:

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

(Saya tidak mengatakan saya mengerti algoritma)

— RosLuP
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.