Kita semua tahu bahwa angka Euler , dilambangkan dengan e, dengan kekuatan beberapa variabel x, dapat diperkirakan dengan menggunakan ekspansi Seri Maclaurin :

Dengan membiarkan x sama dengan 1, kita memperoleh

Tantangan

Tulis program dalam bahasa apa pun yang mendekati angka Euler dengan mengambil input N dan menghitung deret ke suku N-th. Perhatikan bahwa suku pertama memiliki penyebut 0 !, bukan 1 !, yaitu N = 1 sesuai dengan 1/0 !.

Mencetak gol

Program dengan jumlah byte terkecil menang.

Jelly , 5 byte

R’!İS

Cobalah online!

Bagaimana itu bekerja

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

Program sayu-nyata pertama saya! Sebenarnya ada sedikit golf yang saya lakukan, dengan menggunakan somedaybukan wait forkarena yang pertama memiliki panjang lebih pendek.

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

Coba di sini.

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

Terima kasih kepada FryAmTheEggman untuk satu byte!

TI-84 BASIC, 12 15 14

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

TI adalah bahasa tokenized ( byte dihitung melalui token , bukan karakter individu).

Julia, 28 27 21 byte

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

Ini adalah fungsi anonim yang menerima integer dan mengembalikan float. Untuk menyebutnya, tetapkan ke variabel.

Pendekatannya cukup mudah. Kami sum1 dibagi dengan fungsi gamma yang dievaluasi pada masing-masing 1 hingga n . Ini mengambil keuntungan dari properti n ! = Γ ( n +1).

Cobalah online!

Disimpan 1 byte berkat Dennis dan 6 berkat 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

Ini adalah terjemahan seri yang cukup langsung. Saya mencoba menjadi lebih pintar, tetapi itu menghasilkan kode yang lebih panjang.

Penjelasan

[d1-d1<f*]sf

Fungsi faktorial sederhana, untuk n> 0

[dlfx1r/r1-d1<e+]se

Jalankan faktorial untuk n, ..., 1; membalikkan dan menjumlahkan

1?dk1-

Perdana tumpukan dengan 1; menerima input dan mengatur presisi yang sesuai

d1<e+

Jika input 0 atau 1, kita bisa meneruskannya, jika tidak hitung jumlah parsial.

p

Cetak hasilnya.

Hasil tes

100 ekspansi pertama:

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

Menggunakan 1000 istilah:

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

J, 10 byte

[:+/%@!@i.

Pendekatan lurus ke depan.

Penjelasan

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

atau

r~{m!W#}%:+

Cobalah online: versi pertama dan versi kedua

Penjelasan:

r~= membaca dan mengevaluasi
m!= faktorial
W#= naikkan ke daya -1 ( W= -1)
:+= jumlah array
Versi pertama membangun array [0 ... N-1] dan menerapkan faktorial dan terbalik untuk semua elemennya; Versi ke-2 melakukan faktorial dan terbalik untuk setiap angka kemudian menempatkannya dalam sebuah array.

JavaScript ES6, 44 42 40

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

Fungsi yang tidak disebutkan namanya sekarang.

Terima kasih telah menyimpan 2 byte @AlexA dan terima kasih kepada @LeakyNun untuk 2 byte lainnya!

MATL, 11 7 byte

:Ygl_^s

4 byte disimpan berkat rekomendasi @ Luis untuk menggunakan gamma( Yg)

Cobalah secara Online

Penjelasan

        % 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

Ini menghitung jumlah menggunakan fungsi hypergeometric ₁ F ₁ ( a ; b ; z ):

Bekerja pada oktaf dan pada kompiler online, tetapi tidak pada Matlab, karena perbedaan dalam bagaimana fungsi hypergeometric didefinisikan (yang akan diperbaiki).

Cobalah online!

Penjelasan

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

Tidak Disatukan:

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

Mengambil nomor sebagai argumen untuk menentukan jumlah iterasi.

k (13 byte)

Tunduk pada luapan untuk N>20

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

05AB1E, 6 byte

$L<!/O

Dijelaskan

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

Cobalah online

Pyke, 10 byte

FSBQi^R/)s

Coba di sini!

Atau 8 byte jika daya = 1

FSB1R/)s

Coba di sini!

JavaScript (ES6), 28 byte

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

Dyalog APL , 6 byte

+/÷!⍳⎕

+/jumlah
÷kebalikan dari
!faktorial
⍳angka dari 0 hingga
⎕input numerik

Asumsikan ⎕IO←0, yang merupakan default pada banyak sistem.

TryAPL !

Haskell, 37 byte

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

Bukan yang terpendek, tapi bisa dibilang yang tercantik.

Juga atas izin Laikoni , berikut adalah solusi yang lebih pendek 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

⍳⊥⊢÷!

Cobalah online!

Menggunakan trik basis campuran yang ditemukan dalam jawaban saya untuk tantangan lain . Penggunaan ⎕IO←0.

Bagaimana itu bekerja

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

Sebenarnya, 6 byte

r♂!♂ìΣ

Cobalah online!

Penjelasan:

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

Brachylog , 18 byte

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

Penjelasan

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

Pemakaian:

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

Ide itu!

Java dengan Tiang Laser Kaki Sepuluh , 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);}}

Memiliki ketahanan overflow yang jauh lebih baik daripada sebagian besar jawaban lainnya. Untuk 100 syarat, hasilnya adalah

31710869445015912176908843526535027555643447320787267779096898248431156738548305814867560678144006224158425966541000436701189187481211772088720561290395499/11665776930493019085212404857033337561339496033047702683574120486902199999153739451117682997019564785781712240103402969781398151364608000000000000000000000

Julia, 28 byte

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

Penjelasan

~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)sama dengan factorial(k)untuk input integer positif, dan menggeneralisasikannya untuk semua nilai selain dari integer nonnegatif. Menghemat satu byte, jadi mengapa tidak menggunakannya?

MATLAB / Oktaf, 22 byte

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

Menciptakan fungsi anonim bernama ansyang dapat dipanggil menggunakan ans(N).

Solusi ini menghitung gamma(x)untuk setiap elemen dalam array [1 ... N] yang sama dengan factorial(x-1). Kami kemudian mengambil kebalikan dari setiap elemen dan menjumlahkan semua elemen.

Demo online

Perl 5, 37 byte

Bukan pemenang, tetapi baik dan langsung:

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

Output untuk input dari 0 hingga 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))

Cukup mudah, meskipun masalah presisi numerik pasti akan muncul di beberapa titik waktu.

WolframAlpha , 12 byte

sum1/k!,0..n