Sappiamo tutti che il numero di Eulero , indicato da e, alla potenza di una variabile x, può essere approssimato usando l' espansione della serie Maclaurin :

Lasciando x uguale a 1, otteniamo

Sfida

Scrivi un programma in qualsiasi lingua che si avvicini al numero di Eulero inserendo un input N e calcoli le serie sull'ennesimo termine. Nota che il primo termine ha il denominatore 0 !, non 1 !, ovvero N = 1 corrisponde a 1/0 !.

punteggio

Il programma con il minor numero di byte vince.

Gelatina , 5 byte

R’!İS

Provalo online!

Come funziona

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 byte

Il mio primo vero programma malinconico! In realtà ho praticato un po 'di golf, usando somedayinvece che wait forperché il primo aveva una lunghezza inferiore.

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 byte

smc1.!

Provalo qui.

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

Grazie a FryAmTheEggman per un byte!

TI-84 BASIC, 12 15 14

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

TI è un linguaggio tokenizzato (i byte vengono contati tramite token , non singoli caratteri).

Julia, 28 27 21 byte

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

Questa è una funzione anonima che accetta un numero intero e restituisce un float. Per chiamarlo, assegnarlo a una variabile.

L'approccio è piuttosto semplice. Abbiamo sum1 diviso per la funzione gamma valutata da 1 a n . Questo sfrutta la proprietà n ! = Γ ( n +1).

Provalo online!

Salvato 1 byte grazie a Dennis e 6 grazie a Glen O!

Python, 36 byte

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 byte

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

Questa è una traduzione abbastanza diretta della serie. Ho cercato di essere più intelligente, ma ciò ha comportato un codice più lungo.

Spiegazione

[d1-d1<f*]sf

Una semplice funzione fattoriale, per n> 0

[dlfx1r/r1-d1<e+]se

Eseguire il fattoriale per n, ..., 1; inverti e somma

1?dk1-

Prime lo stack con 1; accetta input e imposta una precisione appropriata

d1<e+

Se l'input era 0 o 1, possiamo semplicemente passarlo, altrimenti calcolare la somma parziale.

p

Stampa il risultato.

Risultati del test

Le prime 100 espansioni:

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

Utilizzando 1000 termini:

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

J, 10 byte

[:+/%@!@i.

Approccio diretto.

Spiegazione

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

Provalo online: prima versione e seconda versione

Spiegazione:

r~= leggi e valuta
m!= fattoriale
W#= aumenta alla potenza -1 ( W= -1)
:+= somma dell'array La
prima versione costruisce l' array [0… N-1] e applica fattoriale e inverso a tutti i suoi elementi; La seconda versione fa fattoriale e inversa per ciascun numero, quindi li inserisce in un array.

JavaScript ES6, 44 42 40

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

Una funzione senza nome ora.

Grazie per aver salvato 2 byte @AlexA e grazie a @LeakyNun per altri 2 byte!

MATL, 11 7 byte

:Ygl_^s

4 byte salvati grazie alla raccomandazione di @ Luis di usare gamma( Yg)

Provalo online

Spiegazione

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

q_t1Zh

Questo calcola la somma usando la funzione ipergeometrica ₁ F ₁ ( a ; b ; z ):

Funziona su Octave e sul compilatore online, ma non su Matlab, a causa di una differenza nella modalità di definizione della funzione ipergeometrica (che verrà corretta).

Provalo online!

Spiegazione

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 byte

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

Accetta un numero come argomento per determinare il numero di iterazioni.

k (13 byte)

Con riserva di tracimazione per N>20

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

05AB1E, 6 byte

$L<!/O

spiegato

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

Provalo online

Pyke, 10 byte

FSBQi^R/)s

Provalo qui!

O 8 byte se potenza = 1

FSB1R/)s

Provalo qui!

JavaScript (ES6), 28 byte

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

Dyalog APL , 6 byte

+/÷!⍳⎕

+/somma dei
÷reciproci dei
!fattoriali dei
⍳numeri da 0 a
⎕input numerici

Presuppone ⎕IO←0, che è predefinito su molti sistemi.

TryAPL !

Haskell, 37 byte

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

Non il più corto, ma probabilmente il più bello.

Anche per gentile concessione di Laikoni , ecco una soluzione che è più corta di 2 byte :

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 byte

⍳⊥⊢÷!

Provalo online!

Usando il trucco di base misto trovato nella mia risposta di un'altra sfida . Usi ⎕IO←0.

Come funziona

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

In realtà, 6 byte

r♂!♂ìΣ

Provalo online!

Spiegazione:

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

Brachylog , 18 byte

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

Spiegazione

: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

Acero, 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 byte

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

Ideone esso!

Java con palo laser a dieci piedi , 238 236 byte

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

Ha una resistenza all'overflow molto migliore rispetto alla maggior parte delle altre risposte. Per 100 termini, il risultato è

31710869445015912176908843526535027555643447320787267779096898248431156738548305814867560678144006224158425966541000436701189187481211772088720561290395499/11665776930493019085212404857033337561339496033047702683574120486902199999153739451117682997019564785781712240103402969781398151364608000000000000000000000

Julia, 28 byte

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

Spiegazione

~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)è uguale a factorial(k)per gli input interi positivi e lo generalizza per tutti i valori diversi dagli interi non negativi. Salva un byte, quindi perché non usarlo?

MATLAB / Ottava, 22 byte

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

Crea una funzione anonima denominata ansche può essere chiamata utilizzando ans(N).

Questa soluzione calcola gamma(x)per ciascun elemento dell'array [1 ... N] che è uguale afactorial(x-1) . Quindi prendiamo l'inverso di ogni elemento e sommiamo tutti gli elementi.

Demo online

Perl 5, 37 byte

Non un vincitore, ma simpatico e semplice:

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

Uscite per ingressi da 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 byte

sum(1/gamma(1:n))

Abbastanza semplice, anche se i problemi di precisione numerica sono destinati a sorgere ad un certo punto nel tempo.

WolframAlpha , 12 byte

sum1/k!,0..n