Aproximación de e


21

Todos sabemos que el número de Euler , denotado por e, a la potencia de alguna variable x, puede aproximarse usando la expansión de la serie Maclaurin :

Expansión de la serie Maclaurin de e ^ x

Al dejar que x sea igual a 1, obtenemos

Expansión de la serie Maclaurin de e

Desafío

Escriba un programa en cualquier idioma que se aproxime al número de Euler tomando una entrada N y calcule la serie al término N-ésimo. Tenga en cuenta que el primer término tiene el denominador 0 !, no 1 !, es decir, N = 1 corresponde a 1/0 !.

Puntuación

Programa con la menor cantidad de bytes gana.


77
Dado lo suficientemente grande, Nlos resultados serán los mismos si se usa un número de coma flotante de precisión finita. ¿Es aceptable ese comportamiento o el resultado tiene que ser progresivamente más preciso a medida que se Nacerca al infinito?
FryAmTheEggman

12
Algunos casos de prueba estarían limpios.
Lynn

77
(Este tipo de problema se resuelve preferiblemente en la caja de arena ; si publica sus desafíos allí primero, los golfistas darán su opinión útil).
Lynn

2
¿Es x ^ n el enésimo término o el (n + 1) th?
msh210

44
Personalmente lo desprecio, pero hay personas que se refieren al término en el índice 0 como término cero. Independientemente de nuestros pensamientos al respecto, la pregunta debe ser lo más clara posible. Además, algunos casos de prueba para verificar que las soluciones funcionan correctamente serían muy útiles.
Dennis

Respuestas:



13

Wistful-C - 336 bytes

¡Mi primer programa melancólico! En realidad, hice un poco de golf, con el uso en somedaylugar de wait forporque el primero tenía una longitud más corta.

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

Me dijeron que no es necesario incluir<stdio.h>
Leaky Nun

¿ someday i were N...Funciona en lugar de someday i will be N...?
Leaky Nun


9

TI-84 BÁSICO, 12 15 14

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

TI es un lenguaje tokenizado (los bytes se cuentan mediante tokens , no caracteres individuales).


1
La meta publicación mencionada tiene 11 votos a favor y 10 votos a favor. Eso no es un consenso. Ansno es un formato de entrada válido, por lo que solo la versión de 15 bytes es válida.
Mego

lo suficientemente justo; edición ...
Sin nombre

1
Anssiempre ha sido el formato de entrada predeterminado aquí en PPCG (consulte mis antiguas respuestas de TI), y más personas están de acuerdo que en desacuerdo con eso, así que no se deje intimidar por cambiar su respuesta.
Timtech

2
@MickLH esa no es la disputa aquí. Además, estos son bytes de 8 bits.
hobbs

1
@Timtech Si bien estoy de acuerdo con usted, el consenso de la comunidad se define como dice Mego.
Conor O'Brien

9

Julia, 28 27 21 bytes

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

Esta es una función anónima que acepta un entero y devuelve un flotante. Para llamarlo, asígnelo a una variable.

El enfoque es bastante sencillo. Nos sum1 dividido por la función gamma evaluado en cada uno de 1 a n . Esto aprovecha la propiedad n ! = Γ ( n +1).

Pruébalo en línea!

¡Ahorré 1 byte gracias a Dennis y 6 gracias a Glen O!


Casi exactamente lo mismo en MATLAB:@(n)sum(1./factorial(0:n))
flawr

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

Python 3 variante podría ser más corto con orlugar de and: f=lambda n,i=1:i>=n or 1+f(n,i+1)/i.
Constructor

6

cc, 43 bytes

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

Esta es una traducción bastante directa de la serie. Traté de ser más inteligente, pero eso resultó en un código más largo.

Explicación

[d1-d1<f*]sf

Una función factorial simple, para n> 0

[dlfx1r/r1-d1<e+]se

Ejecute el factorial para n, ..., 1; invertir y sumar

1?dk1-

Prepara la pila con 1; aceptar entrada y establecer una precisión adecuada

d1<e+

Si la entrada fue 0 o 1, podemos pasarla, de lo contrario, calcular la suma parcial.

p

Imprime el resultado.

Resultados de la prueba

Las primeras 100 expansiones:

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

Usando 1000 términos:

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

5

J, 10 bytes

[:+/%@!@i.

Enfoque directo.

Explicación

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

Agradable. Mejora trivial de 1 byte:1#.%@!@i.
Jonás

4

CJam, 11

r~,:m!Wf#:+

o

r~{m!W#}%:+

Pruébelo en línea: primera versión y segunda versión

Explicación:

r~= leer y evaluar
m!= factorial
W#= elevar a la potencia -1 ( W= -1)
:+= suma de la matriz La
primera versión construye la matriz [0 ... N-1] y aplica factorial e inverso a todos sus elementos; La segunda versión hace factorial e inverso para cada número y luego los coloca en una matriz.


4

JavaScript ES6, 44 42 40

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

Una función sin nombre ahora.

¡Gracias por guardar 2 bytes @AlexA y gracias a @LeakyNun por otros 2 bytes!


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

4

MATL, 11 7 bytes

:Ygl_^s

4 bytes guardados gracias a la recomendación de @ Luis de usar gamma( Yg)

Pruébalo en línea

Explicación

        % 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

Puede eliminar]
Luis Mendo

Además, 1i:Yg/spara 7 bytes
Luis Mendo

@LuisMendo oh sí, esperaba que hubiera una mejor manera de obtener un factorial, pero me había olvidado de la gamma. Se actualizará en breve
Suever

4

MATL , 6 bytes

q_t1Zh

Esto calcula la suma usando el función hipergeométrica 1 F 1 ( a ; b ; z ):

ingrese la descripción de la imagen aquí

Funciona en Octave y en el compilador en línea, pero no en Matlab, debido a una diferencia en cómo se define la función hipergeométrica (que se corregirá).

Pruébalo en línea!

Explicación

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

Sin golf:

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

Toma un número como argumento para determinar el número de iteraciones.


Hola y bienvenidos a PPCG! Gran primer post!
NoOneIsHere

¡Bienvenido a Programming Puzzles & Code Golf! Creo que el programa está destinado a imprimir solo la última aproximación. Al menos con GCC, no necesitas el intantes mainy el return 0. Además, si reemplaza NULLcon 0, no necesita las inclusiones. argcy argvse puede acortar a variables de una letra. Si le gusta jugar golf en C, puede encontrar consejos útiles para jugar golf en C.
Dennis

En mi humilde opinión, incluso si el compilador arroja algunas advertencias pero devuelve el resultado correcto, puede tirar muchas partes de su código hasta el punto de que nada podría reducirse sin un error.
Andreï Kostyrka

Y no necesitas #include <stdio.h>
Leaky Nun

3

k (13 bytes)

Sujeto a desbordamientos por N>20

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

3

05AB1E, 6 bytes

$L<!/O

Explicado

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

Pruébalo en línea


1
5 bytes con L<!zO.
Grimmy

3

Pyke, 10 bytes

FSBQi^R/)s

Pruébalo aquí!

O 8 bytes si potencia = 1

FSB1R/)s

Pruébalo aquí!


el primer código estaba desactivado por más de 3 cuando lo ejecuté: 5.436532738095238
tox123

@ tox123 arreglado ahora
Azul

estas probando esto? Obtuve: 7.3887125220458545 para el primero, el segundo funciona mucho mejor.
tox123

Ese es un e ^ x uno que conoces no solo e
Azul

Ese no es el desafío.
tox123

3

JavaScript (ES6), 28 bytes

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

3

Dyalog APL , 6 bytes

+/÷!⍳⎕

+/suma de
÷los recíprocos de
!los factoriales de
los números de 0 a
entrada numérica

Asume ⎕IO←0, lo cual es predeterminado en muchos sistemas.

TryAPL !


3

Haskell, 37 bytes

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

No es el más corto, pero podría decirse que es el más bonito.


También cortesía de Laikoni , aquí hay una solución que es 2 bytes más corta:

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
Puede usar este contador de bytes UTF-8 . Puse una edición sugerida para agregar su número de bytes, que es 50. Para añadir un encabezado, utilice: ## Language, <xxx> bytes.
NoOneIsHere

1
¿Necesitas el espacio en blanco?
NoOneIsHere

1
No puede suponer que la entrada está presente en una variable, por lo que debe anteponer f n=u \n->obtener un envío de función válido. Sin embargo, también podemos guardar algunos bytes: (\x->1/x)se puede acortar a la sección (1/), [1,2..]es lo mismo [1..]y map(...)$se puede (...)<$>. Juntos 36 bytes: ¡ Pruébelo en línea!
Laikoni

1
La conversión a una función sin puntos ahorra otro byte: ¡ Pruébelo en línea! Y aunque es un byte más largo, también se ((scanl(+)0$(1/)<$>scanl(*)1[1..])!!)ve bien.
Laikoni 01 de

1
Como se ha visto a sí mismo, la versión sin paréntesis es solo una expresión válida de Haskell al insertar un valor después de ella, pero dado que no se permite que la entrada esté presente en una variable predefinida , debe agregar los paréntesis o de nuevo un encabezado \n->para crear Una función.
Laikoni

3

APL (Dyalog Unicode) , 5 bytes

⍳⊥⊢÷!

Pruébalo en línea!

Usando el truco de base mixta que se encuentra en mi respuesta de otro desafío . Usos ⎕IO←0.

Cómo funciona

⍳⊥⊢÷!  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)!

10k rep! Ahora para ver si puedo lograr esto en Turing Machine ...
ouflak

Buena respuesta, pero tengo problemas para ver cómo 1÷(n-1)!es un dígito. ¿Podría traducirlo a J para aclarar?
Jonás

2

En realidad, 6 bytes

r♂!♂ìΣ

Pruébalo en línea!

Explicación:

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

2

Brachylog , 18 bytes

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

Explicación

: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

Arce, 18

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

Uso:

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

Creo que la función es n-> add (1 / i!, I = 0..n-1)
RosLuP


2

Java con poste láser de diez pies , 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);}}

Tiene una resistencia al desbordamiento mucho mejor que la mayoría de las otras respuestas. Para 100 términos, el resultado es

31710869445015912176908843526535027555643447320787267779096898248431156738548305814867560678144006224158425966541000436701189187481211772088720561290395499/11665776930493019085212404857033337561339496033047702683574120486902199999153739451117682997019564785781712240103402969781398151364608000000000000000000000

2

Julia, 28 bytes

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

Explicación

~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)es igual a factorial(k)las entradas de enteros positivos, y lo generaliza para todos los valores que no sean los enteros no negativos. Guarda un byte, entonces, ¿por qué no usarlo?


1

MATLAB / Octave, 22 bytes

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

Crea una función anónima llamada a la ansque se puede llamar usando ans(N).

Esta solución calcula gamma(x)para cada elemento en la matriz [1 ... N] que es igual a factorial(x-1). Luego tomamos el inverso de cada elemento y sumamos todos los elementos.

Demo en línea


1

Perl 5, 37 bytes

No es un ganador, pero agradable y directo:

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

Salidas para entradas de 0 a 10:

1
2
2.5
2.66666666666667
2.70833333333333
2.71666666666667
2.71805555555556
2.71825396825397
2.71827876984127
2.71828152557319
2.71828180114638

1

R, 17 bytes

sum(1/gamma(1:n))

Muy sencillo, aunque es probable que surjan problemas de precisión numérica en algún momento.


Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.