Gringotts không chỉ là một kho tiền, mà là một tổ chức tài chính có uy tín và các pháp sư cũng cần các khoản vay. Vì bạn không muốn bị yêu tinh Gringotts làm phiền, bạn đã quyết định viết một chương trình để tính lãi. Tiền lãi chỉ được gộp hàng năm.

Nhiệm vụ của bạn là tính tổng số tiền nợ sau khi trả lãi gốc, lãi suất và thời gian (cả năm), hoạt động bằng toàn bộ mệnh giá tiền thuật sĩ, làm tròn đến toàn bộ Knut gần nhất. Có 29 Knuts Đồng trong một Liềm bạc và 17 Liềm trong một Galleon vàng.

Thí dụ

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

Total owed after interest:
 24 Knuts
  4 Sickles
128 Galleons

Ghi chú và nội quy

• Đầu vào và đầu ra có thể ở bất kỳ định dạng thuận tiện. Bạn phải tham gia Knuts, Sickles, Galleons, lãi suất và thời gian. Tất cả trừ lãi suất sẽ là toàn bộ con số. Lãi suất được tính theo mức tăng 0,125%.
• Tiền đầu vào không được đảm bảo là hợp quy (tức là bạn có thể có 29 Knuts trở lên và 17 Sickles trở lên.)
• Đầu ra phải là đại diện chính tắc. (tức là ít hơn 29 Knuts và ít hơn 17 Sickles)
• Tổng số nợ, lên tới 1.000 Galleons, phải chính xác trong vòng 1 Knut mỗi năm quan tâm khi so sánh với các tính toán chính xác tùy ý.
  • Bạn có thể làm tròn số sau mỗi năm quan tâm hoặc chỉ khi kết thúc. Tính toán tham chiếu có thể tính đến điều này để kiểm tra độ chính xác.

Chúc bạn chơi golf vui vẻ!

R , 70 62 byte

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

Hãy thử trực tuyến!

Có đầu vào là d: tiền gửi trong knuts, liềm, galleons; i: lãi suất dưới dạng thập phân; y: năm Đầu ra tiền gửi cuối cùng trong knuts, liềm, galleons. Cảm ơn @Giuseppe đã sử dụng phép nhân ma trận để lưu một số byte (và chỉ ra cách tránh sự cần thiết phải bọc ở 1e99).

Python 3.8 (tiền phát hành) , 75 74 71 byte

-1 byte nhờ @EmbodimentofIgnorance
-3 byte nhờ @xnor

Điều này lấy Knuts, Sickles và Galleons làm ints, lãi suất như một số float (thập phân, không phải là tỷ lệ phần trăm) và nhiều năm như một int. Nó trả về một tuple chứa số sau lãi suất của Knuts, Sickles và Galleons, tương ứng.

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

Sử dụng:

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

Hãy thử trực tuyến!

APL + THẮNG, 37 28 26 byte

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

Lưu 2 byte nhờ lirtosiast

Hãy thử trực tuyến! Lịch sự của Dyalog Classic

Giải trình:

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

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

Hãy thử trực tuyến!

Tôi ngạc nhiên tôi đã xoay sở để biến điều này thành một ẩn danh Dù là lambda! Đặc biệt là phần mà nó nhiều *hơn bất cứ điều gì khác. Lấy đầu vào là interest rate (e.g. 0.0725), years, [Knuts, Sickles, Galleons]và trả về một danh sách các loại tiền theo cùng một thứ tự.

Giải trình:

 (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

Thạch , 29 byte

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

Một chương trình đầy đủ chấp nhận đối số : rate; [Galleons, Sickles, Knuts]; years.
In [Galleons, Sickles, Knuts].

Hãy thử trực tuyến!

Sàn nhà vào cuối của toàn bộ nhiệm kỳ.
÷ȷ2có thể được xóa nếu chúng tôi có thể chấp nhận tỷ lệ theo tỷ lệ chứ không phải là tỷ lệ phần trăm.

Làm sao?

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

Lắp ráp Intel 8087 FPU, 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

Unassembled và tài liệu:

; 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

Được triển khai dưới dạng MACRO (về cơ bản là một chức năng), đây là mã máy không dành riêng cho hệ điều hành, chỉ sử dụng bộ đồng xử lý Intel 80x87 FPU / math để tính toán.

Ví dụ chương trình thử nghiệm với đầu ra:

    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

Đầu ra

Japt, 48 byte

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

Lần thử đầu tiên của tôi tại Japt, sẽ nhận tiền thưởng của @ Shaggy! Không cần phải nói, điều này không phải là rất golf :(

Hãy thử trực tuyến!

Haskell , 73 byte

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

Hãy thử trực tuyến!

Cảm ơn @Laikoni cho hai byte.

Thủ đoạn bẩn: số lượng đồng xu trong đầu vào là dấu phẩy động ( Double), trong khi số lượng đồng xu trong đầu ra là không thể thiếu (Integer ). Kết quả là một cặp lồng nhau ((Galleons, Sickles), Knotts)để tránh phải làm phẳng thành một bộ ba.

Giải trình

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

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

Chạy và gỡ lỗi nó

Đầu vào là giá trị phân tách không gian. interest years knuts sickles galleons

Đầu ra là dòng mới tách.

knuts
sickles
galleons

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

Đầu vào là Ans, một danh sách có 5 mục: Knuts, Sickles, Galleons, Interest (thập phân) và Thời gian (năm).
Đầu ra nằm trong Ansvà được tự động in ra khi chương trình hoàn thành.

Chưa chơi gôn:

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

Thí dụ:

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

Giải trình:

:SetUpEditor C
:Ans→∟C

Một danh sách mới ∟C, được tạo và Ansđược lưu trữ vào đó.

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

Knuts, Sickles và Galleons được chuyển đổi thành Knuts và được lưu trữ vào T.

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

Lấy số lượng Knuts và áp dụng lãi kép.
Tiền lãi được tính ở đây.

:remainder(iPart(T),493→R

Các cửa hàng tôi nteger Phần của Tmodulo 493 thành R. Được sử dụng để rút ngắn số byte.

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

Đánh giá một danh sách với 3 mục (Knuts, Sickles và Galleons). Danh sách được tự động lưu trữ vào Ans.

Lưu ý: Số byte được đánh giá bằng cách lấy số byte được đưa ra trong [MEM] → [2] → [7] (danh sách chương trình trong RAM) và trừ đi số lượng ký tự trong tên chương trình và thêm 8 byte được sử dụng cho chương trình:

103 - 5 - 8 = 90 byte

K, 46 byte

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

c lưu trữ danh sách để chuyển đổi cơ sở

t là hàm tính tổng số tiền

Sử dụng ví dụ:

t[103 16 23;7.25;3]

viết (128;4;24.29209)

Giải trình:

• c/:x chuyển đổi danh sách (galleon; liềm; knuts) thành kuts

• 1+y%100 tính lãi suất (ví dụ 1,0725 cho tỷ lệ 7,25%)

• lambda {z(y*)\x}thực hiện công việc: lặp lại 3 lần, áp dụng interes * main và trả về main cuối cùng.

• c\: tạo ra galleon, liềm, knuts từ knuts

LƯU Ý.- nếu bạn không cần một hàm tên, chúng ta có thể sử dụng lambda, tiết kiệm 2 byte {c\:{z(y*)/x}[c/:x;1+y%100;z]}inputArgs

C # (Trình biên dịch tương tác Visual C #) , 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;

Đưa vào trong như một tuple có tên với 3 giá trị đại diện cho knuts, liềm và galleons, và lãi suất là gấp đôi (không phải là tỷ lệ phần trăm). Tôi thực sự muốn C # có một toán tử lũy thừa. Math.Pow quá dài :(

Hãy thử trực tuyến!

Mẻ, 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%

Đưa đầu vào dưới dạng đối số dòng lệnh theo thứ tự Galleons, Sickles, Knuts, lãi, năm. Lãi suất là một tỷ lệ phần trăm nhưng được biểu thị mà không có dấu%. Cắt ngắn sau mỗi năm. Đầu ra theo thứ tự Galleons, Sickles, Knuts. Hỗ trợ ít nhất 5000 Galleons. Giải trình:

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

Batch chỉ có số học số nguyên. May mắn thay, lãi suất luôn là bội số của 0.125. Chúng tôi bắt đầu bằng cách chia trên dấu thập phân, để itrở thành phần nguyên của lãi suất và fphần thập phân. Chúng sau đó được nhân với 8. Chữ số đầu tiên fbây giờ là số thứ tám trong phần trăm lãi suất.

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

Điều này sau đó được trích xuất bằng cách sử dụng chuỗi cắt và thêm vào để đưa ra lãi suất trong 1/800. Số lượng Knuts cũng được tính toán.

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

Tính toán và thêm vào lãi suất mỗi năm.

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

Chuyển đổi trở lại Galleons và Sickles.

05AB1E (di sản) , 24 byte

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

Cổng câu trả lời Perl 6 của @JoKing , vì vậy hãy đảm bảo nâng cao anh ấy nếu bạn thích câu trả lời này!

Tôi đang sử dụng phiên bản cũ do lỗi trong phiên bản mới £không hoạt động trên các số nguyên, do đó, một chuỗi rõ ràng được xâu chuỗi §(giữa giây •và thứ hai3 ) (cho đến khi lỗi được khắc phục).

Lấy tiền lãi là số thập phân, theo sau là năm, theo sau là danh sách [Knuts, Sickles, Galleons].

Hãy thử trực tuyến.

Giải trình:

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

Xem 05AB1E mẹo này của tôi (phần Làm thế nào để nén các số nguyên lớn? ) Để hiểu tại sao •1ýÑ•là 119493.

APL (NARS), 37 char, 74 byte

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

bản dịch của giải pháp APL rất tốt và rất ít byte của người dùng Graham sang một giải pháp sử dụng một chức năng thay vì đầu vào tiêu chuẩn ... kiểm tra và cách sử dụng nó:

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

(tôi không nói rằng tôi đã hiểu thuật toán)

Perl 5 , 70 byte

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

Hãy thử trực tuyến!