เราทุกคนรู้ว่าหมายเลขของออยเลอร์แทนด้วย e ถึงกำลังของตัวแปรบางตัว x สามารถประมาณได้โดยใช้ส่วนขยายของMaclaurin Series :

โดยการให้ x เท่ากับ 1 เราได้

ท้าทาย

เขียนโปรแกรมในภาษาใดก็ได้ที่ใกล้เคียงกับจำนวนของออยเลอร์โดยรับอินพุต N และคำนวณอนุกรมเป็นคำศัพท์ N-th โปรดทราบว่าเทอมแรกมีตัวส่วน 0 !, ไม่ใช่ 1!, เช่น N = 1 ตรงกับ 1/0!

เกณฑ์การให้คะแนน

โปรแกรมที่มีจำนวนไบต์น้อยที่สุดจะเป็นผู้ชนะ

เยลลี่ 5 ไบต์

R’!İS

ลองออนไลน์!

มันทำงานอย่างไร

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 ไบต์

โปรแกรมโหยหาจริงครั้งแรกของฉัน! จริงๆแล้วมีสนามกอล์ฟเล็ก ๆ น้อย ๆ ที่ฉันใช้somedayแทนที่จะเป็นwait forเพราะสนามแรกมีความยาวน้อยกว่า

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 ไบต์

smc1.!

ลองที่นี่

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

ขอบคุณFryAmTheEggmanสำหรับไบต์!

TI-84 พื้นฐาน12 15 14

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

TI เป็นภาษาโทเค็น (จำนวนไบต์จะถูกนับผ่านโทเค็นไม่ใช่อักขระแต่ละตัว)

Julia, 28 27 21 bytes

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

นี่คือฟังก์ชั่นที่ไม่ระบุชื่อที่รับจำนวนเต็มและส่งคืนค่าทศนิยม หากต้องการเรียกใช้กำหนดค่าให้กับตัวแปร

วิธีการค่อนข้างตรงไปตรงมา เราsum1 หารด้วยฟังก์ชั่นแกมมาประเมินในแต่ละที่ 1 ถึงn สิ่งนี้ใช้ประโยชน์จากคุณสมบัติn ! = Γ ( n +1)

ลองออนไลน์!

บันทึก 1 ไบต์ขอบคุณ Dennis และ 6 ขอบคุณ Glen O!

Python ขนาด 36 ไบต์

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 ไบต์

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

นี่คือการแปลโดยตรงของซีรีย์ ฉันพยายามที่จะฉลาดขึ้น แต่นั่นทำให้รหัสยาวขึ้น

คำอธิบาย

[d1-d1<f*]sf

ฟังก์ชันแฟกทอเรียลธรรมดาสำหรับ n> 0

[dlfx1r/r1-d1<e+]se

ดำเนินการแฟคทอเรียลสำหรับ n, ... , 1; กลับด้านและผลรวม

1?dk1-

ไพรม์สแต็กด้วย 1; ยอมรับอินพุตและตั้งค่าความแม่นยำที่เหมาะสม

d1<e+

หากอินพุตเป็น 0 หรือ 1 เราสามารถส่งต่อไปได้มิฉะนั้นคำนวณผลรวมบางส่วน

p

พิมพ์ผลลัพธ์

ผลการทดสอบ

การขยาย 100 ครั้งแรก:

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

ใช้ 1,000 ข้อตกลง:

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

J, 10 ไบต์

[:+/%@!@i.

วิธีการตรงไปข้างหน้า

คำอธิบาย

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

หรือ

r~{m!W#}%:+

ลองออนไลน์: รุ่นแรกและรุ่นที่สอง

คำอธิบาย:

r~= อ่านและประเมินค่า
m!= ปัจจัย
W#= ยกกำลัง -1 ( W= -1)
:+= ผลรวมของอาร์เรย์
รุ่นแรกสร้างอาร์เรย์[0 … N-1] และใช้แฟคทอเรียลและผกผันกับองค์ประกอบทั้งหมดของมัน; รุ่นที่ 2 ทำแฟกทอเรียลและผกผันของแต่ละหมายเลขจากนั้นใส่เข้าไปในอาร์เรย์

JavaScript ES6, 44 42 40

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

ฟังก์ชั่นที่ไม่มีชื่อตอนนี้

ขอบคุณสำหรับการบันทึก 2 ไบต์ @AlexA และขอบคุณ @LeakyNun อีก 2 ไบต์!

MATL, 11 7 ไบต์

:Ygl_^s

บันทึกได้ 4 ไบต์ด้วยคำแนะนำของ @ Luis ที่จะใช้gamma( Yg)

ลองออนไลน์

คำอธิบาย

        % 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 ไบต์

q_t1Zh

สิ่งนี้คำนวณผลรวมโดยใช้ ฟังก์ชัน hypergeometric ₁ F ₁ ( a ; b ; z ):

ทำงานบนอ็อคเทฟและคอมไพเลอร์ออนไลน์ แต่ไม่ใช่ใน Matlab เนื่องจากความแตกต่างในวิธีการกำหนดฟังก์ชั่นไฮเพอร์เมตริกซ์ (ซึ่งจะถูกแก้ไข)

ลองออนไลน์!

คำอธิบาย

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 ไบต์

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

ใช้ตัวเลขเป็นอาร์กิวเมนต์เพื่อกำหนดจำนวนการวนซ้ำ

k (13 ไบต์)

อาจมีการล้นสำหรับ N>20

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

05AB1E, 6 ไบต์

$L<!/O

อธิบาย

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

ลองออนไลน์

Pyke ขนาด 10 ไบต์

FSBQi^R/)s

ลองที่นี่!

หรือ 8 ไบต์ถ้า power = 1

FSB1R/)s

ลองที่นี่!

JavaScript (ES6), 28 ไบต์

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

Dyalog APL ขนาด 6 ไบต์

+/÷!⍳⎕

+/ผลรวมของ
÷ส่วนกลับของ
!แฟคทอเรียลของ
⍳ตัวเลขตั้งแต่ 0 ถึง
⎕อินพุตตัวเลข

ถือว่า⎕IO←0ซึ่งเป็นค่าเริ่มต้นในหลาย ๆ ระบบ

ลองใช้ !

Haskell, 37 ไบต์

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

ไม่ใช่ที่สั้นที่สุด แต่เนื้อหาที่สวยที่สุด

ด้วยความอนุเคราะห์จากLaikoniนี่คือทางออกที่สั้นลง2 ไบต์ :

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 ไบต์

⍳⊥⊢÷!

ลองออนไลน์!

ใช้เคล็ดลับฐานผสมที่พบในคำตอบของฉันของความท้าทายอื่น ⎕IO←0การใช้ประโยชน์

มันทำงานอย่างไร

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

ที่จริงแล้ว 6 ไบต์

r♂!♂ìΣ

ลองออนไลน์!

คำอธิบาย:

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

Brachylogขนาด 18 ไบต์

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

คำอธิบาย

: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

เมเปิ้ล, 18

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

การใช้งาน:

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

C, 69 ไบต์

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

ไอเดียมัน!

Java กับสิบเท้าขั้วโลกเลเซอร์ , 238 236 ไบต์

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

มีการต้านทานการล้นที่ดีกว่าคำตอบอื่น ๆ สำหรับ 100 คำผลลัพธ์ที่ได้คือ

31710869445015912176908843526535027555643447320787267779096898248431156738548305814867560678144006224158425966541000436701189187481211772088720561290395499/11665776930493019085212404857033337561339496033047702683574120486902199999153739451117682997019564785781712240103402969781398151364608000000000000000000000

จูเลีย 28 ไบต์

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

คำอธิบาย

~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)มีค่าเท่ากับfactorial(k)สำหรับอินพุตจำนวนเต็มบวกและวางค่าทั่วไปให้กับค่าอื่นทั้งหมดที่ไม่ใช่จำนวนเต็มแบบไม่ลบ มันช่วยประหยัดหนึ่งไบต์ดังนั้นทำไมไม่ใช้มัน?

MATLAB / Octave, 22 ไบต์

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

สร้างฟังก์ชั่นที่ไม่ระบุชื่อชื่อที่สามารถเรียกใช้ansans(N)

นี้คำนวณการแก้ปัญหาgamma(x)สำหรับแต่ละองค์ประกอบในอาร์เรย์ [1 ... N] factorial(x-1)ซึ่งเท่ากับ จากนั้นเราจะใช้อินเวอร์สของแต่ละองค์ประกอบและรวมองค์ประกอบทั้งหมด

การสาธิตออนไลน์

Perl 5, 37 ไบต์

ไม่ใช่ผู้ชนะ แต่เป็นคนดีและตรงไปตรงมา:

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

เอาต์พุตสำหรับอินพุตจาก 0 ถึง 10:

1
2
2.5
2.66666666666667
2.70833333333333
2.71666666666667
2.71805555555556
2.71825396825397
2.71827876984127
2.71828152557319
2.71828180114638

R, 17 ไบต์

sum(1/gamma(1:n))

ค่อนข้างตรงไปตรงมาแม้ว่าปัญหาความแม่นยำเชิงตัวเลขจะเกิดขึ้น ณ เวลาใดเวลาหนึ่ง

WolframAlphaขนาด 12 ไบต์

sum1/k!,0..n