Nous savons tous que le nombre d'Euler , noté e, à la puissance d'une variable x, peut être approximé en utilisant l' expansion de la série Maclaurin :

En laissant x égal à 1, on obtient

Défi

Écrivez un programme dans n'importe quelle langue qui se rapproche du nombre d'Euler en prenant une entrée N et calcule la série au N-ème terme. Notez que le premier terme a le dénominateur 0 !, pas 1 !, c'est-à-dire que N = 1 correspond à 1/0 !.

Notation

Le programme avec le moins d'octets gagne.

Gelée , 5 octets

R’!İS

Essayez-le en ligne!

Comment ça fonctionne

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 octets

Mon premier vrai programme mélancolique! Il y a en fait un peu de golf que j'ai fait, en utilisant somedayau lieu de wait forparce que le premier avait une longueur plus courte.

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 octets

smc1.!

Essayez-le ici.

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

Merci à FryAmTheEggman pour un octet!

TI-84 BASIC, 12 15 14

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

TI est un langage à jetons (les octets sont comptés via des jetons , pas des caractères individuels).

Julia, 28 27 21 octets

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

Il s'agit d'une fonction anonyme qui accepte un entier et renvoie un flottant. Pour l'appeler, affectez-le à une variable.

L'approche est assez simple. Nous sum1 divisé par la fonction gamma évaluée à chacun de 1 à n . Cela profite de la propriété n ! = Γ ( n +1).

Essayez-le en ligne!

Enregistré 1 octet grâce à Dennis et 6 grâce à Glen O!

Python, 36 octets

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 octets

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

Il s'agit d'une traduction assez directe de la série. J'ai essayé d'être plus intelligent, mais cela a abouti à un code plus long.

Explication

[d1-d1<f*]sf

Une fonction factorielle simple, pour n> 0

[dlfx1r/r1-d1<e+]se

Exécutez la factorielle pour n, ..., 1; inverser et additionner

1?dk1-

Amorcez la pile avec 1; accepter l'entrée et définir une précision appropriée

d1<e+

Si l'entrée était 0 ou 1, nous pouvons simplement la transmettre, sinon calculer la somme partielle.

p

Imprimez le résultat.

Résultats de test

Les 100 premières extensions:

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

En utilisant 1000 termes:

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

J, 10 octets

[:+/%@!@i.

Approche directe.

Explication

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

Essayez-le en ligne: première version et deuxième version

Explication:

r~= lire et évaluer
m!= factoriel
W#= monter à -1 puissance ( W= -1)
:+= somme du tableau La
première version construit le tableau [0… N-1] et applique le factoriel et l'inverse à tous ses éléments; La 2ème version fait factorielle et inverse pour chaque nombre puis les place dans un tableau.

JavaScript ES6, 44 42 40

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

Une fonction sans nom maintenant.

Merci d'avoir sauvé 2 octets @AlexA et merci à @LeakyNun pour encore 2 octets!

MATL, 11 7 octets

:Ygl_^s

4 octets économisés grâce à la recommandation de @ Luis d'utiliser gamma( Yg)

Essayez-le en ligne

Explication

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

q_t1Zh

Ceci calcule la somme en utilisant la fonction hypergéométrique ₁ F ₁ ( a ; b ; z ):

Fonctionne sur Octave et sur le compilateur en ligne, mais pas sur Matlab, en raison d' une différence dans la définition de la fonction hypergéométrique (qui sera corrigée).

Essayez-le en ligne!

Explication

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 octets

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

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

Prend un nombre comme argument pour déterminer le nombre d'itérations.

k (13 octets)

Sous réserve de débordements pour N>20

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

05AB1E, 6 octets

$L<!/O

Expliqué

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

Essayez-le en ligne

Pyke, 10 octets

FSBQi^R/)s

Essayez-le ici!

Ou 8 octets si puissance = 1

FSB1R/)s

Essayez-le ici!

JavaScript (ES6), 28 octets

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

Dyalog APL , 6 octets

+/÷!⍳⎕

+/somme des
÷inverses des
!factorielles des
⍳nombres de 0 à
⎕l'entrée numérique

Suppose ⎕IO←0, qui est par défaut sur de nombreux systèmes.

TryAPL !

Haskell, 37 octets

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

Pas le plus court, mais sans doute le plus joli.

Avec l' aimable autorisation de Laikoni , voici une solution plus courte de 2 octets :

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 octets

⍳⊥⊢÷!

Essayez-le en ligne!

En utilisant l'astuce de base mixte trouvé dans ma réponse d' un autre défi . Utilise ⎕IO←0.

Comment ça fonctionne

⍳⊥⊢÷!  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 fait, 6 octets

r♂!♂ìΣ

Essayez-le en ligne!

Explication:

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

Brachylog , 18 octets

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

Explication

: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

Érable, 18

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

Usage:

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

C, 69 octets

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

Ideone it!

Java avec pôle laser de dix pieds , 238 236 octets

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

A une bien meilleure résistance aux débordements que la plupart des autres réponses. Pour 100 termes, le résultat est

31710869445015912176908843526535027555643447320787267779096898248431156738548305814867560678144006224158425966541000436701189187481211772088720561290395499/11665776930493019085212404857033337561339496033047702683574120486902199999153739451117682997019564785781712240103402969781398151364608000000000000000000000

Julia, 28 octets

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

Explication

~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)est égal à factorial(k)pour les entrées entières positives et le généralise pour toutes les valeurs autres que les entiers non négatifs. Il enregistre un octet, alors pourquoi ne pas l'utiliser?

MATLAB / Octave, 22 octets

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

Crée une fonction anonyme nommée ansqui peut être appelée à l'aide de ans(N).

Cette solution calcule gamma(x)pour chaque élément du tableau [1 ... N] qui est égal à factorial(x-1). Nous prenons ensuite l'inverse de chaque élément et additionnons tous les éléments.

Démo en ligne

Perl 5, 37 octets

Pas un gagnant, mais gentil et simple:

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

Sorties pour entrées de 0 à 10:

1
2
2.5
2.66666666666667
2.70833333333333
2.71666666666667
2.71805555555556
2.71825396825397
2.71827876984127
2.71828152557319
2.71828180114638

R, 17 octets

sum(1/gamma(1:n))

Assez simple, bien que des problèmes de précision numérique surgissent à un moment donné.

WolframAlpha , 12 octets

sum1/k!,0..n