Wir alle wissen, dass die mit e bezeichnete Euler-Zahl zur Potenz einer Variablen x mit der Erweiterung der Maclaurin-Reihe angenähert werden kann :

Wenn wir x gleich 1 lassen, erhalten wir

Herausforderung

Schreiben Sie ein Programm in einer beliebigen Sprache, die sich der Euler-Zahl annähert, indem Sie eine Eingabe N eingeben und die Reihe mit dem N-ten Term berechnen. Beachten Sie, dass der erste Term den Nenner 0 !, nicht 1 !, hat, dh N = 1 entspricht 1/0 !.

Wertung

Programm mit der geringsten Anzahl von Bytes gewinnt.

Gelee , 5 Bytes

R’!İS

Probieren Sie es online!

Wie es funktioniert

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.

Wehmütig-C - 336 Bytes

Mein erstes echtes Wehmut-Programm! Eigentlich habe ich ein bisschen Golf gespielt, somedayanstatt zu spielen, wait forweil der erste eine kürzere Länge hatte.

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 Bytes

smc1.!

Probieren Sie es hier aus.

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

Danke an FryAmTheEggman für ein Byte!

TI-84 BASIC, 12 15 14

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

TI ist eine Token-Sprache ( Bytes werden über Token gezählt , nicht über einzelne Zeichen).

Julia, 28 27 21 Bytes

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

Dies ist eine anonyme Funktion, die eine Ganzzahl akzeptiert und einen Gleitkommawert zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

Der Ansatz ist recht unkompliziert. We sum1 dividiert durch die Gammafunktion, die bei jedem von 1 bis n ausgewertet wird . Dies nutzt die Eigenschaft n ! = Γ ( n + 1).

Probieren Sie es online!

1 Byte dank Dennis und 6 dank Glen O!

Python, 36 Bytes

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

Gleichstrom, 43 Bytes

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

Dies ist eine ziemlich direkte Übersetzung der Serie. Ich habe versucht, klüger zu sein, aber das führte zu längerem Code.

Erläuterung

[d1-d1<f*]sf

Eine einfache Fakultätsfunktion für n> 0

[dlfx1r/r1-d1<e+]se

Führe die Fakultät für n, ..., 1 aus; invertieren und summieren

1?dk1-

Füllen Sie den Stapel mit 1; Eingaben übernehmen und entsprechende Genauigkeit einstellen

d1<e+

Wenn die Eingabe 0 oder 1 war, können wir sie einfach weitergeben, oder die Teilsumme berechnen.

p

Drucken Sie das Ergebnis.

Testergebnisse

Die ersten 100 Erweiterungen:

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

Mit 1000 Begriffen:

2.7182818284590452353602874713526624977572470936999595749669676277240\
766303535475945713821785251664274274663919320030599218174135966290435\
729003342952605956307381323286279434907632338298807531952510190115738\
341879307021540891499348841675092447614606680822648001684774118537423\
454424371075390777449920695517027618386062613313845830007520449338265\
602976067371132007093287091274437470472306969772093101416928368190255\
151086574637721112523897844250569536967707854499699679468644549059879\
316368892300987931277361782154249992295763514822082698951936680331825\
288693984964651058209392398294887933203625094431173012381970684161403\
970198376793206832823764648042953118023287825098194558153017567173613\
320698112509961818815930416903515988885193458072738667385894228792284\
998920868058257492796104841984443634632449684875602336248270419786232\
090021609902353043699418491463140934317381436405462531520961836908887\
070167683964243781405927145635490613031072085103837505101157477041718\
986106873969655212671546889570350116

J, 10 Bytes

[:+/%@!@i.

Unkomplizierter Ansatz.

Erläuterung

[:+/%@!@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#:+

oder

r~{m!W#}%:+

Probieren Sie es online aus: erste Version und zweite Version

Erläuterung:

r~= lesen und auswerten
m!= faktoriell
W#= zur -1-Potenz erhöhen ( W= -1)
:+= Summe des Arrays Die
erste Version konstruiert das [0… N-1] -Array und wendet faktoriell und invers auf alle seine Elemente an; Die 2. Version führt faktorielle und inverse Operationen für jede Zahl durch und fügt sie dann in ein Array ein.

JavaScript ES6, 44 42 40

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

Eine unbenannte Funktion jetzt.

Vielen Dank für das Speichern von 2 Bytes @AlexA und danke an @LeakyNun für weitere 2 Bytes!

MATL, 11 7 Bytes

:Ygl_^s

4 Bytes gespart dank der Empfehlung von @ Luis, gamma( Yg) zu verwenden

Probieren Sie es online

Erläuterung

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

q_t1Zh

Dies berechnet die Summe mit der hypergeometrischen Funktion ₁ F ₁ ( a ; b ; z ):

Funktioniert auf Octave und auf den Online - Compiler, aber nicht auf Matlab, aufgrund einer Differenz in , wie die hypergeometric Funktion definiert ist (die korrigiert werden).

Probieren Sie es online!

Erläuterung

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 Bytes

#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;}

Ungolfed:

/* 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;
}

Nimmt eine Zahl als Argument, um die Anzahl der Iterationen zu bestimmen.

k (13 Bytes)

Vorbehaltlich von Überläufen für N>20

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

05AB1E, 6 Bytes

$L<!/O

Erklärt

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

Probieren Sie es online aus

Pyke, 10 Bytes

FSBQi^R/)s

Probieren Sie es hier aus!

Oder 8 Bytes, wenn power = 1 ist

FSB1R/)s

Probieren Sie es hier aus!

JavaScript (ES6), 28 Byte

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

Dyalog APL , 6 Bytes

+/÷!⍳⎕

+/Summe
÷der Kehrwerte
!der Fakultäten
⍳der Zahlen von 0 bis zur
⎕numerischen Eingabe

Angenommen ⎕IO←0, das ist auf vielen Systemen Standard.

TryAPL !

Haskell, 37 Bytes

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

Nicht die kürzeste, aber wohl die schönste.

Ebenfalls mit freundlicher Genehmigung von Laikoni ist hier eine Lösung, die 2 Byte kürzer ist:

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 Bytes

⍳⊥⊢÷!

Probieren Sie es online!

Verwenden Sie den gemischten Basistrick, der in meiner Antwort auf eine andere Herausforderung enthalten ist . Verwendet ⎕IO←0.

Wie es funktioniert

⍳⊥⊢÷!  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)!

Eigentlich 6 Bytes

r♂!♂ìΣ

Probieren Sie es online!

Erläuterung:

r♂!♂ìΣ
r       range(N) ([0, N-1])
 ♂!     factorial of each element
   ♂ì   reciprocal of each element
     Σ  sum

Brachylog , 18 Bytes

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

Erläuterung

: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

Ahorn, 18

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

Verwendung:

> f:=n->add(1/i!,i=0..n-1);
> f(1);
  1
> f(4);
  8/3

C 69 Bytes

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

Ideone es!

Java mit zehn Fuß Laser Pole , 238 236 Bytes

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

Besserer Überlaufwiderstand als die meisten anderen Antworten. Für 100 Terme lautet das Ergebnis

31710869445015912176908843526535027555643447320787267779096898248431156738548305814867560678144006224158425966541000436701189187481211772088720561290395499/11665776930493019085212404857033337561339496033047702683574120486902199999153739451117682997019564785781712240103402969781398151364608000000000000000000000

Julia, 28 Bytes

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

Erläuterung

~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)ist gleich factorial(k)für positive Ganzzahleingaben und verallgemeinert es für alle Werte außer den nichtnegativen Ganzzahlen. Es spart ein Byte, warum also nicht?

MATLAB / Octave, 22 Bytes

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

Erstellt eine anonyme Funktion mit dem Namen ans, die mit aufgerufen werden kann ans(N).

Diese Lösung berechnet gamma(x)für jedes Element im Array [1 ... N], das gleich ist factorial(x-1). Wir nehmen dann die Umkehrung jedes Elements und summieren alle Elemente.

Online Demo

Perl 5, 37 Bytes

Kein Gewinner, aber nett und unkompliziert:

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

Ausgänge für Eingänge von 0 bis 10:

1
2
2.5
2.66666666666667
2.70833333333333
2.71666666666667
2.71805555555556
2.71825396825397
2.71827876984127
2.71828152557319
2.71828180114638

R, 17 Bytes

sum(1/gamma(1:n))

Ganz einfach, auch wenn irgendwann Probleme mit der numerischen Genauigkeit auftreten werden.

WolframAlpha , 12 Bytes

sum1/k!,0..n