Аппроксимация е

21

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

Расширение серии Маклаурина е ^ х

Принимая x равным 1, мы получаем

Маклаурин серия расширение е

Вызов

Напишите программу на любом языке, который аппроксимирует число Эйлера с помощью ввода N и вычисляет ряд для N-го члена. Обратите внимание, что первый член имеет знаменатель 0 !, а не 1 !, т.е. N = 1 соответствует 1/0 !.

счет

Программа с наименьшим количеством байтов выигрывает.

code-golf math number approximation Мяу микс
источник
7
Учитывая достаточно большой, Nрезультаты будут такими же, если использовать число с плавающей запятой конечной точности. Является ли это поведение приемлемым или результат должен постепенно становиться более точным по мере Nприближения к бесконечности?
FryAmTheEggman
12
Некоторые тесты были бы аккуратными.
Линн
7
(Этот тип проблемы предпочтительно решается в песочнице - если вы сначала опубликуете свои испытания там, игроки в гольф дадут полезную обратную связь.)
Линн
2
Является ли x ^ n n-м термином или (n + 1) -ым термином?
msh210
4
Я лично презираю это, но есть люди, которые называют термин с индексом 0 нулевым термином. Независимо от наших мыслей по этому вопросу, этот вопрос должен быть как можно более ясным. Кроме того, несколько контрольных примеров для проверки правильности работы решений были бы очень полезны.
Деннис

Ответы:

12

Желе , 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.
Деннис
источник
8
«Наличие встроенного для [1, n] имеет больше смысла, чем наличие встроенного для [0, n) imho».
Дрянная Монахиня
6
... и через месяц , и чуть позже, желе имеет Ḷ, что делает [0, п) диапазона. ^ v ^;
Линн
13

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...
Maltysen
источник
Мне сказали, что вам не нужно включать<stdio.h>
Leaky Nun
Работает someday i were N...вместо someday i will be N...?
Дрянная Монахиня
9

TI-84 BASIC, 12 15 14

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

TI является языком токенов ( байты считаются с помощью токенов , а не отдельных символов).

Без имени
источник
1
Цитированная мета-публикация имеет 11 голосов "против" и 10 голосов "против". Это не консенсус. Ansне является допустимым форматом ввода, поэтому допустима только 15-байтовая версия.
Мего
справедливо; редактирование ...
Без имени
1
Ansздесь всегда был формат ввода по умолчанию здесь, в PPCG (посмотрите мои старые ответы TI), и больше людей с этим согласны, чем не согласны, поэтому не пытайтесь изменить свой ответ.
Timtech
2
@MickLH это не спор здесь. Кроме того, это 8-битные байты.
Хоббс
1
@Timtech Хотя я согласен с вами, консенсус сообщества определяется, как говорит Мего.
Конор О'Брайен
9

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

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

Это анонимная функция, которая принимает целое число и возвращает число с плавающей точкой. Чтобы вызвать его, присвойте его переменной.

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

Попробуйте онлайн!

Благодаря Деннису сэкономлено 1 байт, а Глену O - 6!

Алекс А.
источник
Почти то же самое в MATLAB:@(n)sum(1./factorial(0:n))
flawr
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
XNOR
источник
Python 3 вариант может быть короче , с orвместо and: f=lambda n,i=1:i>=n or 1+f(n,i+1)/i.
Конструктор
6

постоянный ток, 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
Тоби Спейт
источник
5

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
миль
источник
Ницца. Тривиальное улучшение 1 байта:1#.%@!@i.
Иона
4

CJam, 11

r~,:m!Wf#:+

или

r~{m!W#}%:+

Попробуйте онлайн: первая версия и вторая версия

Объяснение:

r~= читать и оценивать
m!= факториал
W#= повысить до степени -1 ( W= -1)
:+= сумма массива
Первая версия создает массив [0… N-1] и применяет факториал и обратный ко всем его элементам; 2-я версия делает факториал и инверсию для каждого числа, затем помещает их в массив.

aditsu
источник
4

JavaScript ES6, 44 42 40

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

Безымянная функция сейчас.

Спасибо за сохранение 2 байтов @AlexA и спасибо @LeakyNun за еще 2 байта!

ಠ_ಠ
источник
n=>{for(k=s=m=1;m<n;s+=k/=m++);return s}
Утренняя монахиня
4

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
Suever
источник
Вы можете удалить]
Луис Мендо
Кроме того, 1i:Yg/sдля 7 байтов
Луис Мендо
@ LuisMendo о да, я надеялся, что есть лучший способ получить факториал, но я забыл о гамме.
Обновится в
4

MATL , 6 байтов

q_t1Zh

Это вычисляет сумму, используя гипергеометрическую функцию 1 F 1 ( 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
Луис Мендо
источник
4

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

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

LordCreepity
источник
Здравствуйте и добро пожаловать в PPCG! Отличный первый пост!
NoOneIsHere
Добро пожаловать в Программирование Пазлов и Код Гольф! Я думаю, что программа предназначена для печати только в последнем приближении. По крайней мере, с GCC, вам не нужно intраньше mainи return 0. Кроме того, если вы заменяете NULLна 0, вам не нужны включения. argcи argvможет быть сокращен до однобуквенных переменных. Если вы любите играть в гольф на Си, вам могут пригодиться советы по игре в гольф на Си .
Деннис
ИМХО, даже если компилятор выдает некоторые предупреждения, но, тем не менее, возвращает правильный результат, вы можете отбросить многие части своего кода до такой степени, что ничто не может быть уменьшено без ошибки.
Андрей Костырка,
И вам не нужно#include <stdio.h>
Leaky Nun
3

к (13 байт)

Возможно переполнение для N>20

{+/%*\1,1+!x}
skeevey
источник
3

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

Попробуйте онлайн

Emigna
источник
1
5 байт с L<!zO.
Grimmy
3

Пайк, 10 байт

FSBQi^R/)s

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

Или 8 байтов, если power = 1

FSB1R/)s

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

синий
источник
первый код был отключен более чем на 3, когда я его запустил: 5.436532738095238
tox123
@ tox123 исправлено
Blue
Вы тестируете это? Я получил: 7.3887125220458545 для первого, второй работает намного лучше.
tox123
Это один из тех, кого вы знаете не просто e
Blue
это не проблема.
tox123
3

JavaScript (ES6), 28 байт

f=(n,i=1)=>n&&1+f(n-1,i+1)/i
Нил
источник
3

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

+/÷!⍳⎕

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

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

TryAPL !

Адам
источник
3

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
Родриго де Азеведо
источник
2
Вы можете использовать этот счетчик байтов UTF-8 . Я добавил предлагаемое изменение, чтобы добавить ваш счетчик байтов 50. Чтобы добавить заголовок, используйте: ## Language, <xxx> bytes.
NoOneIsHere
1
Вам нужны пробелы?
NoOneIsHere
1
Вы не можете предполагать, что входные данные присутствуют в переменной, поэтому вам нужно добавить f n=или \n->получить правильное представление функции. Тем не менее, мы также можем сохранить несколько байтов: (\x->1/x)может быть сокращен до раздела (1/), так [1,2..]же, как [1..]и map(...)$может быть (...)<$>. Вместе 36 байтов: попробуйте онлайн!
Лайкони
1
Преобразование в функцию без точек экономит еще один байт: попробуйте онлайн! И хотя он на байт длиннее, ((scanl(+)0$(1/)<$>scanl(*)1[1..])!!)выглядит хорошо.
Лайкони
1
Как вы уже убедились, версия без круглых скобок является только допустимым выражением Haskell при вставке значения после него, но поскольку допущение, что входные данные присутствуют в предопределенной переменной, недопустимо , вы должны добавить круглые скобки или снова ведущий \n->для создания функция.
Лайкони
3

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)!
фонтанчик для питья
источник
10 тыс. Респ! Теперь посмотрим, смогу ли я справиться с этим в машине Тьюринга ....
ouflak
Хороший ответ, но я не могу понять 1÷(n-1)!, как цифра? Не могли бы вы перевести это на J, чтобы уточнить?
Иона
2

Брахилог , 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
Fatalize
источник
2

Клен, 18

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

Использование:

> f:=n->add(1/i!,i=0..n-1);
> f(1);
  1
> f(4);
  8/3
DSkoog
источник
Я думаю, что функция n-> add (1 / i!, I = 0..n-1)
RosLuP
2

Ява с десятифутовым лазерным полюсом , 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
SuperJedi224
источник
2

Юлия, 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)для положительных целочисленных входных данных и обобщает его для всех значений, кроме неотрицательных целых чисел. Это сохраняет один байт, так почему бы не использовать его?

eaglgenes101
источник
1

MATLAB / Octave, 22 байта

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

Создает анонимную функцию с именем, ansкоторая может быть вызвана с помощью ans(N).

Это решение вычисляется gamma(x)для каждого элемента в массиве [1 ... N], который равен factorial(x-1). Затем мы берем инверсию каждого элемента и суммируем все элементы.

Демо онлайн

Suever
источник
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
Hobbs
источник
1

R, 17 байт

sum(1/gamma(1:n))

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

Андрей Костырка
источник