Chúng ta đều biết rằng số Euler , được ký hiệu là e, với sức mạnh của một số biến x, có thể được xấp xỉ bằng cách sử dụng mở rộng Sê-ri Maclaurin :

Bằng cách để x bằng 1, chúng ta có được

Thử thách

Viết chương trình bằng bất kỳ ngôn ngữ nào xấp xỉ số của Euler bằng cách nhập N đầu vào và tính toán chuỗi theo thuật ngữ thứ N. Lưu ý rằng thuật ngữ đầu tiên có mẫu số 0!, Không phải 1!, Tức là N = 1 tương ứng với 1/0!.

Chấm điểm

Chương trình có số lượng byte chiến thắng ít nhất.

Thạch , 5 byte

R’!İS

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Chương trình thực sự đầu tiên của tôi! Thực sự có một ít chơi golf tôi đã làm, với việc sử dụng somedaythay wait forvì bởi vì lần đầu tiên có chiều dài ngắn hơn.

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

Bình thường, 7 6 byte

smc1.!

Hãy thử nó ở đây.

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

Cảm ơn FryAmTheEggman cho một byte!

TI-84 CƠ BẢN, 12 15 14

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

TI là ngôn ngữ được mã hóa ( byte được tính thông qua mã thông báo , không phải ký tự riêng lẻ).

Julia, 28 27 21 byte

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

Đây là một hàm ẩn danh chấp nhận một số nguyên và trả về một số float. Để gọi nó, gán nó cho một biến.

Cách tiếp cận khá đơn giản. Chúng tôi sumchia 1 cho hàm gamma được đánh giá ở mỗi 1 đến n . Điều này tận dụng lợi thế của tài sản n ! = Γ ( n +1).

Hãy thử trực tuyến!

Đã lưu 1 byte nhờ Dennis và 6 nhờ Glen O!

Python, 36 byte

Con trăn 2:

f=lambda n,i=1:n/i and 1.+f(n,i+1)/i

Con trăn 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

Đây là một bản dịch khá trực tiếp của bộ truyện. Tôi đã cố gắng để thông minh hơn, nhưng điều đó dẫn đến mã dài hơn.

Giải trình

[d1-d1<f*]sf

Hàm giai thừa đơn giản, cho n> 0

[dlfx1r/r1-d1<e+]se

Thực hiện giai thừa cho n, ..., 1; đảo và tổng

1?dk1-

Prime stack với 1; chấp nhận đầu vào và đặt độ chính xác phù hợp

d1<e+

Nếu đầu vào là 0 hoặc 1, chúng ta có thể chuyển nó vào, nếu không thì tính tổng một phần.

p

In kết quả.

Kết quả kiểm tra

100 bản mở rộng đầu tiên:

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

Sử dụng 1000 thuật ngữ:

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

J, 10 byte

[:+/%@!@i.

Phương pháp tiếp cận thẳng.

Giải trình

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

hoặc là

r~{m!W#}%:+

Dùng thử trực tuyến: phiên bản đầu tiên và phiên bản thứ hai

Giải trình:

r~= đọc và đánh giá
m!= factorial
W#= nâng lên sức mạnh -1 ( W= -1)
:+= tổng của mảng
Phiên bản đầu tiên xây dựng mảng [0 N N-1] và áp dụng giai thừa và nghịch đảo cho tất cả các phần tử của nó; Phiên bản thứ 2 không giai thừa và nghịch đảo cho mỗi số sau đó đặt chúng vào một mảng.

JavaScript ES6, 44 42 40

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

Một chức năng chưa được đặt tên bây giờ.

Cảm ơn vì đã lưu 2 byte @AlexA và cảm ơn @LeakyNun vì đã có thêm 2 byte!

MATL, 11 7 byte

:Ygl_^s

4 byte được lưu nhờ đề xuất của @ Luis để sử dụng gamma( Yg)

Dùng thử trực tuyến

Giải trình

        % 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

Điều này sẽ tính tổng bằng cách sử dụng hàm siêu bội ₁ F ₁ ( a ; b ; z ):

Hoạt động trên Octave và trên trình biên dịch trực tuyến, nhưng không phải trên Matlab, do sự khác biệt trong cách xác định hàm siêu bội (sẽ được sửa).

Hãy thử trực tuyến!

Giải trình

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

Ung dung:

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

Lấy một số làm đối số để xác định số lần lặp.

k (13 byte)

Chủ đề cho tràn N>20

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

05AB1E, 6 byte

$L<!/O

Giải thích

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

Dùng thử trực tuyến

Pyke, 10 byte

FSBQi^R/)s

Hãy thử nó ở đây!

Hoặc 8 byte nếu power = 1

FSB1R/)s

Hãy thử nó ở đây!

JavaScript (ES6), 28 byte

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

APL Dyalog , 6 byte

+/÷!⍳⎕

+/tổng
÷các đối ứng của
!các giai thừa của
⍳các số từ 0 đến
⎕ đầu vào số

Giả định ⎕IO←0 , được mặc định trên nhiều hệ thống.

Hãy thử !

Haskell, 37 byte

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

Không phải là ngắn nhất, nhưng được cho là đẹp nhất.

Cũng theo phép lịch sự của Laikoni , đây là một giải pháp ngắn hơn 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

⍳⊥⊢÷!

Hãy thử trực tuyến!

Sử dụng thủ thuật cơ sở hỗn hợp được tìm thấy trong câu trả lời của tôi về một thách thức khác . Công dụng ⎕IO←0.

Làm thế nào nó hoạt động

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

Trên thực tế, 6 byte

r♂!♂ìΣ

Hãy thử trực tuyến!

Giải trình:

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

Brachylog , 18 byte

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

Giải trình

: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

Phong, 18

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

Sử dụng:

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

Nghĩa là nó!

Java với cực mười chân laser , 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);}}

Có khả năng chống tràn tốt hơn nhiều so với hầu hết các câu trả lời khác. Đối với 100 điều khoản, kết quả là

31710869445015912176908843526535027555643447320787267779096898248431156738548305814867560678144006224158425966541000436701189187481211772088720561290395499/11665776930493019085212404857033337561339496033047702683574120486902199999153739451117682997019564785781712240103402969781398151364608000000000000000000000

Julia, 28 byte

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

Giải trình

~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)bằng với factorial(k)các đầu vào số nguyên dương và tổng quát hóa nó cho tất cả các giá trị khác với các số nguyên không âm. Nó tiết kiệm một byte, vậy tại sao không sử dụng nó?

MATLAB / Octave, 22 byte

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

Tạo một hàm ẩn danh có tên ans có thể được gọi bằng cách sử dụng ans(N).

Giải pháp này tính toán gamma(x)cho từng phần tử trong mảng [1 ... N] bằng factorial(x-1). Sau đó chúng ta lấy nghịch đảo của từng phần tử và tính tổng tất cả các phần tử.

Demo trực tuyến

Perl 5, 37 byte

Không phải là một người chiến thắng, nhưng tốt đẹp và đơn giản:

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

Đầu ra cho đầu vào từ 0 đến 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))

Khá đơn giản, mặc dù các vấn đề chính xác về số lượng chắc chắn sẽ phát sinh tại một số thời điểm.

WolframAlpha , 12 byte

sum1/k!,0..n