Perkiraan e

21

Kita semua tahu bahwa angka Euler , dilambangkan dengan e, dengan kekuatan beberapa variabel x, dapat diperkirakan dengan menggunakan ekspansi Seri Maclaurin :

Ekspansi seri Maclaurin dari e ^ x

Dengan membiarkan x sama dengan 1, kita memperoleh

Ekspansi seri Maclaurin dari e

Tantangan

Tulis program dalam bahasa apa pun yang mendekati angka Euler dengan mengambil input N dan menghitung deret ke suku N-th. Perhatikan bahwa suku pertama memiliki penyebut 0 !, bukan 1 !, yaitu N = 1 sesuai dengan 1/0 !.

Mencetak gol

Program dengan jumlah byte terkecil menang.

Meow Mix
sumber
7
Diberikan cukup besar Nhasilnya akan sama jika menggunakan angka floating point presisi terbatas. Apakah perilaku itu dapat diterima atau apakah hasilnya harus semakin akurat saat Nmendekati tak terbatas?
FryAmTheEggman
12
Beberapa test case akan rapi.
Lynn
7
(Masalah seperti ini sebaiknya diselesaikan di kotak pasir - jika Anda memposting tantangan Anda di sana lebih dulu, pegolf akan memberikan umpan balik yang bermanfaat.)
Lynn
2
Apakah x ^ n istilah ke-n atau (n +1)?
msh210
4
Saya pribadi membencinya, tetapi ada orang yang menyebut istilah di indeks 0 sebagai istilah nol. Terlepas dari pemikiran kita tentang hal itu, pertanyaannya harus sejelas mungkin. Juga, beberapa uji kasus untuk memverifikasi bahwa solusi berfungsi dengan benar, akan sangat membantu.
Dennis

Jawaban:

13

Wistful-C - 336 bytes

Program sayu-nyata pertama saya! Sebenarnya ada sedikit golf yang saya lakukan, dengan menggunakan somedaybukan wait forkarena yang pertama memiliki panjang lebih pendek.

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
sumber
Saya diberitahu bahwa Anda tidak perlu memasukkan<stdio.h>
Leaky Nun
Apakah ini someday i were N...berfungsi someday i will be N...?
Leaky Nun
10

Pyth, 7 6 byte

smc1.!

Coba di sini.

 m      map over range 0..input:
    .!  factorial
  c1    1 / ^
s       sum

Terima kasih kepada FryAmTheEggman untuk satu byte!

Gagang pintu
sumber
9

TI-84 BASIC, 12 15 14

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

TI adalah bahasa tokenized ( byte dihitung melalui token , bukan karakter individu).

Tanpa nama
sumber
1
Posting meta yang dikutip memiliki 11 upvote dan 10 downvotes. Itu bukan konsensus. Ansbukan format input yang valid, jadi hanya versi 15-byte yang valid.
Mego
cukup adil; pengeditan ...
No Name
1
Ansselalu menjadi format input default di sini di PPCG (lihat jawaban TI lama saya), dan lebih banyak orang setuju daripada tidak setuju dengan itu, jadi jangan diganggu untuk mengubah jawaban Anda.
Timtech
2
@MickLH bukan itu perselisihan di sini. Selain itu, ini adalah byte 8-bit.
hobbs
1
@Timtech Sementara saya setuju dengan Anda, konsensus komunitas didefinisikan seperti yang dikatakan Mego.
Conor O'Brien
9

Julia, 28 27 21 byte

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

Ini adalah fungsi anonim yang menerima integer dan mengembalikan float. Untuk menyebutnya, tetapkan ke variabel.

Pendekatannya cukup mudah. Kami sum1 dibagi dengan fungsi gamma yang dievaluasi pada masing-masing 1 hingga n . Ini mengambil keuntungan dari properti n ! = Γ ( n +1).

Cobalah online!

Disimpan 1 byte berkat Dennis dan 6 berkat Glen O!

Alex A.
sumber
Hampir persis sama di MATLAB:@(n)sum(1./factorial(0:n))
flawr
6

Python, 36 byte

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
Tidak
sumber
Python 3 varian bisa lebih pendek dengan orbukannya and: f=lambda n,i=1:i>=n or 1+f(n,i+1)/i.
Konstruktor
6

dc, 43 byte

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

Ini adalah terjemahan seri yang cukup langsung. Saya mencoba menjadi lebih pintar, tetapi itu menghasilkan kode yang lebih panjang.

Penjelasan

[d1-d1<f*]sf

Fungsi faktorial sederhana, untuk n> 0

[dlfx1r/r1-d1<e+]se

Jalankan faktorial untuk n, ..., 1; membalikkan dan menjumlahkan

1?dk1-

Perdana tumpukan dengan 1; menerima input dan mengatur presisi yang sesuai

d1<e+

Jika input 0 atau 1, kita bisa meneruskannya, jika tidak hitung jumlah parsial.

p

Cetak hasilnya.

Hasil tes

100 ekspansi pertama:

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

Menggunakan 1000 istilah:

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

J, 10 byte

[:+/%@!@i.

Pendekatan lurus ke depan.

Penjelasan

[:+/%@!@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
mil
sumber
Bagus. Peningkatan 1 byte sepele:1#.%@!@i.
Jonah
4

CJam, 11

r~,:m!Wf#:+

atau

r~{m!W#}%:+

Cobalah online: versi pertama dan versi kedua

Penjelasan:

r~= membaca dan mengevaluasi
m!= faktorial
W#= naikkan ke daya -1 ( W= -1)
:+= jumlah array
Versi pertama membangun array [0 ... N-1] dan menerapkan faktorial dan terbalik untuk semua elemennya; Versi ke-2 melakukan faktorial dan terbalik untuk setiap angka kemudian menempatkannya dalam sebuah array.

aditsu
sumber
4

JavaScript ES6, 44 42 40

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

Fungsi yang tidak disebutkan namanya sekarang.

Terima kasih telah menyimpan 2 byte @AlexA dan terima kasih kepada @LeakyNun untuk 2 byte lainnya!

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

MATL, 11 7 byte

:Ygl_^s

4 byte disimpan berkat rekomendasi @ Luis untuk menggunakan gamma( Yg)

Cobalah secara Online

Penjelasan

        % 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
sumber
Anda dapat menghapus]
Luis Mendo
Juga, 1i:Yg/sselama 7 byte
Luis Mendo
@LuisMendo oh ya saya berharap ada cara yang lebih baik untuk mendapatkan faktorial tetapi saya lupa tentang gamma. Akan segera diperbarui
Suever
4

MATL , 6 byte

q_t1Zh

Ini menghitung jumlah menggunakan fungsi hypergeometric 1 F 1 ( a ; b ; z ):

masukkan deskripsi gambar di sini

Bekerja pada oktaf dan pada kompiler online, tetapi tidak pada Matlab, karena perbedaan dalam bagaimana fungsi hypergeometric didefinisikan (yang akan diperbaiki).

Cobalah online!

Penjelasan

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
sumber
4

C, 249 byte

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

Tidak Disatukan:

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

Mengambil nomor sebagai argumen untuk menentukan jumlah iterasi.

LordCreepity
sumber
Halo, dan selamat datang di PPCG! Pos pertama yang bagus!
NoOneIsHere
Selamat Datang di Programming Puzzles & Code Golf! Saya pikir program ini dimaksudkan untuk mencetak hanya perkiraan terakhir. Setidaknya dengan GCC, Anda tidak perlu intsebelum maindan return 0. Juga, jika Anda mengganti NULLdengan 0, Anda tidak perlu menyertakan. argcdan argvdapat disingkat menjadi variabel huruf tunggal. Jika Anda menikmati bermain golf di C, Anda mungkin menemukan Tips untuk bermain golf di C bermanfaat.
Dennis
IMHO, meskipun kompiler melempar beberapa peringatan tetapi mengembalikan hasil yang benar, Anda dapat membuang banyak bagian kode Anda ke titik bahwa tidak ada yang dapat dikurangi tanpa kesalahan.
Andreï Kostyrka
Dan Anda tidak perlu#include <stdio.h>
Leaky Nun
3

k (13 byte)

Tunduk pada luapan untuk N>20

{+/%*\1,1+!x}
skeevey
sumber
3

05AB1E, 6 byte

$L<!/O

Dijelaskan

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

Cobalah online

Emigna
sumber
1
5 byte dengan L<!zO.
Grimmy
3

Pyke, 10 byte

FSBQi^R/)s

Coba di sini!

Atau 8 byte jika daya = 1

FSB1R/)s

Coba di sini!

Biru
sumber
kode pertama mati oleh lebih dari 3 ketika saya menjalankannya: 5.436532738095238
tox123
@ tox123 diperbaiki sekarang
Biru
Apakah Anda sedang menguji ini? Saya mendapat: 7.3887125220458545 untuk yang pertama, yang kedua bekerja lebih baik.
tox123
Yang itu adalah e ^ x yang kamu tahu bukan hanya e
Blue
itu bukan tantangannya.
tox123
3

JavaScript (ES6), 28 byte

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

Dyalog APL , 6 byte

+/÷!⍳⎕

+/jumlah
÷kebalikan dari
!faktorial
angka dari 0 hingga
input numerik

Asumsikan ⎕IO←0, yang merupakan default pada banyak sistem.

TryAPL !

Adm
sumber
3

Haskell, 37 byte

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

Bukan yang terpendek, tapi bisa dibilang yang tercantik.


Juga atas izin Laikoni , berikut adalah solusi yang lebih pendek 2 byte :

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
sumber
2
Anda dapat menggunakan penghitung byte UTF-8 ini . Saya memasukkan edit yang disarankan untuk menambahkan jumlah byte Anda, yaitu 50. Untuk menambahkan header, gunakan: ## Language, <xxx> bytes.
NoOneIsHere
1
Apakah Anda memerlukan spasi?
NoOneIsHere
1
Anda tidak dapat menganggap input hadir dalam variabel, jadi Anda perlu menambahkan f n=atau \n->mendapatkan pengajuan fungsi yang valid. Namun, kita juga dapat menyimpan beberapa byte: (\x->1/x)bisa disingkat menjadi bagian (1/), [1,2..]sama dengan [1..]dan map(...)$bisa (...)<$>. Bersama 36 byte: Cobalah online!
Laikoni
1
Mengubah ke fungsi bebas-titik menghemat byte lain: Coba online! Dan meskipun itu satu byte lebih lama, ((scanl(+)0$(1/)<$>scanl(*)1[1..])!!)terlihat bagus juga.
Laikoni
1
Seperti yang Anda lihat sendiri, versi tanpa tanda kurung hanya ekspresi Haskell yang valid saat memasukkan nilai setelahnya, tetapi dengan asumsi input yang akan ada dalam variabel yang telah ditentukan tidak diperbolehkan , Anda harus menambahkan tanda kurung atau lagi yang mengarah \n->untuk membuat sebuah fungsi.
Laikoni
3

APL (Dyalog Unicode) , 5 byte

⍳⊥⊢÷!

Cobalah online!

Menggunakan trik basis campuran yang ditemukan dalam jawaban saya untuk tantangan lain . Penggunaan ⎕IO←0.

Bagaimana itu bekerja

⍳⊥⊢÷!  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
sumber
Perwakilan 10k! Sekarang untuk melihat apakah saya dapat melakukan ini di Turing Machine ....
ouflak
Jawaban yang bagus tapi saya mengalami kesulitan melihat bagaimana 1÷(n-1)!digit? Bisakah Anda menerjemahkannya ke J untuk menjelaskan?
Jonah
2

Sebenarnya, 6 byte

r♂!♂ìΣ

Cobalah online!

Penjelasan:

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

Brachylog , 18 byte

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

Penjelasan

: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
Fatalisasi
sumber
2

Maple, 18

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

Pemakaian:

> f:=n->add(1/i!,i=0..n-1);
> f(1);
  1
> f(4);
  8/3
DSkoog
sumber
Saya pikir fungsinya adalah n-> add (1 / i!, I = 0..n-1)
RosLuP
2

C, 69 byte

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

Ide itu!

Biarawati Bocor
sumber
2

Java dengan Tiang Laser Kaki Sepuluh , 238 236 byte

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

Memiliki ketahanan overflow yang jauh lebih baik daripada sebagian besar jawaban lainnya. Untuk 100 syarat, hasilnya adalah

31710869445015912176908843526535027555643447320787267779096898248431156738548305814867560678144006224158425966541000436701189187481211772088720561290395499/11665776930493019085212404857033337561339496033047702683574120486902199999153739451117682997019564785781712240103402969781398151364608000000000000000000000
SuperJedi224
sumber
2

Julia, 28 byte

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

Penjelasan

~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)sama dengan factorial(k)untuk input integer positif, dan menggeneralisasikannya untuk semua nilai selain dari integer nonnegatif. Menghemat satu byte, jadi mengapa tidak menggunakannya?

eaglgenes101
sumber
1

MATLAB / Oktaf, 22 byte

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

Menciptakan fungsi anonim bernama ansyang dapat dipanggil menggunakan ans(N).

Solusi ini menghitung gamma(x)untuk setiap elemen dalam array [1 ... N] yang sama dengan factorial(x-1). Kami kemudian mengambil kebalikan dari setiap elemen dan menjumlahkan semua elemen.

Demo online

Suever
sumber
1

Perl 5, 37 byte

Bukan pemenang, tetapi baik dan langsung:

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

Output untuk input dari 0 hingga 10:

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

R, 17 byte

sum(1/gamma(1:n))

Cukup mudah, meskipun masalah presisi numerik pasti akan muncul di beberapa titik waktu.

Andreï Kostyrka
sumber