Approximation von e

21

Wir alle wissen, dass die mit e bezeichnete Euler-Zahl zur Potenz einer Variablen x mit der Erweiterung der Maclaurin-Reihe angenähert werden kann :

Maclaurin-Reihenerweiterung von e ^ x

Wenn wir x gleich 1 lassen, erhalten wir

Maclaurin-Serienerweiterung von e

Herausforderung

Schreiben Sie ein Programm in einer beliebigen Sprache, die sich der Euler-Zahl annähert, indem Sie eine Eingabe N eingeben und die Reihe mit dem N-ten Term berechnen. Beachten Sie, dass der erste Term den Nenner 0 !, nicht 1 !, hat, dh N = 1 entspricht 1/0 !.

Wertung

Programm mit der geringsten Anzahl von Bytes gewinnt.

Meow Mix
quelle
7
Bei ausreichender Größe sind Ndie Ergebnisse bei Verwendung einer Gleitkommazahl mit endlicher Genauigkeit gleich. Ist dieses Verhalten akzeptabel oder muss das Ergebnis mit zunehmender NAnnäherung an die Unendlichkeit immer genauer werden ?
FryAmTheEggman
12
Einige Testfälle wären ordentlich.
Lynn
7
(Diese Art von Problem wird vorzugsweise im Sandkasten behoben. Wenn Sie Ihre Herausforderungen zuerst dort posten, geben Golfer nützliches Feedback.)
Lynn,
2
Ist x ^ n der n-te Term oder der (n + 1) -te?
msh210
4
Ich persönlich verachte es, aber es gibt Leute, die den Begriff bei Index 0 als nullten Begriff bezeichnen. Unabhängig von unseren Überlegungen sollte die Frage so klar wie möglich sein. Auch ein paar Testfälle, um zu überprüfen, ob die Lösungen korrekt funktionieren, wären sehr hilfreich.
Dennis

Antworten:

13

Wehmütig-C - 336 Bytes

Mein erstes echtes Wehmut-Programm! Eigentlich habe ich ein bisschen Golf gespielt, somedayanstatt zu spielen, wait forweil der erste eine kürzere Länge hatte.

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
quelle
Mir wurde gesagt, dass Sie nicht enthalten müssen<stdio.h>
Leaky Nun
Arbeitet someday i were N...statt someday i will be N...?
Undichte Nonne
9

TI-84 BASIC, 12 15 14

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

TI ist eine Token-Sprache ( Bytes werden über Token gezählt , nicht über einzelne Zeichen).

Kein Name
quelle
1
Der zitierte Metapost hat 11 Upvotes und 10 Downvotes. Das ist kein Konsens. Ansist kein gültiges Eingabeformat, daher ist nur die 15-Byte-Version gültig.
Mego
Meinetwegen; Bearbeitung ...
No Name
1
Answar schon immer das Standard-Eingabeformat bei PPCG (siehe meine alten TI-Antworten), und mehr Leute stimmen dem zu als nicht. Lassen Sie sich also nicht dazu drängen, Ihre Antwort zu ändern.
Timtech
2
@ MickLH das ist hier nicht der Streit. Dabei handelt es sich um 8-Bit-Bytes.
Hobbs
1
@ Timtech Obwohl ich Ihnen zustimme, wird der Konsens der Community so definiert, wie Mego es sagt.
Conor O'Brien
9

Julia, 28 27 21 Bytes

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

Dies ist eine anonyme Funktion, die eine Ganzzahl akzeptiert und einen Gleitkommawert zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

Der Ansatz ist recht unkompliziert. We sum1 dividiert durch die Gammafunktion, die bei jedem von 1 bis n ausgewertet wird . Dies nutzt die Eigenschaft n ! = Γ ( n + 1).

Probieren Sie es online!

1 Byte dank Dennis und 6 dank Glen O!

Alex A.
quelle
Fast genau das gleiche in MATLAB:@(n)sum(1./factorial(0:n))
Fehler
6

Python, 36 Bytes

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
quelle
Python 3 - Variante könnte kürzer sein mit orstatt and: f=lambda n,i=1:i>=n or 1+f(n,i+1)/i.
Konstruktor
6

Gleichstrom, 43 Bytes

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

Dies ist eine ziemlich direkte Übersetzung der Serie. Ich habe versucht, klüger zu sein, aber das führte zu längerem Code.

Erläuterung

[d1-d1<f*]sf

Eine einfache Fakultätsfunktion für n> 0

[dlfx1r/r1-d1<e+]se

Führe die Fakultät für n, ..., 1 aus; invertieren und summieren

1?dk1-

Füllen Sie den Stapel mit 1; Eingaben übernehmen und entsprechende Genauigkeit einstellen

d1<e+

Wenn die Eingabe 0 oder 1 war, können wir sie einfach weitergeben, oder die Teilsumme berechnen.

p

Drucken Sie das Ergebnis.

Testergebnisse

Die ersten 100 Erweiterungen:

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

Mit 1000 Begriffen:

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

J, 10 Bytes

[:+/%@!@i.

Unkomplizierter Ansatz.

Erläuterung

[:+/%@!@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
Meilen
quelle
Nett. Triviale 1-Byte-Verbesserung:1#.%@!@i.
Jonah
4

CJam, 11

r~,:m!Wf#:+

oder

r~{m!W#}%:+

Probieren Sie es online aus: erste Version und zweite Version

Erläuterung:

r~= lesen und auswerten
m!= faktoriell
W#= zur -1-Potenz erhöhen ( W= -1)
:+= Summe des Arrays Die
erste Version konstruiert das [0… N-1] -Array und wendet faktoriell und invers auf alle seine Elemente an; Die 2. Version führt faktorielle und inverse Operationen für jede Zahl durch und fügt sie dann in ein Array ein.

aditsu
quelle
4

JavaScript ES6, 44 42 40

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

Eine unbenannte Funktion jetzt.

Vielen Dank für das Speichern von 2 Bytes @AlexA und danke an @LeakyNun für weitere 2 Bytes!

ಠ_ಠ
quelle
n=>{for(k=s=m=1;m<n;s+=k/=m++);return s}
Undichte Nonne
4

MATL, 11 7 Bytes

:Ygl_^s

4 Bytes gespart dank der Empfehlung von @ Luis, gamma( Yg) zu verwenden

Probieren Sie es online

Erläuterung

        % 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
quelle
Sie können entfernen]
Luis Mendo
Auch 1i:Yg/sfür 7 Bytes
Luis Mendo
@LuisMendo oh ja, ich hatte gehofft, es gäbe einen besseren Weg, um eine Fakultät zu bekommen, aber ich hatte Gamma vergessen. Wird in Kürze aktualisiert
Suever
4

MATL , 6 Bytes

q_t1Zh

Dies berechnet die Summe mit der hypergeometrischen Funktion 1 F 1 ( a ; b ; z ):

Bildbeschreibung hier eingeben

Funktioniert auf Octave und auf den Online - Compiler, aber nicht auf Matlab, aufgrund einer Differenz in , wie die hypergeometric Funktion definiert ist (die korrigiert werden).

Probieren Sie es online!

Erläuterung

q_    % Take N implicitly. Compute -N+1
t     % Duplicate
1     % Push 1
Zh    % Hypergeometric function 1F1(-N+1;-N+1;1). Implicitly display
Luis Mendo
quelle
4

C 249 Bytes

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

Nimmt eine Zahl als Argument, um die Anzahl der Iterationen zu bestimmen.

LordCreepity
quelle
Hallo und willkommen bei PPCG! Toller erster Beitrag!
NoOneIsHere
Willkommen bei Programming Puzzles & Code Golf! Ich denke, das Programm soll nur die letzte Annäherung drucken. Zumindest bei GCC braucht man das intvorher mainund das nicht return 0. Auch, wenn Sie ersetzen NULLmit 0, brauchen Sie nicht das enthält. argcund argvkann zu einbuchstabigen Variablen gekürzt werden. Wenn Sie gerne in C Golf spielen, finden Sie möglicherweise hilfreiche Tipps zum Golfen in C.
Dennis
IMHO, auch wenn der Compiler einige Warnungen ausgibt, aber dennoch das richtige Ergebnis zurückgibt, können Sie viele Teile Ihres Codes so weit wegwerfen, dass nichts ohne einen Fehler reduziert werden kann.
Andreï Kostyrka
Und du brauchst nicht#include <stdio.h>
Undichte Nonne
3

k (13 Bytes)

Vorbehaltlich von Überläufen für N>20

{+/%*\1,1+!x}
Skeevey
quelle
3

05AB1E, 6 Bytes

$L<!/O

Erklärt

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

Probieren Sie es online aus

Emigna
quelle
1
5 Bytes mit L<!zO.
Grimmy
3

Pyke, 10 Bytes

FSBQi^R/)s

Probieren Sie es hier aus!

Oder 8 Bytes, wenn power = 1 ist

FSB1R/)s

Probieren Sie es hier aus!

Blau
quelle
Der erste Code war um mehr als 3 falsch, als ich ihn ausführte: 5.436532738095238
tox123
@ Tox123 jetzt behoben
Blue
Testest du diese? Ich habe: 7.3887125220458545 für die erste, die zweite funktioniert viel besser.
Tox123
Dieser ist ein e ^ x, den Sie nicht nur kennen
Blue
Das ist nicht die Herausforderung.
Tox123
3

JavaScript (ES6), 28 Byte

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

Dyalog APL , 6 Bytes

+/÷!⍳⎕

+/Summe
÷der Kehrwerte
!der Fakultäten
der Zahlen von 0 bis zur
numerischen Eingabe

Angenommen ⎕IO←0, das ist auf vielen Systemen Standard.

TryAPL !

Adam
quelle
3

Haskell, 37 Bytes

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

Nicht die kürzeste, aber wohl die schönste.


Ebenfalls mit freundlicher Genehmigung von Laikoni ist hier eine Lösung, die 2 Byte kürzer ist:

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
Rodrigo de Azevedo
quelle
2
Sie können diesen UTF-8-Byte-Zähler verwenden . Ich habe eine vorgeschlagene Änderung vorgenommen, um die Anzahl der Bytes zu erhöhen 50. Um einen Header hinzuzufügen, verwenden: ## Language, <xxx> bytes.
NoOneIsHere
1
Benötigen Sie das Leerzeichen?
NoOneIsHere
1
Sie können nicht davon ausgehen, dass die Eingabe in einer Variablen vorhanden ist. Daher müssen Sie eine gültige Funktionsübermittlung voranstellen f n=oder abrufen \n->. Wir können aber auch ein paar Bytes einsparen: (\x->1/x)Kann auf den Abschnitt gekürzt werden (1/), [1,2..]ist genauso wie [1..]und map(...)$kann sein (...)<$>. Zusammen 36 Bytes: Probieren Sie es online!
Laikoni
1
Durch die Konvertierung in eine punktfreie Funktion wird ein weiteres Byte gespart: Probieren Sie es online aus! Und obwohl es ein Byte länger ist, ((scanl(+)0$(1/)<$>scanl(*)1[1..])!!)sieht es auch gut aus.
Laikoni
1
Wie Sie selbst gesehen haben, ist die Version ohne Klammern nur ein gültiger Haskell-Ausdruck, wenn Sie einen Wert danach einfügen. Da jedoch davon ausgegangen wird, dass die Eingabe in einer vordefinierten Variablen nicht zulässig ist , müssen Sie die Klammern hinzufügen oder erneut einen Zeilenumbruch \n->erstellen eine Funktion.
Laikoni
3

APL (Dyalog Unicode) , 5 Bytes

⍳⊥⊢÷!

Probieren Sie es online!

Verwenden Sie den gemischten Basistrick, der in meiner Antwort auf eine andere Herausforderung enthalten ist . Verwendet ⎕IO←0.

Wie es funktioniert

⍳⊥⊢÷!  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)!
Bubbler
quelle
10k rep! Nun, um zu sehen, ob ich das in Turing Machine
durchziehen
Gute Antwort, aber ich habe Probleme beim Erkennen 1÷(n-1)!einer Ziffer. Könnten Sie es zur Verdeutlichung in J übersetzen?
Jona
2

Eigentlich 6 Bytes

r♂!♂ìΣ

Probieren Sie es online!

Erläuterung:

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

Brachylog , 18 Bytes

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

Erläuterung

: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
Tödlich
quelle
2

Ahorn, 18

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

Verwendung:

> f:=n->add(1/i!,i=0..n-1);
> f(1);
  1
> f(4);
  8/3
DSkoog
quelle
Ich denke, die Funktion ist n-> add (1 / i!, I = 0..n-1)
RosLuP
2

C 69 Bytes

double f(int n){double s=1,f=1;for(int i=0;i++<n;s+=f)f/=i;return s;}

Ideone es!

Undichte Nonne
quelle
2

Java mit zehn Fuß Laser Pole , 238 236 Bytes

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

Besserer Überlaufwiderstand als die meisten anderen Antworten. Für 100 Terme lautet das Ergebnis

31710869445015912176908843526535027555643447320787267779096898248431156738548305814867560678144006224158425966541000436701189187481211772088720561290395499/11665776930493019085212404857033337561339496033047702683574120486902199999153739451117682997019564785781712240103402969781398151364608000000000000000000000
SuperJedi224
quelle
2

Julia, 28 Bytes

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

Erläuterung

~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)ist gleich factorial(k)für positive Ganzzahleingaben und verallgemeinert es für alle Werte außer den nichtnegativen Ganzzahlen. Es spart ein Byte, warum also nicht?

eaglgenes101
quelle
1

MATLAB / Octave, 22 Bytes

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

Erstellt eine anonyme Funktion mit dem Namen ans, die mit aufgerufen werden kann ans(N).

Diese Lösung berechnet gamma(x)für jedes Element im Array [1 ... N], das gleich ist factorial(x-1). Wir nehmen dann die Umkehrung jedes Elements und summieren alle Elemente.

Online Demo

Suever
quelle
1

Perl 5, 37 Bytes

Kein Gewinner, aber nett und unkompliziert:

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

Ausgänge für Eingänge von 0 bis 10:

1
2
2.5
2.66666666666667
2.70833333333333
2.71666666666667
2.71805555555556
2.71825396825397
2.71827876984127
2.71828152557319
2.71828180114638
hobbs
quelle
1

R, 17 Bytes

sum(1/gamma(1:n))

Ganz einfach, auch wenn irgendwann Probleme mit der numerischen Genauigkeit auftreten werden.

Andreï Kostyrka
quelle