Все мы знаем, что число Эйлера , обозначенное через e степенью некоторой переменной x, может быть аппроксимировано с использованием расширения Маклаурина :

Принимая x равным 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 байт, а Глену O - 6!

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

постоянный ток, 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+

Если input был 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 байта сохранены благодаря рекомендации @ 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

Это вычисляет сумму, используя гипергеометрическую функцию ₁ 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;}

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

Принимает число в качестве аргумента для определения количества итераций.

к (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 байтов, если power = 1

FSB1R/)s

Попробуй это здесь!

JavaScript (ES6), 28 байт

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

Дьялог АПЛ , 6 байтов

+/÷!⍳⎕

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

Предполагается ⎕IO←0, что по умолчанию на многих системах.

TryAPL !

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

Брахилог , 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 / Octave, 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))

Довольно просто, хотя проблемы с числовой точностью неизбежно возникают в определенный момент времени.

WolframAlpha , 12 байт

sum1/k!,0..n