Przybliżenie e

21

Wszyscy wiemy, że liczbę Eulera , oznaczoną e, do potęgi jakiejś zmiennej x, można aproksymować za pomocą rozszerzenia Maclaurin Series :

Rozszerzenie e ^ x serii Maclaurin

Pozwalając x równa się 1, otrzymujemy

Rozszerzenie serii e Maclaurin e

Wyzwanie

Napisz program w dowolnym języku, który jest zbliżony do liczby Eulera, przyjmując wartość wejściową N i obliczając szereg na N-ty warunek. Zauważ, że pierwszy termin ma mianownik 0 !, nie 1 !, tj. N = 1 odpowiada 1/0 !.

Punktacja

Program z najmniejszą liczbą bajtów wygrywa.

Meow Mix
źródło
7
Biorąc pod uwagę wystarczająco duże Nwyniki będą takie same, jeśli użyje się liczby zmiennoprzecinkowej o skończonej precyzji. Czy takie zachowanie jest akceptowalne, czy wynik musi być coraz dokładniejszy w miarę Nzbliżania się do nieskończoności?
FryAmTheEggman
12
Niektóre przypadki testowe byłyby fajne.
Lynn
7
(Tego rodzaju problem najlepiej rozwiązać w piaskownicy - jeśli postawisz tam swoje wyzwania, golfiści udzielą użytecznych informacji zwrotnych.)
Lynn
2
Czy x ^ n jest n-tym terminem czy (n + 1)?
msh210
4
Ja osobiście gardzę tym, ale są ludzie, którzy odnoszą się do terminu o indeksie 0 jako terminu zerowego. Niezależnie od naszych przemyśleń na ten temat pytanie powinno być jak najbardziej jasne. Bardzo pomocne byłoby również kilka przypadków testowych do sprawdzenia, czy rozwiązania działają poprawnie.
Dennis

Odpowiedzi:

13

Wistful-C - 336 bajtów

Mój pierwszy prawdziwy smutny program! Grałem trochę w golfa, używając somedayzamiast tego, wait forponieważ pierwszy miał krótszą długość.

if only <stdio.h> were included...
if only int f were 1...
if only int N were 0...
wish for "%d",&N upon a star
if only int i were 0...
if only double e were 0...
someday i will be N...
        if only e were e+1./f...
        if only i were i+1...
        if only f were f*i...
*sigh*
wish "%f\n",e upon a star
if wishes were horses...
Maltysen
źródło
Powiedziano mi, że nie musisz uwzględniać<stdio.h>
Leaky Nun
Czy someday i were N...działa zamiast someday i will be N...?
Leaky Nun
9

TI-84 BASIC, 12 15 14

Input N
Σ(A!⁻¹,A,0,N

TI jest tokenizowanym językiem ( bajty są liczone za pomocą tokenów , a nie pojedynczych znaków).

Bez nazwy
źródło
1
Cytowany meta post ma 11 głosów pozytywnych i 10 głosów negatywnych. To nie jest konsensus. Ansnie jest poprawnym formatem wejściowym, więc poprawna jest tylko wersja 15-bajtowa.
Mego
Słusznie; edycja ...
Brak nazwy
1
Anszawsze był domyślnym formatem wejściowym tutaj w PPCG (przejrzyj moje stare odpowiedzi TI), a więcej osób zgadza się, niż nie zgadzam, więc nie daj się zastraszyć, aby zmienić twoją odpowiedź.
Timtech,
2
@MickLH to nie jest tutaj spór. Poza tym są to 8-bitowe bajty.
hobbs
1
@ Timtech Chociaż zgadzam się z tobą, konsensus społeczności jest zdefiniowany, jak mówi Mego.
Conor O'Brien
9

Julia, 28 27 21 bajtów

n->sum(1./gamma(1:n))

Jest to anonimowa funkcja, która przyjmuje liczbę całkowitą i zwraca liczbę zmiennoprzecinkową. Aby go wywołać, przypisz go do zmiennej.

Podejście jest dość proste. Mamy sum1 podzielone przez funkcję gamma ocenianą dla każdego z 1 do n . Wykorzystuje to właściwość n ! = Γ ( n +1).

Wypróbuj online!

Zaoszczędzono 1 bajt dzięki Dennisowi i 6 dzięki Glen O!

Alex A.
źródło
Prawie dokładnie tak samo w MATLAB:@(n)sum(1./factorial(0:n))
flawr
6

Python, 36 bajtów

Python 2:

f=lambda n,i=1:n/i and 1.+f(n,i+1)/i

Python 3:

f=lambda n,i=1:i<=n and 1+f(n,i+1)/i
xnor
źródło
Python 3 wariant mógłby być krótszy ze orzamiast and: f=lambda n,i=1:i>=n or 1+f(n,i+1)/i.
Konstruktor
6

dc, 43 bajty

[d1-d1<f*]sf[dlfx1r/r1-d1<e+]se1?dk1-d1<e+p

Jest to dość bezpośrednie tłumaczenie serii. Próbowałem być sprytniejszy, ale to spowodowało dłuższy kod.

Wyjaśnienie

[d1-d1<f*]sf

Prosta funkcja silnia dla n> 0

[dlfx1r/r1-d1<e+]se

Wykonaj silnię dla n, ..., 1; odwrócenie i suma

1?dk1-

Zalej stos 1; zaakceptuj dane wejściowe i ustaw odpowiednią dokładność

d1<e+

Jeśli wartość wejściowa wynosiła 0 lub 1, możemy ją po prostu przekazać, w przeciwnym razie obliczyć sumę częściową.

p

Wydrukuj wynik.

Wyniki testu

Pierwsze 100 rozszerzeń:

0
1
2
2.500
2.6666
2.70832
2.716665
2.7180553
2.71825394
2.718278766
2.7182815251
2.71828180110
2.718281826194
2.7182818282857
2.71828182844671
2.718281828458223
2.7182818284589936
2.71828182845904216
2.718281828459045062
2.7182818284590452257
2.71828182845904523484
2.718281828459045235331
2.7182818284590452353584
2.71828182845904523536012
2.718281828459045235360273
2.7182818284590452353602862
2.71828182845904523536028736
2.718281828459045235360287457
2.7182818284590452353602874700
2.71828182845904523536028747123
2.718281828459045235360287471339
2.7182818284590452353602874713514
2.71828182845904523536028747135253
2.718281828459045235360287471352649
2.7182818284590452353602874713526606
2.71828182845904523536028747135266232
2.718281828459045235360287471352662481
2.7182818284590452353602874713526624964
2.71828182845904523536028747135266249759
2.718281828459045235360287471352662497738
2.7182818284590452353602874713526624977552
2.71828182845904523536028747135266249775705
2.718281828459045235360287471352662497757231
2.7182818284590452353602874713526624977572453
2.71828182845904523536028747135266249775724691
2.718281828459045235360287471352662497757247074
2.7182818284590452353602874713526624977572470919
2.71828182845904523536028747135266249775724709352
2.718281828459045235360287471352662497757247093683
2.7182818284590452353602874713526624977572470936984
2.71828182845904523536028747135266249775724709369978
2.718281828459045235360287471352662497757247093699940
2.7182818284590452353602874713526624977572470936999574
2.71828182845904523536028747135266249775724709369995936
2.718281828459045235360287471352662497757247093699959554
2.7182818284590452353602874713526624977572470936999595729
2.71828182845904523536028747135266249775724709369995957475
2.718281828459045235360287471352662497757247093699959574944
2.7182818284590452353602874713526624977572470936999595749646
2.71828182845904523536028747135266249775724709369995957496673
2.718281828459045235360287471352662497757247093699959574966943
2.7182818284590452353602874713526624977572470936999595749669652
2.71828182845904523536028747135266249775724709369995957496696740
2.718281828459045235360287471352662497757247093699959574966967601
2.7182818284590452353602874713526624977572470936999595749669676254
2.71828182845904523536028747135266249775724709369995957496696762747
2.718281828459045235360287471352662497757247093699959574966967627699
2.7182818284590452353602874713526624977572470936999595749669676277220
2.71828182845904523536028747135266249775724709369995957496696762772386
2.718281828459045235360287471352662497757247093699959574966967627724050
2.7182818284590452353602874713526624977572470936999595749669676277240739
2.71828182845904523536028747135266249775724709369995957496696762772407632
2.718281828459045235360287471352662497757247093699959574966967627724076601
2.7182818284590452353602874713526624977572470936999595749669676277240766277
2.71828182845904523536028747135266249775724709369995957496696762772407663006
2.718281828459045235360287471352662497757247093699959574966967627724076630325
2.7182818284590452353602874713526624977572470936999595749669676277240766303508
2.71828182845904523536028747135266249775724709369995957496696762772407663035328
2.718281828459045235360287471352662497757247093699959574966967627724076630353518
2.7182818284590452353602874713526624977572470936999595749669676277240766303535449
2.71828182845904523536028747135266249775724709369995957496696762772407663035354729
2.718281828459045235360287471352662497757247093699959574966967627724076630353547565
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475915
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759429
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594542
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945681
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457111
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571352
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713792
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138185
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382143
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821752
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138217826
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178492
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785218
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138217852481
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525131
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251635
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138217852516607
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166394

Używając 1000 terminów:

2.7182818284590452353602874713526624977572470936999595749669676277240\
766303535475945713821785251664274274663919320030599218174135966290435\
729003342952605956307381323286279434907632338298807531952510190115738\
341879307021540891499348841675092447614606680822648001684774118537423\
454424371075390777449920695517027618386062613313845830007520449338265\
602976067371132007093287091274437470472306969772093101416928368190255\
151086574637721112523897844250569536967707854499699679468644549059879\
316368892300987931277361782154249992295763514822082698951936680331825\
288693984964651058209392398294887933203625094431173012381970684161403\
970198376793206832823764648042953118023287825098194558153017567173613\
320698112509961818815930416903515988885193458072738667385894228792284\
998920868058257492796104841984443634632449684875602336248270419786232\
090021609902353043699418491463140934317381436405462531520961836908887\
070167683964243781405927145635490613031072085103837505101157477041718\
986106873969655212671546889570350116
Toby Speight
źródło
5

J, 10 bajtów

[:+/%@!@i.

Proste podejście.

Wyjaśnienie

[:+/%@!@i.    Input: n
        i.    Creates the range [0, 1, ..., n-1]
      !@      Maps factorial to each
    %@        Map 1/x to each
[:+/          Take the sum of the values and return it
mile
źródło
Ładny. Trywialna poprawa 1-bajtowa:1#.%@!@i.
Jonasz
4

CJam, 11

r~,:m!Wf#:+

lub

r~{m!W#}%:+

Wypróbuj online: pierwsza wersja i druga wersja

Wyjaśnienie:

r~= odczyt i ocena
m!= silnia
W#= podniesienie do potęgi -1 ( W= -1)
:+= suma tablicy
Pierwsza wersja konstruuje tablicę [0… N-1] i stosuje silnię i odwrotność do wszystkich jej elementów; Druga wersja robi silnię i odwrotność dla każdej liczby, a następnie umieszcza je w tablicy.

aditsu
źródło
4

JavaScript ES6, 44 42 40

n=>{for(k=s=m=1;m<n;s+=k/=m++);return s}

Teraz funkcja bez nazwy.

Dzięki za zapisanie 2 bajtów @AlexA i dzięki @LeakyNun za kolejne 2 bajty!

ಠ_ಠ
źródło
n=>{for(k=s=m=1;m<n;s+=k/=m++);return s}
Leaky Nun
4

MATL, 11 7 bajtów

:Ygl_^s

4 bajty zapisane dzięki rekomendacji @ Luis do użycia gamma( Yg)

Wypróbuj online

Wyjaśnienie

        % Implicitly grab input (N)
:       % Create an array from 1...N
Yg      % Compute factorial(x-1) for each element (x) in the array
l_^     % Take the inverse
s       % Sum all elements
        % Implicitly display the result
Suever
źródło
Możesz usunąć]
Luis Mendo
Również 1i:Yg/sdla 7 bajtów
Luis Mendo
@LuisMendo o tak, miałem nadzieję, że istnieje lepszy sposób na uzyskanie silni, ale zapomniałem o gamma. Wkrótce się zaktualizuje
Suever,
4

MATL , 6 bajtów

q_t1Zh

To oblicza sumę za pomocą funkcji hipergeometrycznej 1 F 1 ( a ; b ; z ):

enter image description here

Działa na Octave i kompilatorze online, ale nie na Matlabie, ze względu na różnicę w definiowaniu funkcji hipergeometrycznej (która zostanie poprawiona).

Wypróbuj online!

Wyjaśnienie

q_    % Take N implicitly. Compute -N+1
t     % Duplicate
1     % Push 1
Zh    % Hypergeometric function 1F1(-N+1;-N+1;1). Implicitly display
Luis Mendo
źródło
4

C, 249 bajtów

#include <stdio.h>
#include <stdlib.h>
#define z double
z f(z x){z r=1;z n=1;while(x>0){r*=n;n++;x--;}return r;}int main(int argc, char **argv){z e=0;z p=0;z d=0;p=strtod(argv[1],NULL);while(p>0){e+=1.0d/f(d);printf("%.10f\n",e);p--;d++;}return 0;}

Nie golfowany:

/* approximate e */

#include <stdio.h>
#include <stdlib.h>

double fact(double x){
    double result = 1;
    double num = 1;

    while (x > 0){
        result *= num;
        num++;
        x--;
    }
    return result;
}

int main(int argc, char **argv){
    double e = 0;
    double precision = 0;
    double denom = 0;

    precision = strtod(argv[1], NULL);
    while (precision > 0){
        e += 1.0d / fact(denom);
        printf("%.10f\n", e);
        precision--;
        denom++;
    }
    return 0;
}

Bierze liczbę jako argument w celu ustalenia liczby iteracji.

LordCreepity
źródło
Witaj i witaj w PPCG! Świetny pierwszy post!
NoOneIsHere
Witamy w Programowaniu Puzzle i Code Golf! Myślę, że program ma wydrukować tylko ostatnie przybliżenie. Przynajmniej z GCC nie potrzebujesz intwcześniejszych maini return 0. Ponadto, jeśli zastąpi NULLsię 0, nie trzeba includes. argci argvmoże być skrócony do zmiennych jednoliterowych. Jeśli lubisz grać w golfa w C, pomocne mogą być porady dotyczące gry w golfa w C.
Dennis
IMHO, nawet jeśli kompilator zgłasza pewne ostrzeżenia, ale mimo to zwraca poprawny wynik, możesz wyrzucić wiele części kodu do tego stopnia, że ​​nic nie można zmniejszyć bez błędu.
Andreï Kostyrka
I nie potrzebujesz#include <stdio.h>
Leaky Nun
3

k (13 bajtów)

Z zastrzeżeniem przepełnienia dla N>20

{+/%*\1,1+!x}
skeevey
źródło
3

05AB1E, 6 bajtów

$L<!/O

Wyjaśniono

$           # push 1 and input: N = 5
 L<         # range [0..N-1]: [0,1,2,3,4]
   !        # factorial over range [1,1,2,6,24]
    /       # divide 1/range: [1.0, 1.0, 0.5, 0.16666666666666666, 0.041666666666666664]
     O      # sum: 2.708333333333333

Wypróbuj online

Emigna
źródło
1
5 bajtów z L<!zO.
Grimmy,
3

Pyke, 10 bajtów

FSBQi^R/)s

Wypróbuj tutaj!

Lub 8 bajtów, jeśli moc = 1

FSB1R/)s

Wypróbuj tutaj!

niebieski
źródło
pierwszy kod był wyłączony o więcej niż 3, kiedy go uruchomiłem: 5.436532738095238
tox123
@ tox123 naprawione teraz
Blue
testujesz je? Dostałem: 7.3887125220458545 po raz pierwszy, drugi działa znacznie lepiej.
tox123
Ten jest e ^ x, którego znasz nie tylko e
Blue
to nie wyzwanie.
tox123
3

JavaScript (ES6), 28 bajtów

f=(n,i=1)=>n&&1+f(n-1,i+1)/i
Neil
źródło
3

Dyalog APL , 6 bajtów

+/÷!⍳⎕

+/suma
÷odwrotności
!silni
liczb od 0 do
wprowadzania liczbowego

Zakłada się ⎕IO←0, że jest to domyślne w wielu systemach.

TryAPL !

Adám
źródło
3

Haskell, 37 bajtów

((scanl(+)0$(1/)<$>scanl(*)1[1..])!!)

Nie najkrótszy, ale prawdopodobnie najładniejszy.


Również dzięki uprzejmości Laikoni , oto rozwiązanie o 2 bajty krótsze:

sum.(`take`((1/)<$>scanl(*)1[1..]))

λ> let f = ((scanl (+) 0 $ (1/) <$> scanl (*) 1 [1..]) !!)

λ> map f [1..5]
[1.0,2.0,2.5,2.6666666666666665,2.708333333333333]

λ> f 10
2.7182815255731922

λ> f 100
2.7182818284590455

λ> log (f 10)
0.9999998885745155

λ> log (f 100)
1.0
Rodrigo de Azevedo
źródło
2
Możesz użyć tego licznika bajtów UTF-8 . Wprowadziłem sugerowaną edycję, aby dodać liczbę bajtów, czyli 50. Aby dodać nagłówek, należy: ## Language, <xxx> bytes.
NoOneIsHere
1
Potrzebujesz białych znaków?
NoOneIsHere
1
Nie można zakładać, że dane wejściowe są obecne w zmiennej, dlatego należy wcześniej wstawić f n=lub \n->uzyskać prawidłowe przesłanie funkcji. Możemy jednak również zapisać kilka bajtów: (\x->1/x)można go skrócić do sekcji (1/), [1,2..]jest taki sam jak [1..]i map(...)$może być(...)<$> . Razem 36 bajtów: Wypróbuj online!
Laikoni
1
Konwersja na funkcję bez punktów oszczędza kolejny bajt: Wypróbuj online! I chociaż jest to bajt dłuższy, ((scanl(+)0$(1/)<$>scanl(*)1[1..])!!)wygląda również ładnie.
Laikoni
1
Jak już widzieliście, wersja bez nawiasów jest tylko prawidłowym wyrażeniem Haskell podczas wstawiania wartości po nim, ale ponieważ zakładanie, że dane wejściowe w predefiniowanej zmiennej są niedozwolone , należy dodać nawiasy lub ponownie wiodącą stronę \n->do utworzenia funkcja.
Laikoni,
3

APL (Dyalog Unicode) , 5 bajtów

⍳⊥⊢÷!

Wypróbuj online!

Używając sztuczki o mieszanej podstawie, znalezionej w mojej odpowiedzi na inne wyzwanie . Zastosowania ⎕IO←0.

Jak to działa

⍳⊥⊢÷!  Right argument: n, the number of terms
  ⊢÷!  v: 1÷(n-1)!
      B: The array of 0 .. n-1
      Expand v to length-n array V,
       then mixed base conversion of V in base B

Base | Digit | Value
--------------------
0    | v     | v×(1×2×..×(n-1)) = 1÷0!
1    | v     | v×(2×3×..×(n-1)) = 1÷1!
2    | v     | v×(3×..×(n-1))   = 1÷2!
..   | ..    | ..
n-2  | v     | v×(n-1)          = 1÷(n-2)!
n-1  | v     | v                = 1÷(n-1)!
Bubbler
źródło
10 000 powtórzeń! Teraz zobaczę, czy uda mi się to zrobić w maszynie Turinga ....
ouflak
Dobra odpowiedź, ale mam problem z dostrzeżeniem 1÷(n-1)!cyfry? Czy możesz to przetłumaczyć na J, aby to wyjaśnić?
Jonasz
2

Właściwie 6 bajtów

r♂!♂ìΣ

Wypróbuj online!

Wyjaśnienie:

r♂!♂ìΣ
r       range(N) ([0, N-1])
 ♂!     factorial of each element
   ♂ì   reciprocal of each element
     Σ  sum
Mego
źródło
2

Brachylog , 18 bajtów

:1-:0r:ef:$!a:/a+.

Wyjaśnienie

:1-                 Subtract 1 from Input
   :0r              Create the list [0, Input - 1]
      :ef           Find all integers between 0 and Input - 1
         :$!a       Apply factorial to each member of that list
             :/a    Apply inverse to each element of that list
                +.  Unify the output with the sum of the list
Fatalizować
źródło
2

Klon, 18

add(1/i!,i=0..n-1)

Stosowanie:

> f:=n->add(1/i!,i=0..n-1);
> f(1);
  1
> f(4);
  8/3
DSkoog
źródło
Myślę, że funkcja jest n-> add (1 / i!, I = 0..n-1)
RosLuP
2

C, 69 bajtów

double f(int n){double s=1,f=1;for(int i=0;i++<n;s+=f)f/=i;return s;}

Ideone to!

Leaky Nun
źródło
2

Java z dziesięciostopowym biegunem laserowym , 238 236 bajtów

import sj224.tflp.math.*;interface U{static void main(String[]a){BigRational r=null,s,t;r=s=t=r.ONE;for(int n=new java.util.Scanner(System.in).nextInt()-1;n-->0;){t=t.multiply(r);s=s.add(t.pow(-1));r=r.add(r.ONE);}System.out.print(s);}}

Ma znacznie lepszą odporność na przelewanie niż większość innych odpowiedzi. Wynik dla 100 terminów to

31710869445015912176908843526535027555643447320787267779096898248431156738548305814867560678144006224158425966541000436701189187481211772088720561290395499/11665776930493019085212404857033337561339496033047702683574120486902199999153739451117682997019564785781712240103402969781398151364608000000000000000000000
SuperJedi224
źródło
2

Julia, 28 bajtów

~k=k<1?1:1/gamma(k+1)+~(k-1)

Wyjaśnienie

~k=                    #Define ~ to be
    k<1                #If k is less than 1
        ?1             #to be one
        :1/gamma(k+1)  #else add the reciprocal factorial to 
            +~(k-1)    #the function applied to the predecessor value

gamma(k+1)jest równy factorial(k)dla dodatnich liczb całkowitych i uogólnia je dla wszystkich wartości innych niż nieujemne liczby całkowite. Oszczędza jeden bajt, więc dlaczego go nie użyć?

eaglgenes101
źródło
1

MATLAB / Octave, 22 bajty

@(x)sum(1./gamma(1:x))

Tworzy anonimową funkcję o nazwie, ansktórą można wywołać za pomocą ans(N).

To rozwiązanie oblicza gamma(x)dla każdego elementu w tablicy [1 ... N], który jest równy factorial(x-1). Następnie bierzemy odwrotność każdego elementu i sumujemy wszystkie elementy.

Demo online

Suever
źródło
1

Perl 5, 37 bajtów

Nie zwycięzca, ale miły i bezpośredni:

$e=$p=1;$e+=1/($p*=$_)for 1..<>;say$e

Wyjścia dla wejść od 0 do 10:

1
2
2.5
2.66666666666667
2.70833333333333
2.71666666666667
2.71805555555556
2.71825396825397
2.71827876984127
2.71828152557319
2.71828180114638
Hobbs
źródło
1

R, 17 bajtów

sum(1/gamma(1:n))

Całkiem proste, choć w pewnym momencie mogą pojawić się problemy z precyzją liczbową.

Andreï Kostyrka
źródło