Przybliżenie e


21

Wszyscy wiemy, że liczbę Eulera , oznaczoną e, do potęgi jakiejś zmiennej x, można aproksymować za pomocą rozszerzenia Maclaurin Series :

Rozszerzenie e ^ x serii Maclaurin

Pozwalając x równa się 1, otrzymujemy

Rozszerzenie serii e Maclaurin e

Wyzwanie

Napisz program w dowolnym języku, który jest zbliżony do liczby Eulera, przyjmując wartość wejściową N i obliczając szereg na N-ty warunek. Zauważ, że pierwszy termin ma mianownik 0 !, nie 1 !, tj. N = 1 odpowiada 1/0 !.

Punktacja

Program z najmniejszą liczbą bajtów wygrywa.


7
Biorąc pod uwagę wystarczająco duże Nwyniki będą takie same, jeśli użyje się liczby zmiennoprzecinkowej o skończonej precyzji. Czy takie zachowanie jest akceptowalne, czy wynik musi być coraz dokładniejszy w miarę Nzbliżania się do nieskończoności?
FryAmTheEggman

12
Niektóre przypadki testowe byłyby fajne.
Lynn

7
(Tego rodzaju problem najlepiej rozwiązać w piaskownicy - jeśli postawisz tam swoje wyzwania, golfiści udzielą użytecznych informacji zwrotnych.)
Lynn

2
Czy x ^ n jest n-tym terminem czy (n + 1)?
msh210

4
Ja osobiście gardzę tym, ale są ludzie, którzy odnoszą się do terminu o indeksie 0 jako terminu zerowego. Niezależnie od naszych przemyśleń na ten temat pytanie powinno być jak najbardziej jasne. Bardzo pomocne byłoby również kilka przypadków testowych do sprawdzenia, czy rozwiązania działają poprawnie.
Dennis

Odpowiedzi:



13

Wistful-C - 336 bajtów

Mój pierwszy prawdziwy smutny program! Grałem trochę w golfa, używając somedayzamiast tego, wait forponieważ pierwszy miał krótszą długość.

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

Powiedziano mi, że nie musisz uwzględniać<stdio.h>
Leaky Nun

Czy someday i were N...działa zamiast someday i will be N...?
Leaky Nun


9

TI-84 BASIC, 12 15 14

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

TI jest tokenizowanym językiem ( bajty są liczone za pomocą tokenów , a nie pojedynczych znaków).


1
Cytowany meta post ma 11 głosów pozytywnych i 10 głosów negatywnych. To nie jest konsensus. Ansnie jest poprawnym formatem wejściowym, więc poprawna jest tylko wersja 15-bajtowa.
Mego

Słusznie; edycja ...
Brak nazwy

1
Anszawsze był domyślnym formatem wejściowym tutaj w PPCG (przejrzyj moje stare odpowiedzi TI), a więcej osób zgadza się, niż nie zgadzam, więc nie daj się zastraszyć, aby zmienić twoją odpowiedź.
Timtech,

2
@MickLH to nie jest tutaj spór. Poza tym są to 8-bitowe bajty.
hobbs

1
@ Timtech Chociaż zgadzam się z tobą, konsensus społeczności jest zdefiniowany, jak mówi Mego.
Conor O'Brien

9

Julia, 28 27 21 bajtów

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

Jest to anonimowa funkcja, która przyjmuje liczbę całkowitą i zwraca liczbę zmiennoprzecinkową. Aby go wywołać, przypisz go do zmiennej.

Podejście jest dość proste. Mamy sum1 podzielone przez funkcję gamma ocenianą dla każdego z 1 do n . Wykorzystuje to właściwość n ! = Γ ( n +1).

Wypróbuj online!

Zaoszczędzono 1 bajt dzięki Dennisowi i 6 dzięki Glen O!


Prawie dokładnie tak samo w MATLAB:@(n)sum(1./factorial(0:n))
flawr

6

Python, 36 bajtów

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

Python 3 wariant mógłby być krótszy ze orzamiast and: f=lambda n,i=1:i>=n or 1+f(n,i+1)/i.
Konstruktor

6

dc, 43 bajty

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

Jest to dość bezpośrednie tłumaczenie serii. Próbowałem być sprytniejszy, ale to spowodowało dłuższy kod.

Wyjaśnienie

[d1-d1<f*]sf

Prosta funkcja silnia dla n> 0

[dlfx1r/r1-d1<e+]se

Wykonaj silnię dla n, ..., 1; odwrócenie i suma

1?dk1-

Zalej stos 1; zaakceptuj dane wejściowe i ustaw odpowiednią dokładność

d1<e+

Jeśli wartość wejściowa wynosiła 0 lub 1, możemy ją po prostu przekazać, w przeciwnym razie obliczyć sumę częściową.

p

Wydrukuj wynik.

Wyniki testu

Pierwsze 100 rozszerzeń:

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

Używając 1000 terminów:

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

5

J, 10 bajtów

[:+/%@!@i.

Proste podejście.

Wyjaśnienie

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

Ładny. Trywialna poprawa 1-bajtowa:1#.%@!@i.
Jonasz

4

CJam, 11

r~,:m!Wf#:+

lub

r~{m!W#}%:+

Wypróbuj online: pierwsza wersja i druga wersja

Wyjaśnienie:

r~= odczyt i ocena
m!= silnia
W#= podniesienie do potęgi -1 ( W= -1)
:+= suma tablicy
Pierwsza wersja konstruuje tablicę [0… N-1] i stosuje silnię i odwrotność do wszystkich jej elementów; Druga wersja robi silnię i odwrotność dla każdej liczby, a następnie umieszcza je w tablicy.


4

JavaScript ES6, 44 42 40

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

Teraz funkcja bez nazwy.

Dzięki za zapisanie 2 bajtów @AlexA i dzięki @LeakyNun za kolejne 2 bajty!


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

4

MATL, 11 7 bajtów

:Ygl_^s

4 bajty zapisane dzięki rekomendacji @ Luis do użycia gamma( Yg)

Wypróbuj online

Wyjaśnienie

        % 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

Możesz usunąć]
Luis Mendo

Również 1i:Yg/sdla 7 bajtów
Luis Mendo

@LuisMendo o tak, miałem nadzieję, że istnieje lepszy sposób na uzyskanie silni, ale zapomniałem o gamma. Wkrótce się zaktualizuje
Suever,

4

MATL , 6 bajtów

q_t1Zh

To oblicza sumę za pomocą funkcji hipergeometrycznej 1 F 1 ( a ; b ; z ):

enter image description here

Działa na Octave i kompilatorze online, ale nie na Matlabie, ze względu na różnicę w definiowaniu funkcji hipergeometrycznej (która zostanie poprawiona).

Wypróbuj online!

Wyjaśnienie

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 bajtów

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

Nie golfowany:

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

Bierze liczbę jako argument w celu ustalenia liczby iteracji.


Witaj i witaj w PPCG! Świetny pierwszy post!
NoOneIsHere

Witamy w Programowaniu Puzzle i Code Golf! Myślę, że program ma wydrukować tylko ostatnie przybliżenie. Przynajmniej z GCC nie potrzebujesz intwcześniejszych maini return 0. Ponadto, jeśli zastąpi NULLsię 0, nie trzeba includes. argci argvmoże być skrócony do zmiennych jednoliterowych. Jeśli lubisz grać w golfa w C, pomocne mogą być porady dotyczące gry w golfa w C.
Dennis

IMHO, nawet jeśli kompilator zgłasza pewne ostrzeżenia, ale mimo to zwraca poprawny wynik, możesz wyrzucić wiele części kodu do tego stopnia, że ​​nic nie można zmniejszyć bez błędu.
Andreï Kostyrka

I nie potrzebujesz#include <stdio.h>
Leaky Nun

3

k (13 bajtów)

Z zastrzeżeniem przepełnienia dla N>20

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

3

05AB1E, 6 bajtów

$L<!/O

Wyjaśniono

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

Wypróbuj online


1
5 bajtów z L<!zO.
Grimmy,

3

Pyke, 10 bajtów

FSBQi^R/)s

Wypróbuj tutaj!

Lub 8 bajtów, jeśli moc = 1

FSB1R/)s

Wypróbuj tutaj!


pierwszy kod był wyłączony o więcej niż 3, kiedy go uruchomiłem: 5.436532738095238
tox123

@ tox123 naprawione teraz
Blue

testujesz je? Dostałem: 7.3887125220458545 po raz pierwszy, drugi działa znacznie lepiej.
tox123

Ten jest e ^ x, którego znasz nie tylko e
Blue

to nie wyzwanie.
tox123

3

JavaScript (ES6), 28 bajtów

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

3

Dyalog APL , 6 bajtów

+/÷!⍳⎕

+/suma
÷odwrotności
!silni
liczb od 0 do
wprowadzania liczbowego

Zakłada się ⎕IO←0, że jest to domyślne w wielu systemach.

TryAPL !


3

Haskell, 37 bajtów

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

Nie najkrótszy, ale prawdopodobnie najładniejszy.


Również dzięki uprzejmości Laikoni , oto rozwiązanie o 2 bajty krótsze:

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
Możesz użyć tego licznika bajtów UTF-8 . Wprowadziłem sugerowaną edycję, aby dodać liczbę bajtów, czyli 50. Aby dodać nagłówek, należy: ## Language, <xxx> bytes.
NoOneIsHere

1
Potrzebujesz białych znaków?
NoOneIsHere

1
Nie można zakładać, że dane wejściowe są obecne w zmiennej, dlatego należy wcześniej wstawić f n=lub \n->uzyskać prawidłowe przesłanie funkcji. Możemy jednak również zapisać kilka bajtów: (\x->1/x)można go skrócić do sekcji (1/), [1,2..]jest taki sam jak [1..]i map(...)$może być(...)<$> . Razem 36 bajtów: Wypróbuj online!
Laikoni

1
Konwersja na funkcję bez punktów oszczędza kolejny bajt: Wypróbuj online! I chociaż jest to bajt dłuższy, ((scanl(+)0$(1/)<$>scanl(*)1[1..])!!)wygląda również ładnie.
Laikoni

1
Jak już widzieliście, wersja bez nawiasów jest tylko prawidłowym wyrażeniem Haskell podczas wstawiania wartości po nim, ale ponieważ zakładanie, że dane wejściowe w predefiniowanej zmiennej są niedozwolone , należy dodać nawiasy lub ponownie wiodącą stronę \n->do utworzenia funkcja.
Laikoni,

3

APL (Dyalog Unicode) , 5 bajtów

⍳⊥⊢÷!

Wypróbuj online!

Używając sztuczki o mieszanej podstawie, znalezionej w mojej odpowiedzi na inne wyzwanie . Zastosowania ⎕IO←0.

Jak to działa

⍳⊥⊢÷!  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 000 powtórzeń! Teraz zobaczę, czy uda mi się to zrobić w maszynie Turinga ....
ouflak

Dobra odpowiedź, ale mam problem z dostrzeżeniem 1÷(n-1)!cyfry? Czy możesz to przetłumaczyć na J, aby to wyjaśnić?
Jonasz

2

Właściwie 6 bajtów

r♂!♂ìΣ

Wypróbuj online!

Wyjaśnienie:

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

2

Brachylog , 18 bajtów

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

Wyjaśnienie

: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

2

Klon, 18

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

Stosowanie:

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

Myślę, że funkcja jest n-> add (1 / i!, I = 0..n-1)
RosLuP


2

Java z dziesięciostopowym biegunem laserowym , 238 236 bajtów

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

Ma znacznie lepszą odporność na przelewanie niż większość innych odpowiedzi. Wynik dla 100 terminów to

31710869445015912176908843526535027555643447320787267779096898248431156738548305814867560678144006224158425966541000436701189187481211772088720561290395499/11665776930493019085212404857033337561339496033047702683574120486902199999153739451117682997019564785781712240103402969781398151364608000000000000000000000

2

Julia, 28 bajtów

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

Wyjaśnienie

~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)jest równy factorial(k)dla dodatnich liczb całkowitych i uogólnia je dla wszystkich wartości innych niż nieujemne liczby całkowite. Oszczędza jeden bajt, więc dlaczego go nie użyć?


1

MATLAB / Octave, 22 bajty

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

Tworzy anonimową funkcję o nazwie, ansktórą można wywołać za pomocą ans(N).

To rozwiązanie oblicza gamma(x)dla każdego elementu w tablicy [1 ... N], który jest równy factorial(x-1). Następnie bierzemy odwrotność każdego elementu i sumujemy wszystkie elementy.

Demo online


1

Perl 5, 37 bajtów

Nie zwycięzca, ale miły i bezpośredni:

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

Wyjścia dla wejść od 0 do 10:

1
2
2.5
2.66666666666667
2.70833333333333
2.71666666666667
2.71805555555556
2.71825396825397
2.71827876984127
2.71828152557319
2.71828180114638

1

R, 17 bajtów

sum(1/gamma(1:n))

Całkiem proste, choć w pewnym momencie mogą pojawić się problemy z precyzją liczbową.


Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.