Todos sabemos que el número de Euler , denotado por e, a la potencia de alguna variable x, puede aproximarse usando la expansión de la serie Maclaurin :

Al dejar que x sea igual a 1, obtenemos

Desafío

Escriba un programa en cualquier idioma que se aproxime al número de Euler tomando una entrada N y calcule la serie al término N-ésimo. Tenga en cuenta que el primer término tiene el denominador 0 !, no 1 !, es decir, N = 1 corresponde a 1/0 !.

Puntuación

Programa con la menor cantidad de bytes gana.

Jalea , 5 bytes

R’!İS

Pruébalo en línea!

Cómo funciona

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 bytes

¡Mi primer programa melancólico! En realidad, hice un poco de golf, con el uso en somedaylugar de wait forporque el primero tenía una longitud más corta.

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

Pruébalo aquí

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

¡Gracias a FryAmTheEggman por un byte!

TI-84 BÁSICO, 12 15 14

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

TI es un lenguaje tokenizado (los bytes se cuentan mediante tokens , no caracteres individuales).

Julia, 28 27 21 bytes

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

Esta es una función anónima que acepta un entero y devuelve un flotante. Para llamarlo, asígnelo a una variable.

El enfoque es bastante sencillo. Nos sum1 dividido por la función gamma evaluado en cada uno de 1 a n . Esto aprovecha la propiedad n ! = Γ ( n +1).

Pruébalo en línea!

¡Ahorré 1 byte gracias a Dennis y 6 gracias a 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

cc, 43 bytes

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

Esta es una traducción bastante directa de la serie. Traté de ser más inteligente, pero eso resultó en un código más largo.

Explicación

[d1-d1<f*]sf

Una función factorial simple, para n> 0

[dlfx1r/r1-d1<e+]se

Ejecute el factorial para n, ..., 1; invertir y sumar

1?dk1-

Prepara la pila con 1; aceptar entrada y establecer una precisión adecuada

d1<e+

Si la entrada fue 0 o 1, podemos pasarla, de lo contrario, calcular la suma parcial.

p

Imprime el resultado.

Resultados de la prueba

Las primeras 100 expansiones:

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

Usando 1000 términos:

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

J, 10 bytes

[:+/%@!@i.

Enfoque directo.

Explicación

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

o

r~{m!W#}%:+

Pruébelo en línea: primera versión y segunda versión

Explicación:

r~= leer y evaluar
m!= factorial
W#= elevar a la potencia -1 ( W= -1)
:+= suma de la matriz La
primera versión construye la matriz [0 ... N-1] y aplica factorial e inverso a todos sus elementos; La segunda versión hace factorial e inverso para cada número y luego los coloca en una matriz.

JavaScript ES6, 44 42 40

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

Una función sin nombre ahora.

¡Gracias por guardar 2 bytes @AlexA y gracias a @LeakyNun por otros 2 bytes!

MATL, 11 7 bytes

:Ygl_^s

4 bytes guardados gracias a la recomendación de @ Luis de usar gamma( Yg)

Pruébalo en línea

Explicación

        % 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

Esto calcula la suma usando el función hipergeométrica ₁ F ₁ ( a ; b ; z ):

Funciona en Octave y en el compilador en línea, pero no en Matlab, debido a una diferencia en cómo se define la función hipergeométrica (que se corregirá).

Pruébalo en línea!

Explicación

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

Sin golf:

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

Toma un número como argumento para determinar el número de iteraciones.

k (13 bytes)

Sujeto a desbordamientos por N>20

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

05AB1E, 6 bytes

$L<!/O

Explicado

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

Pruébalo en línea

Pyke, 10 bytes

FSBQi^R/)s

Pruébalo aquí!

O 8 bytes si potencia = 1

FSB1R/)s

Pruébalo aquí!

JavaScript (ES6), 28 bytes

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

Dyalog APL , 6 bytes

+/÷!⍳⎕

+/suma de
÷los recíprocos de
!los factoriales de
⍳los números de 0 a
⎕entrada numérica

Asume ⎕IO←0, lo cual es predeterminado en muchos sistemas.

TryAPL !

Haskell, 37 bytes

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

No es el más corto, pero podría decirse que es el más bonito.

También cortesía de Laikoni , aquí hay una solución que es 2 bytes más corta:

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

⍳⊥⊢÷!

Pruébalo en línea!

Usando el truco de base mixta que se encuentra en mi respuesta de otro desafío . Usos ⎕IO←0.

Cómo funciona

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

En realidad, 6 bytes

r♂!♂ìΣ

Pruébalo en línea!

Explicación:

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

Brachylog , 18 bytes

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

Explicación

: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

Arce, 18

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

Uso:

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

Java con poste láser de diez pies , 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);}}

Tiene una resistencia al desbordamiento mucho mejor que la mayoría de las otras respuestas. Para 100 términos, el resultado es

31710869445015912176908843526535027555643447320787267779096898248431156738548305814867560678144006224158425966541000436701189187481211772088720561290395499/11665776930493019085212404857033337561339496033047702683574120486902199999153739451117682997019564785781712240103402969781398151364608000000000000000000000

Julia, 28 bytes

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

Explicación

~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)es igual a factorial(k)las entradas de enteros positivos, y lo generaliza para todos los valores que no sean los enteros no negativos. Guarda un byte, entonces, ¿por qué no usarlo?

MATLAB / Octave, 22 bytes

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

Crea una función anónima llamada a la ansque se puede llamar usando ans(N).

Esta solución calcula gamma(x)para cada elemento en la matriz [1 ... N] que es igual a factorial(x-1). Luego tomamos el inverso de cada elemento y sumamos todos los elementos.

Demo en línea

Perl 5, 37 bytes

No es un ganador, pero agradable y directo:

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

Salidas para entradas de 0 a 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))

Muy sencillo, aunque es probable que surjan problemas de precisión numérica en algún momento.

WolframAlpha , 12 bytes

sum1/k!,0..n