Składane odsetki… dzięki Wizard Money

15

Gringotts to nie tylko skarbiec, ale także renomowana instytucja finansowa i czarodzieje potrzebują pożyczek. Ponieważ nie chcesz dać się porwać goblinom Gringotta, postanowiłeś napisać program do obliczania odsetek. Odsetki są naliczane tylko raz w roku.

Twoim zadaniem jest obliczenie całkowitej kwoty należnej po oprocentowaniu, biorąc pod uwagę kwotę główną, stopę procentową i czas (całe lata), działając w pełnych nominałach pieniędzy czarodzieja, zaokrąglając w dół do najbliższego całego Knuta. Jest 29 brązowych knutów w srebrnym sierpu i 17 sierpów w złotym galeonie.

Przykład

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

Total owed after interest:
 24 Knuts
  4 Sickles
128 Galleons

Uwagi i zasady

  • Dane wejściowe i wyjściowe mogą być w dowolnym dogodnym formacie. Musisz wziąć Knuts, Sierpy, Galeony, stopę procentową i czas. Wszystkie oprócz oprocentowania będą liczbami całkowitymi. Stopa procentowa jest zwiększana o 0,125%.
  • Nie można zagwarantować, że pieniądze wejściowe będą kanoniczne (tzn. Możesz mieć 29 lub więcej Knutów i 17 lub więcej Sierpów).
  • Dane wyjściowe muszą być reprezentacją kanoniczną. (tj. mniej niż 29 knutów i mniej niż 17 sierpów)
  • Sumy należne, do 1000 galeonów, powinny być dokładne z dokładnością do 1 Knut na rok odsetkowy w porównaniu z arbitralnymi obliczeniami precyzji.
    • Możesz zaokrąglać w dół po każdym roku zainteresowania lub tylko pod koniec. Obliczenia referencyjne mogą wziąć to pod uwagę przy kontroli dokładności.

Miłej gry w golfa!

Wołowina
źródło
4
Czy możemy przyjąć stopę procentową w postaci dziesiętnej zamiast procentowej? (np. 0.0725zamiast 7.25)
Shaggy
@Shaggy Chciałbym to również wiedzieć
senox13,
Jeśli pożyczka wynosi dokładnie 1 Knut, a odsetki wynoszą 99% rocznie, a okres wynosi 1 rok, to czy wynik powinien wynosić „1 Knut” czy „2 Knuts”?
Chas Brown
Innymi słowy, proszę wyjaśnić matematyczne znaczenie frazyrounding down
senox13
1
@ChasBrown: 1 Knut. Funkcja obcięcia / podłogi do najbliższego całego Knuta.
Beefster

Odpowiedzi:

6

R , 70 62 bajtów

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

Wypróbuj online!

Przyjmuje dane wejściowe jako d: depozyt w knuts, sierpach, galeonach; i: stopa procentowa jako dziesiętna; y: lata. Wysyła depozyt końcowy w knutsach, sierpach, galeonach. Dzięki @Giuseppe za użycie mnożenia macierzy w celu zaoszczędzenia niektórych bajtów (i wskazanie, jak uniknąć konieczności zawijania na 1e99).

Nick Kennedy
źródło
Nie znam R; co Cię wygrywa?
dfeuer
@dfeuer biorą mod 1e99, więc jeśli twoje galeony osiągną tak wysoką wartość, spadną do zera
Nick Kennedy
Zastanawiam się, co zyskujesz, biorąc je mod 1e99.
dfeuer
Większość funkcji R jest wektoryzowanych. W tym przypadku przekazuję dane wyjściowe przez %%funkcję, którą jest mod. Idealnie, chciałbym zostawić galeony w spokoju, ale biorąc mod liczbowy nieskończoność zwraca NaN, więc właśnie użyłem naprawdę dużej liczby (ale takiej, która jest mała w bajtach). Alternatywy, które wymyśliłem, są dłuższe (np. [ Tio.run / ##JYrLCsIwEEV/... Wypróbuj online!])
Nick Kennedy
@NickKennedy możesz również zrobić 9e99... Możesz też zagrać w golfa do 63 bajtów
Giuseppe
4

Python 3.8 (wersja wstępna) , 75 74 71 bajtów

-1 bajtów dzięki @EmbodimentofIgnorance
-3 bajtów dzięki @xnor

To bierze Knuts, Sierpy i Galeony jako ints, odsetki jako zmiennoprzecinkowe (dziesiętne, nie procentowe), a lata jako int. Zwraca krotkę zawierającą liczbę po zainteresowaniu odpowiednio Knutami, Sierpami i Galeonami.

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

Stosowanie:

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

Wypróbuj online!

senox13
źródło
Dobry chwyt Aktualizacja odpowiedzi
senox13
Pytanie mówi operating in whole denominations of wizard money, rounding down. Miałem rounding downna myśli to, że chop off everything after the decimal point.używanie nagłówka zdecydowanie brzmi jak łatwiejszy sposób robienia rzeczy. Zrobię to dla przyszłych postów, dzięki
senox13
To brzmi bardziej jak „obcinanie” niż „zaokrąglanie”; ale poprosiłem OP o wyjaśnienia (ponieważ wybieranie nitów to nazwa gry tutaj w PPCG :)).
Chas Brown
Nie zgadzam się z tobą, to tylko znaczenie, które zawsze widziałem używane do zaokrąglania w dół, ponieważ zawsze zaokrąglasz do liczby całkowitej poniżej wyniku. W przeciwnym razie jest to zwykłe zaokrąglenie. Pozwolenie OP decydować jest dobrym pomysłem
senox13
Do Twojej wiadomości, użyteczną sztuczką umożliwiającą przetestowanie anonimowych funkcji w TIO jest umieszczenie I\=takiego nagłówka w ten sposób . Wygląda też na to, że k//29//17może być k//493.
xnor
3

APL + WIN, 37 28 26 bajtów

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

2 bajty zapisane dzięki lirtosiast

Wypróbuj online! Dzięki uprzejmości Dyalog Classic

Wyjaśnienie:

(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
źródło
⌊a⊤(⎕⊥⍨a←0 17 29)×⎕*⍨1+⎕za 24?
lirtosiast
@lirtosiast Dzięki, ale obawiam się, że mój starożytny interpreter APL + WIN nie ma funkcji ⍨. Oczywiście, prześlij to jako własne rozwiązanie APL.
Graham
@lirtosiast Dzięki jeszcze raz wziąłem 2 bajty wynikające z przypisania do.
Graham
3

Perl 6 , 47 bajtów

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

Wypróbuj online!

Jestem zaskoczony, że udało mi się przekształcić to w anonimową cokolwiek lambda! Zwłaszcza ta część, w której jest więcej *niż cokolwiek innego. Pobiera dane wejściowe jakointerest rate (e.g. 0.0725), years, [Knuts, Sickles, Galleons] i zwraca listę walut w tej samej kolejności.

Wyjaśnienie:

 (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
źródło
Dziwię się, że nie wymyśliłeś sposobu, aby dopasować liczbę Knutów / Sierpów / Galeonów również do wielorybników. Wtedy byłoby po prostu eh, jak *************************** ;-)
user0721090601
@ guifa The Whatevers są danymi wejściowymi, więc może być naprawdę tylko 3 z nich (chociaż mogę podzielić dane wejściowe waluty na więcej *s, ale więcej bajtów). Reszta *pochodzi z mnożenia ( *) i wykładniczego ( **)
Jo King
Miałem na myśli, jeśli masz w nich również współczynniki konwersji (numer 29/17). Ale oczywiście był to żart, ponieważ trzeba użyć tych liczb więcej niż raz. Przepraszam, jeśli mój humor nie przetrwał
user0721090601
2

Galaretka , 29 bajtów

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

Pełen program, przyjmując argumenty rate; [Galleons, Sickles, Knuts]; years.
Wydruki [Galleons, Sickles, Knuts].

Wypróbuj online!

Podłogi na koniec całego semestru.
÷ȷ2może zostać usunięty, jeśli możemy zaakceptować stawkę jako stosunek, a nie procent.

W jaki sposób?

“¢×ø‘©×\ - 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
źródło
2

Zespół procesora Intel 8087 FPU, 86 bajtów

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

Niezmontowane i udokumentowane:

; 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

Zaimplementowany jako MAKRO (w zasadzie funkcja), jest to kod maszynowy niespecyficzny dla systemu operacyjnego, do obliczeń wykorzystuje jedynie procesor Intel 80x87 FPU / matematyka.

Przykładowy program testowy z wyjściem:

    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

Wynik

wprowadź opis zdjęcia tutaj

640 KB
źródło
1

Japt, 48 bajtów

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

Moja pierwsza próba u Japt, zdobywając nagrodę @ Shaggy! Nie trzeba dodawać, że to nie jest bardzo golfowe :(

Wypróbuj online!

Wcielenie ignorancji
źródło
1

Haskell , 73 bajty

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

Wypróbuj online!

Dzięki @Laikoni za dwa bajty.

Brudne sztuczki: liczba monet na wejściu jest zmiennoprzecinkowa ( Double), podczas gdy liczba monet na wyjściu jest całką ( Integer). Rezultatem jest para zagnieżdżona, ((Galleons, Sickles), Knotts)aby uniknąć konieczności spłaszczania do potrójnego.

Wyjaśnienie

-- 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
źródło
1
Zapisz dwa bajty za pomocą (truncate$ ... )-> truncate( ... )i (g#s)k r nzamiast c g s k r n.
Laikoni,
@Laikoni, wielkie dzięki!
dfeuer
@Laikoni, naprawdę doceniłbym, gdybyś mógł znaleźć dla mnie kilka bajtów w codegolf.stackexchange.com/questions/55960/… , jeśli masz czas.
dfeuer
1
Zajmę się tym, kiedy znajdę czas. Tymczasem mogę wskazać Ci nasz czat Haskell Of Monads and Men, a także to pytanie, które może ci się spodobać, biorąc pod uwagę twoje poligloty Hugs / GHC.
Laikoni,
1

Stax , 24 bajty

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

Uruchom i debuguj

Dane wejściowe to wartości rozdzielone spacjami. interest years knuts sickles galleons

Wyjście jest oddzielone znakiem nowej linii.

knuts
sickles
galleons
rekurencyjny
źródło
1

TI-BASIC (TI-84), 96 90 bajtów

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

Dane wejściowe to Anslista z 5 pozycjami: Knuts, Sierpy, Galeony, Odsetki (dziesiętne) i Czas (lata).
Dane wyjściowe są wprowadzane Ansi są automatycznie drukowane po zakończeniu programu.

Bez golfa:

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

Przykład:

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

Wyjaśnienie:

:SetUpEditor C
:Ans→∟C

Zostanie utworzona nowa lista, ∟CiAns jest w niej zapisywana.

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

Knuts, Sierpy i Galeony są przekształcane w Knuts i przechowywane w T .

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

Pobiera liczbę Knutów i stosuje do nich odsetki złożone.
Odsetki są naliczane tutaj.

:remainder(iPart(T),493→R

Przechowuje I nteger Część z Tmodulo 493 doR . Służy do skrócenia liczby bajtów.

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

Ocenia listę z 3 przedmiotami (knuts, sierpy i galeony). Lista jest automatycznie zapisywana w Ans.


Uwaga: Liczba bajtów jest obliczana na podstawie liczby bajtów podanej w [MEM] [2][7] (lista programów w pamięci RAM) i odejmując liczbę znaków w nazwie programu oraz dodatkowe 8 bajtów użytych dla programu:

103 - 5 - 8 = 90 bajtów

Tau
źródło
0

K, 46 bajtów

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

c zapisz listę do konwersji podstawowej

t to funkcja obliczająca całkowitą kwotę

Użyj przykładu:

t[103 16 23;7.25;3]

pisze (128;4;24.29209)

Wyjaśnienie:

  • c/:x przekształcić listę (galeon; sierp; knuts) w kuts

  • 1+y%100 obliczyć stopę procentową (przykład 1.0725 dla stopy 7,25%)

  • lambda {z(y*)\x}wykonuje pracę: iteruje 3 razy, stosując interes * main, i zwraca ostatnią main.

  • c\: generuje galeon, sierpy, knuty z knutów

UWAGA. - jeśli nie potrzebujesz funkcji nazw, możemy użyć lambda, oszczędzając 2 bajty {c\:{z(y*)/x}[c/:x;1+y%100;z]}inputArgs

J. Sendra
źródło
0

C # (interaktywny kompilator Visual C #) , 86 bajtów

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

Wybiera się jako nazwana krotka z 3 wartościami reprezentującymi knuts, sierpy i galeony, a stopa procentowa jako podwójna (nie procentowa). Naprawdę chciałbym, żeby C # miał operator potęgowania. Math.Pow jest zdecydowanie za długi :(

Wypróbuj online!

Wcielenie ignorancji
źródło
0

Partia, 171 bajtów

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

Pobiera dane wejściowe jako argumenty wiersza polecenia w kolejności Galeony, Sierpy, Knuty, odsetki, lata. Odsetki są procentowe, ale wyrażane bez znaku%. Obcina się po każdym roku. Wyjście jest w kolejności Galeony, Sierpy, Knuty. Obsługuje co najmniej 5000 galeonów. Wyjaśnienie:

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

Partia ma tylko arytmetykę liczb całkowitych. Na szczęście stopa procentowa jest zawsze wielokrotnością 0.125. Zaczynamy od dzielenia na przecinek dziesiętny, dzięki czemu istaje się całkowitą częścią stopy procentowej i fułamkiem dziesiętnym. Są one następnie mnożone przez 8. Pierwsza cyfra fto teraz ósma procentowej stopy procentowej.

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

Jest on następnie wyodrębniany za pomocą odcinania sznurka i dodawany w celu uzyskania stopy procentowej w 1/800. Obliczana jest również liczba Knutów.

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

Oblicz i dodaj odsetki każdego roku.

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

Wróć do Galeonów i Sierpów.

Neil
źródło
0

05AB1E (starsza wersja) , 24 bajty

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

Port odpowiedzi Perl 6 @JoKinga , więc upewnij się, że go również głosujesz, jeśli podoba ci się ta odpowiedź!

Używam starszej wersji z powodu błędu w nowej wersji, £który nie działa na liczbach całkowitych, więc wymagane jest jawne rzutowanie na ciąg znaków §(między drugą a 3) (dopóki błąd nie zostanie naprawiony).

Podaje odsetki jako dziesiętne, po których następuje rok, a następnie lista [Knuts, Sickles, Galeony].

Wypróbuj online.

Wyjaśnienie:

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

Zobacz moją wskazówkę 05AB1E (rozdział Jak kompresować duże liczby całkowite? ), Aby zrozumieć, dlaczego tak •1ýÑ•jest 119493.

Kevin Cruijssen
źródło
0

APL (NARS), 37 znaków, 74 bajty

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

tłumaczenie bardzo dobrego i bardzo mało bajtowego rozwiązania APL przez użytkownika Grahama na rozwiązanie, które używa jednej funkcji zamiast standardowego wejścia ... test i jak z niego korzystać:

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

(nie mówię, że zrozumiałem algorytm)

RosLuP
źródło
0

Perl 5 , 70 bajtów

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

Wypróbuj online!

Xcali
źródło