Todos sabemos que o número de Euler , indicado por e, à potência de alguma variável x, pode ser aproximado usando a expansão da série Maclaurin :

Ao deixar x igual a 1, obtemos

Desafio

Escreva um programa em qualquer idioma que se aproxime do número de Euler, inserindo uma entrada N e calculando a série para o nono termo. Observe que o primeiro termo tem denominador 0 !, não 1 !, ou seja, N = 1 corresponde a 1/0 !.

Pontuação

Programa com menos quantidade de bytes ganhos.

Gelatina , 5 bytes

R’!İS

Experimente online!

Como 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

Meu primeiro programa de verdade! Na verdade, eu pratiquei um pouco de golfe, usando ao somedayinvés de wait forporque o primeiro tinha um comprimento menor.

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

Pitão, 7 6 bytes

smc1.!

Experimente aqui.

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

Obrigado a FryAmTheEggman por um byte!

TI-84 BASIC, 12 15 14

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

A TI é um idioma tokenizado (os bytes são contados por tokens , não por caracteres individuais).

Julia, 28 27 21 bytes

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

Esta é uma função anônima que aceita um número inteiro e retorna um número flutuante. Para chamá-lo, atribua-o a uma variável.

A abordagem é bastante direta. Nós sum1 dividido pela função gama avaliada em cada um de 1 a n . Isso tira proveito da propriedade n ! = Γ ( n +1).

Experimente online!

Guardou 1 byte graças a Dennis e 6 graças 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

dc, 43 bytes

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

Esta é uma tradução bastante direta da série. Tentei ser mais inteligente, mas isso resultou em um código mais longo.

Explicação

[d1-d1<f*]sf

Uma função fatorial simples, para n> 0

[dlfx1r/r1-d1<e+]se

Execute o fatorial para n, ..., 1; inverter e somar

1?dk1-

Prepare a pilha com 1; aceite a entrada e defina uma precisão apropriada

d1<e+

Se a entrada foi 0 ou 1, podemos apenas transmiti-la, senão calcular a soma parcial.

p

Imprima o resultado.

Resultado dos testes

As 100 primeiras expansões:

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 termos:

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

J, 10 bytes

[:+/%@!@i.

Abordagem direta.

Explicação

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

ou

r~{m!W#}%:+

Experimente online: primeira versão e segunda versão

Explicação:

r~= ler e avaliar
m!= fatorial
W#= elevar à potência -1 ( W= -1)
:+= soma da matriz A
primeira versão constrói a matriz [0… N-1] e aplica fatorial e inversa a todos os seus elementos; A segunda versão faz fatorial e inversa para cada número e os coloca em uma matriz.

JavaScript ES6, 44 42 40

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

Uma função sem nome agora.

Obrigado por salvar 2 bytes @AlexA e obrigado a @LeakyNun por mais 2 bytes!

MATL, 11 7 bytes

:Ygl_^s

4 bytes salvos graças à recomendação de @ Luis de usar gamma( Yg)

Experimente Online

Explicação

        % 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

Isso calcula a soma usando a função hipergeométrica ₁ F ₁ ( a ; b ; z ):

Funciona no Octave e no compilador on-line, mas não no Matlab, devido a uma diferença na forma como a função hipergeométrica é definida (que será corrigida).

Experimente online!

Explicação

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

Leva um número como argumento para determinar o número de iterações.

k (13 bytes)

Sujeito a estouros para 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

Experimente online

Pyke, 10 bytes

FSBQi^R/)s

Experimente aqui!

Ou 8 bytes se poder = 1

FSB1R/)s

Experimente aqui!

JavaScript (ES6), 28 bytes

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

Dyalog APL , 6 bytes

+/÷!⍳⎕

+/soma dos
÷recíprocos dos
!fatoriais dos
⍳números de 0 a
⎕entrada numérica

Supõe ⎕IO←0, que é padrão em muitos sistemas.

TryAPL !

Haskell, 37 bytes

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

Não é o mais curto, mas sem dúvida o mais bonito.

Também cortesia de Laikoni , aqui está uma solução que é 2 bytes mais curta:

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

⍳⊥⊢÷!

Experimente online!

Usando o truque de base mista encontrado na minha resposta de outro desafio . Usos⎕IO←0 .

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

Na verdade, 6 bytes

r♂!♂ìΣ

Experimente online!

Explicação:

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

Braquilog , 18 bytes

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

Explicação

: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

Maple, 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 com pólo a laser de dez pés , 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);}}

Tem muito melhor resistência a transbordamento do que a maioria das outras respostas. Por 100 termos, o resultado é

31710869445015912176908843526535027555643447320787267779096898248431156738548305814867560678144006224158425966541000436701189187481211772088720561290395499/11665776930493019085212404857033337561339496033047702683574120486902199999153739451117682997019564785781712240103402969781398151364608000000000000000000000

Julia, 28 bytes

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

Explicação

~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)é igual a factorial(k)para entradas inteiras positivas e o generaliza para todos os valores, exceto os inteiros não negativos. Ele economiza um byte, então por que não usá-lo?

MATLAB / oitava, 22 bytes

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

Cria uma função anônima chamada ansque pode ser chamada usando ans(N).

Esta solução calcula gamma(x)para cada elemento na matriz [1 ... N] que é igual a factorial(x-1). Em seguida, tomamos o inverso de cada elemento e somamos todos os elementos.

Demo Online

Perl 5, 37 bytes

Não é um vencedor, mas agradável e direto:

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

Saídas 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))

Muito simples, embora problemas de precisão numérica devam surgir em algum momento.

WolframAlpha , 12 bytes

sum1/k!,0..n