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

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

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.

Galaretka , 5 bajtów

R’!İS

Wypróbuj online!

Jak to działa

R’!İS  Main link. Argument: n

R      Yield the range [1, ..., n].
 ’     Map decrement over the list.
  !    Map factorial over the list.
   İ   Map inverse over the list.
    S  Compute the sum.

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

Pyth, 7 6 bajtów

smc1.!

Wypróbuj tutaj.

 m      map over range 0..input:
    .!  factorial
  c1    1 / ^
s       sum

Dzięki FryAmTheEggman za bajt!

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

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!

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

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

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

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.

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!

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

MATL , 6 bajtów

q_t1Zh

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

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

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.

k (13 bajtów)

Z zastrzeżeniem przepełnienia dla N>20

{+/%*\1,1+!x}

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

Pyke, 10 bajtów

FSBQi^R/)s

Wypróbuj tutaj!

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

FSB1R/)s

Wypróbuj tutaj!

JavaScript (ES6), 28 bajtów

f=(n,i=1)=>n&&1+f(n-1,i+1)/i

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 !

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

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

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

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

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

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!

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

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ć?

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

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

R, 17 bajtów

sum(1/gamma(1:n))

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

WolframAlpha , 12 bajtów

sum1/k!,0..n