Gringotts는 단순한 금고 일뿐만 아니라 평판이 좋은 금융 기관 및 마법사도 대출이 필요합니다. Gringotts 고블린에 의해 망가지기를 원하지 않기 때문에 관심을 계산하는 프로그램을 작성하는 것이 좋습니다. 이자는 매년 만 복리가됩니다.

귀하의 임무는 교장, 이자율 및 시간 (년 단위)을 고려하여이자 이후 총 빚진 금액을 계산하여 마법사 돈의 전체 명칭으로 작동하며 가장 가까운 전체 Knut으로 내림하는 것입니다. 실버 낫에는 29 개의 브론즈 넛과 골드 갤리온에는 17 개의 낫이 있습니다.

예

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

Total owed after interest:
 24 Knuts
  4 Sickles
128 Galleons

참고 및 규칙

• 입력 및 출력은 편리한 형식 일 수 있습니다. Knuts, Sickles, Galleons, 금리 및 시간을 가져와야합니다. 금리를 제외한 전부는 정수입니다. 이자율은 0.125 % 씩 증가합니다.
• 입력 금액이 정식 일 수는 없습니다 (예 : 29 개 이상의 넛과 17 개 이상의 낫을 가질 수 있음).
• 출력은 표준 표현이어야합니다. (즉, 29 개 미만의 넛과 17 개 미만의 낫)
• 임의의 정밀 계산과 비교할 때 최대 1,000 갤리온의 총 빚은 매년 1 Knut 내에서 정확해야합니다.
  • 매년 관심을 보인 후 또는 끝날 때만 반올림 할 수 있습니다. 참조 계산에서는 정확성 검사를 위해이를 고려할 수 있습니다.

행복한 골프!

R , 70 62 바이트

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

온라인으로 사용해보십시오!

입력을 d로 취합니다 : 넛, 낫, 갤리온에 예금; i : 이자율을 십진수로 표시합니다. y : 년. 견과류, 낫, 갤리온에 최종 예금을 출력합니다. 일부 바이트를 절약하기 위해 행렬 곱셈을 사용하고 1e99에서 줄 바꿈을 피하는 방법을 지적한 @Giuseppe에게 감사드립니다.

Python 3.8 (시험판) , 75 74 71 바이트

@EmbodimentofIgnorance 덕분에 -1 바이트 @@ nor 덕분에
-3 바이트

Knuts, Sickles 및 Galleons는 정수로, 부동 소수점 (백분율이 아닌 10 진수)으로 관심을 기울이고 년을 정수로 사용합니다. Knuts, Sickles 및 Galleons에 각각 관심이있는 숫자를 포함하는 튜플을 반환합니다.

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

용법:

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

온라인으로 사용해보십시오!

APL + WIN, 37 28 26 바이트

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

lirtosiast 덕분에 2 바이트 절약

온라인으로 사용해보십시오! Dyalog Classic 제공

설명:

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

펄 6 , 47 바이트

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

온라인으로 사용해보십시오!

익명으로 뭐든지 람다에 빠지게 된 것에 놀랐습니다! 특히 *다른 것보다 더 중요한 부분 . 입력을 가져와 interest rate (e.g. 0.0725), years, [Knuts, Sickles, Galleons]동일한 순서로 통화 목록을 리턴합니다.

설명:

 (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

젤리 , 29 바이트

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

인수를 받아들이는 전체 프로그램 : rate; [Galleons, Sickles, Knuts]; years.
인쇄 [Galleons, Sickles, Knuts]합니다.

온라인으로 사용해보십시오!

전체 학기 말의 바닥.
÷ȷ2비율이 아닌 비율로 비율을 수락 할 수있는 경우 삭제 될 수 있습니다.

어떻게?

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

Intel 8087 FPU 어셈블리, 86 바이트

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

조립 및 문서화 :

; 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

MACRO (기본적으로 기능)로 구현 된이 제품은 계산에 Intel 80x87 FPU / 수학 보조 프로세서 만 사용하는 OS 특정이 아닌 기계 코드입니다.

출력이있는 테스트 프로그램 예 :

    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

산출

apt, 48 바이트

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

Japt에서 첫 번째 시도, @Shaggy의 현상금으로 이동하십시오! 말할 것도없이, 이것은 매우 골프가 아닙니다 :(

온라인으로 사용해보십시오!

하스켈 , 73 바이트

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

온라인으로 사용해보십시오!

2 바이트 동안 @Laikoni에게 감사드립니다.

더티 트릭 : 입력의 코인 수는 부동 소수점 ( Double)이고 출력의 코인 수는 정수 ( Integer)입니다. 결과는 ((Galleons, Sickles), Knotts)3 중으로 전개되는 것을 피하기 위해 중첩 된 쌍 입니다.

설명

-- 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 바이트

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

실행 및 디버깅

입력은 공백으로 구분 된 값입니다. interest years knuts sickles galleons

출력은 줄 바꿈으로 구분됩니다.

knuts
sickles
galleons

TI-BASIC (TI-84), 96 90 바이트

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

입력은 AnsKnuts, Sickles, Galleons, Interest (decimal) 및 Time (years)의 5 개 항목으로 구성된 목록입니다. 프로그램이 완료되면
출력이 시작 Ans되고 자동으로 인쇄됩니다.

언 골프 :

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

예:

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

설명:

:SetUpEditor C
:Ans→∟C

새로운 목록 인을 ∟C만들어서 Ans저장합니다.

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

Knuts, Sickles 및 Galleons는 Knuts로 변환되어에 저장됩니다 T.

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

Knuts의 양을 취하고 이에 관심을가합니다.
여기에이자가 계산됩니다.

:remainder(iPart(T),493→R

를 저장 I nteger 제 의T 에 모듈 493 R. 바이트 수를 줄이는 데 사용됩니다.

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

3 가지 항목 (Knuts, Sickles 및 Galleons)으로 목록을 평가합니다. 목록은에 자동으로 저장됩니다 Ans.

참고 : 바이트 수는 [MEM] → [2]에 지정된 바이트 수를 사용하여 평가됩니다 . → [7] (RAM의 프로그램 목록)에 프로그램 이름의 문자 수와 프로그램에 사용 된 추가 8 바이트를 빼서 평가합니다.

103-5-8 = 90 바이트

K, 46 바이트

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

c 기본 변환 목록 저장

t 총량을 계산하는 함수입니다

사용 예 :

t[103 16 23;7.25;3]

글을 (128;4;24.29209)

설명:

• c/:x 목록 (갤리온, 낫, 넛)을 kut으로 변환

• 1+y%100 이자율 계산 (예 : 7.25 % 비율의 예 1.0725)

• 람다 {z(y*)\x}는 작업을 수행합니다 : interes * main을 적용하고 3 번 반복하고 마지막 main을 반환합니다.

• c\: 넛에서 갤리온, 낫, 넛을 생성

NOTE.- 만약 이름 함수가 필요하지 않다면 람다를 사용하여 2 바이트를 절약 할 수 있습니다 {c\:{z(y*)/x}[c/:x;1+y%100;z]}inputArgs

C # (Visual C # 대화식 컴파일러) , 86 바이트

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

호두, 낫, 갤리온을 나타내는 3 개의 값과 2 배 (이 아닌 백분율)의 금리로 명명 된 튜플로 인아웃합니다. C #에 지수 연산자가 있었으면 좋겠습니다. Math.Pow가 너무 길다 :(

온라인으로 사용해보십시오!

배치, 171 바이트

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

Galleons, Sickles, Knuts, interest, years 순서로 명령 행 인수로 입력을받습니다. 이자는 백분율이지만 % 기호없이 표시됩니다. 매년마다 잘립니다. 출력은 Galleons, Sickles, Knuts 순서입니다. 최소 5000 갤리온을 지원합니다. 설명:

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

일괄 처리에는 정수 산술 만 있습니다. 다행히 이자율은 항상의 배수입니다 0.125. 우리는 소수점으로 나누는 것으로 시작 i하여 이자율의 정수 부분과 f소수 부분이됩니다. 그런 다음이 숫자에 8을 곱합니다. 첫 번째 숫자 f는 이제 이자율 백분율에서 8 번째 숫자입니다 .

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

그런 다음 문자열 슬라이싱을 사용하여 추출한 후 추가하여 1/800의 금리를 제공합니다. 견과류 수도 계산됩니다.

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

갤리온과 낫으로 다시 변환하십시오.

05AB1E (레거시) , 24 바이트

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

@JoKing 포트 6 답변 하십시오!

£정수에서 작동하지 않는 새 버전의 버그로 인해 레거시 버전을 사용하고 있으므로 명시 적으로 문자열로 캐스팅합니다 §(두 번째 •와3 (버그가 수정 될 때까지) ).

관심을 10 진수로, 그 다음 연도, [Knuts, Sickles, Galleons] 목록을받습니다.

온라인으로 사용해보십시오.

설명:

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

내이 05AB1E 팁을 참조하십시오 (섹션 얼마나 큰 정수를 압축하는 방법을? ) 이유를 이해하는 •1ýÑ•것입니다 119493.

APL (NARS), 37 자, 74 바이트

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

Graham 사용자에 의한 매우 우수하고 매우 적은 바이트 APL 솔루션을 표준 입력 대신 하나의 기능을 사용하는 솔루션으로 변환 ... 테스트 및 사용 방법 :

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

(나는 알고리즘을 이해했다고 말하지 않는다)

펄 5 , 70 바이트

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

온라인으로 사용해보십시오!