Всі ми знаємо, що число Ейлера , позначене e, до сили деякої змінної x, можна наблизити, використовуючи розширення серії Maclaurin :

Додавши х рівний 1, отримуємо

Виклик

Напишіть програму будь-якою мовою, яка наближає число Ейлера, взявши вхід N та обчислюючи ряд до N-го числа. Зауважимо, що перший член має знаменник 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 BASIC, 12 15 14

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

TI - це токенізована мова ( байти обчислюються через лексеми , а не окремі символи).

Юлія, 28 27 21 байт

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

Це анонімна функція, яка приймає ціле число і повертає поплавок. Щоб викликати його, призначте його змінній.

Підхід досить простий. Ми sum1 ділимо на гамма-функцію, оцінювану на кожен з 1 по n . Цим скористається властивість n ! = Γ ( n +1).

Спробуйте в Інтернеті!

Збережено 1 байт завдяки Деннісу та 6 завдяки Глен О!

Пітон, 36 байт

Пітон 2:

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

Пітон 3:

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

постійного струму, 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

Використання 1000 термінів:

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 байти збережено завдяки рекомендації @ Луїса використовувати 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

Це обчислює суму, використовуючи гіпергеометричну функцію ₁ F ₁ ( a ; b ; z ):

Працює на Octave та на онлайн-компіляторі, але не на 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;}

Безголівки:

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

Спробуйте в Інтернеті

Пайк, 10 байт

FSBQi^R/)s

Спробуйте тут!

Або 8 байт, якщо потужність = 1

FSB1R/)s

Спробуйте тут!

JavaScript (ES6), 28 байт

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

Діалог APL , 6 байт

+/÷!⍳⎕

+/сума
÷зворотних
!факторіалів
⍳чисел від 0 до
⎕ числового вводу

Припускається ⎕IO←0, що за замовчуванням для багатьох систем.

СпробуйтеAPL !

Хаскелл, 37 байт

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

Не найкоротший, але, мабуть, найкрасивіший.

Також люб’язно надано Лайконі , ось рішення, яке на 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

Брахілог , 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;}

Ідей це!

Ява з десятистопним лазерним полюсом , 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 / Октава, 22 байти

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

Створює анонімну функцію, названу якою, ansяку можна викликати за допомогою ans(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))

Досить прямо, хоча проблеми чисельності точності повинні виникнути в якийсь момент часу.

Вольфрам Альфа , 12 байт

sum1/k!,0..n