Dado un número entero no negativo $n ,$ salida de la $n^{\text{th}}$ número de Euler ( OEIS A122045 ).

Todos los números de Euler indexados impar son $0 .$Los números de Euler de índice par pueden calcularse con la siguiente fórmula ( $i \equiv \sqrt{-1}$ refiere a la unidad imaginaria):

$$E_{2n} = i \sum_{k=1}^{2n+1}{ \sum_{j=0}^{k}{ \left(\begin{array}{c}k \\ j \end{array}\right) \frac{{\left(-1\right)}^{j} {\left(k-2j\right)}^{2n+1}}{2^k i^k k} } } \,.$$

Reglas

• $n$ será un número entero no negativo de modo que el número$n^{\text{th}}$ Euler esté dentro del rango representable de números enteros para su idioma.

Casos de prueba

0 -> 1
1 -> 0
2 -> -1
3 -> 0
6 -> -61
10 -> -50521
20 -> 370371188237525

Mathematica, 6 bytes

EulerE

-tos-

J , 10 bytes

(1%6&o.)t:

Pruébalo en línea!

Utiliza la definición para la función de generación exponencial sech (x).

Pari / GP , 32 bytes

n->n!*Vec(1/cosh(x+O(x^n++)))[n]

Pruébalo en línea!

Arce, 5 bytes

euler

¿Hurra por las builtins?

Máximo , 5 bytes / 42 bytes

Maxima tiene incorporado:

euler

Pruébalo en línea!

La siguiente solución no requiere el incorporado desde arriba, y utiliza la fórmula que definió originalmente los números de Euler.

Básicamente estamos buscando el coeficiente n-ésimo de la expansión de la serie de 1/cosh(t) = sech(t)(hasta el n!)

f(n):=coeff(taylor(sech(x),x,0,n)*n!,x,n);

Pruébalo en línea!

Mathematica, sin incorporado, 18 bytes

Usando la fórmula de @ rahnema1 :

2Im@PolyLog[-#,I]&

---

21 bytes:

Sech@x~D~{x,#}/.x->0&

Python 2.7, 46 bytes

Usando scipy.

from scipy.special import*
lambda n:euler(n)[n]

Perl 6 , 78 bytes

{(->*@E {1-sum @E».&{$_*2**(@E-1-$++)*[*](@E-$++^..@E)/[*] 1..$++}}...*)[$_]}

Utiliza la fórmula iterativa de aquí :

$$E_n = 1 - \sum_{k=0}^{n-1} \left[ E_k \cdot 2^{(n-1-k)} \cdot \binom{n}{k} \right]$$

Cómo funciona

La estructura general es una lambda en la que se genera una secuencia infinita, mediante una expresión que se llama repetidamente y obtiene todos los valores anteriores de la secuencia en la variable @E, y luego esa secuencia se indexa con el argumento lambda:

{ ( -> *@E {    } ... * )[$_] }

La expresión llamada para cada paso de la secuencia es:

1 - sum @E».&{              # 1 - ∑
    $_                      # Eₙ
    * 2**(@E - 1 - $++)     # 2ⁿ⁻ˡ⁻ᵏ
    * [*](@E - $++ ^.. @E)  # (n-k-1)·...·(n-1)·n
    / [*] 1..$++            # 1·2·...·k
}

Máxima, 29 bytes

z(n):=2*imagpart(li[-n](%i));

¡Pruébelo en línea!

Dos veces parte imaginaria de la función de orden polilogaritmo -ncon argumento i [1]

JavaScript (Node.js) , 46 45 bytes

F=(a,b=a)=>a?(b+~a)*F(--a,b-2)+F(a,b)*++b:+!b

Pruébalo en línea!

Válido para todos los valores (según se requiera), pero no para generalmente (salidas para impar s.) Se modifica el código para reducir un byte cambiando la salida a donde se define como a continuación. Específicamente, la fórmula de recurrencia para es$E_n$$F(n, i)$$-F(n,i)$$n$$F'(n,i)=(-1)^nF(n,i)$$F$$F'$

$$F'(n,i)=(i-n-1)F'(n-1,i-2)+(i+1)F'(n-1,i)$$

JavaScript (Node.js) , 70 46 bytes

F=(a,b=a)=>a?-F(--a,b)*++b+F(a,b-=3)*(a-b):+!b

Pruébalo en línea!

Sorprendido de no encontrar una respuesta de JavaScript todavía, así que intentaré.

El código consiste solo en matemáticas básicas, pero las matemáticas detrás del código requieren cálculo. La fórmula de recursión se deriva de la expansión de las derivadas de de diferentes órdenes.$\mathrm{sech}(x)$

Explicación

Aquí usaré alguna notación conveniente. Deje y . Entonces tenemos$T^n:=\mathrm{tanh}^n(t)$$S^n:=\mathrm{sech}^n(t)$

$$\frac{d^nS}{dt^n}=\sum_{i=0}^nF(n,i)T^{n-i}S^{i+1}$$

Como y , podemos deducir que$\frac{dT}{dt}=S^2$$\frac{dS}{dt}=-TS$

$$\begin{equation} \begin{aligned} \frac{d}{dt}(T^aS^b)&=aT^{a-1}(S^2)(S^b)+bS^{b-1}(-TS)(T^a) \\ &=aT^{a-1}S^{b+2}-bT^{a+1}S^b \end{aligned} \end{equation}$$

Sea y , podemos reescribir la relación anterior como$b=i+1$$a=n-i$

$$\begin{equation} \begin{aligned} \frac{d}{dt}(T^{n-i}S^{i+1})&=(n-i)T^{n-i-1}S^{i+3}-(i+1)T^{n-i+1}S^{i+1}\\ &=(n-i)T^{(n+1)-(i+2)}S^{(i+2)+1}-(i+1)T^{(n+1)-i}S^{i+1} \end{aligned} \end{equation}$$

Es decir, contribuye tanto a como a . Como resultado, podemos escribir en términos de y :$F(n,i)$$F(n+1,i+2)$$F(n+1,i)$$F(n,i)$$F(n-1,i-2)$$F(n-1,i)$

$$F(n,i)=(n-i+1)F(n-1,i-2)-(i+1)F(n-1,i)$$

con condición inicial y donde .$F(0,0)=1$$F(0,i)=0$$i\neq 0$

La parte relacionada del código a?-F(--a,b)*++b+F(a,b-=3)*(a-b):+!bse calcula exactamente utilizando la fórmula de recurrencia anterior. Aquí está el desglose:

-F(--a,b)                // -F(n-1, i)                  [ a = n-1, b = i   ]
*++b                     // *(i+1)                      [ a = n-1, b = i+1 ]
+F(a,b-=3)               // +F(n-1, i-2)                [ a = n-1, b = i-2 ]
*(a-b)                   // *((n-1)-(i-2))              [ a = n-1, b = i-2 ]
                         // which is equivalent to *(n-i+1)

Como y , es igual al coeficiente de en la expansión de , que es .$T(0)=0$$S(0)=1$$E_n$$S^{n+1}$$\frac{d^nS}{dt^n}$$F(n,n)$

Para las ramas en las que nunca se puede alcanzar , las recurrencias siempre terminan en 0, por lo que donde o es impar. El último, particularmente, implica que para todos los impares . Para aún S estrictamente mayor que , la recurrencia puede eventualmente permitir que suceda en algún momento, pero antes de que el paso que debe alcanzar un punto donde , y la fórmula de recurrencia muestra que la el valor debe ser 0 en ese punto (ya que el primer término se multiplica por , y el segundo término está más lejos del "triángulo" de$F(0,0)$$F(n,i)=0$$i<0$$i$$E_n=0$$n$$i$$n$$0\leq i\leq n$$i=n+1$$n-i+1=n-(n+1)+1=0$$0\leq i\leq n$) Como resultado, donde . Esto completa la prueba de la validez del algoritmo.$F(n,i)=0$$i > n$

Extensiones

El código se puede modificar para calcular tres secuencias más relacionadas:

Números de tangente (46 bytes)

F=(a,b=a)=>a?F(--a,b)*++b+F(a,b-=3)*(a-b):+!~b

Números Secantes (45 bytes)

F=(a,b=a)=>a?F(--a,b)*++b+F(a,b-=3)*(a-b):+!b

Números en zigzag de Euler (48 bytes)

F=(a,b=a)=>a?F(--a,b)*++b+F(a,b-=3)*(a-b):!b+!~b

Befunge, 115 bytes

Esto solo admite un conjunto codificado de los primeros 16 números de Euler (es decir, E ₀ a E ₁₅ ). Cualquier cosa más allá de eso no encajaría en un valor Befunge de 32 bits de todos modos.

&:2%v
v@.0_2/:
_1.@v:-1
v:-1_1-.@
_5.@v:-1
v:-1_"="-.@
_"}$#"*+.@v:-1
8**-.@v:-1_"'PO"
"0h;"3_"A+y^"9*+**.@.-*8+*:*

Pruébalo en línea!

También hice una implementación completa de la fórmula provista en el desafío, pero es casi el doble del tamaño y todavía está limitada a los primeros 16 valores en TIO, a pesar de que es un intérprete de 64 bits.

<v0p00+1&
v>1:>10p\00:>20p\>010g20g2*-00g1>-:30pv>\:
_$12 0g2%2*-*10g20g110g20g-240pv^1g03:_^*
>-#1:_!>\#<:#*_$40g:1-40p!#v_*\>0\0
@.$_^#`g00:<|!`g01::+1\+*/\<
+4%1-*/+\2+^>$$10g::2>\#<1#*-#2:#\_$*\1

Pruébalo en línea!

El problema con este algoritmo es que los valores intermedios en la serie se desbordan mucho antes que el total. En un intérprete de 32 bits, solo puede manejar los primeros 10 valores (es decir, E ₀ a E ₉ ). Sin embargo, los intérpretes que usan bignums deberían hacerlo mucho mejor: PyFunge y Befungee podrían manejar al menos hasta E ₃₀ .

Python2, (sympy racional), 153 bytes

from sympy import *
t=n+2 
print n,re(Add(*map(lambda (k,j):I**(k-2*j-1)*(k-2*j)**(n+1)*binomial(k,j)/(k*2**k),[(c/t+1,c%t) for c in range(0,t**2-t)])))

Esto es muy subóptimo pero está tratando de usar funciones básicas de sympy y evitar el punto flotante. Gracias @Mego por aclararme la fórmula original mencionada anteriormente. Traté de usar algo como "combinar dos bucles" de @ xnor de Consejos para jugar golf en Python

CJam (34 bytes)

{1a{_W%_,,.*0+(+W%\_,,:~.*.+}@*W=}

Demostración en línea que imprime E (0) a E (19). Este es un bloque anónimo (función).

La implementación toma prestada la recurrencia de Shieru Akasoto y la reescribe en un estilo más amigable para CJam, manipulando filas enteras a la vez.

Disección

{           e# Define a block
  1a        e#   Start with row 0: [1]
  {         e#   Loop...
    _W%     e#     Take a copy and reverse it
    _,,.*   e#     Multiply each element by its position
    0+(+    e#     Pop the 0 from the start and add two 0s to the end
    W%      e#     Reverse again, giving [0 0 (i-1)a_0 (i-2)a_1 ... a_{i-2}]
    \       e#     Go back to the other copy
    _,,:~.* e#     Multiply each element by -1 ... -i
    .+      e#     Add the two arrays
  }         e#
  @*        e#   Bring the input to the top to control the loop count
  W=        e#   Take the last element
}

Wolfram Language (Mathematica) , 47 46 bytes

Sin usar ninguna función especial:

e@0=1;e@n_:=-n!Sum[e[n-k]/k!/(n-k)!,{k,2,n,2}]

Pruébalo en línea!

Axioma, 5 bytes

euler

para OEIS A122045; esto es 57 bytes

g(n:NNI):INT==factorial(n)*coefficient(taylor(sech(x)),n)

código de prueba y resultados

(102) -> [[i,g(i)] for i in [0,1,2,3,6,10,20]]
   (102)
   [[0,1],[1,0],[2,- 1],[3,0],[6,- 61],[10,- 50521],[20,370371188237525]]

(103) -> [[i,euler(i)] for i in [0,1,2,3,6,10,20]]
   (103)
   [[0,1],[1,0],[2,- 1],[3,0],[6,- 61],[10,- 50521],[20,370371188237525]]

APL (NARS), 42 caracteres, 84 bytes

E←{0≥w←⍵:1⋄1-+/{(⍵!w)×(2*w-1+⍵)×E⍵}¨¯1+⍳⍵}

Siga la fórmula que se muestra en "smls", prueba:

  E 0
1
  E 1
0
  E 3
0
  E 6
¯61
  E 10
¯50521

el último caso devuelve un gran racional como resultado porque ingreso 20x (el gran racional 20/1) y no 20 como creo 20.0 flotante de 64 bits ...

  E 20x
370371188237525 

Sería más rápido si uno devuelve 0 pronto, pero sería un poco más largo (50 caracteres):

  E←{0≥w←⍵:1⋄0≠2∣w:0⋄1-+/{(⍵!w)×(2*w-1+⍵)×E⍵}¨¯1+⍳⍵}
  E 30x
¯441543893249023104553682821 

sería más rápido si se usa la definición en cuestión (y sería un poco más de 75 caracteres):

  f←{0≥⍵:1⋄0≠2∣⍵:0⋄0J1×+/{+/⍵{⍺÷⍨(0J2*-⍺)×(⍵!⍺)×(¯1*⍵)×(⍺-2×⍵)*n}¨0..⍵}¨⍳n←1+⍵}
  f 0
1
  f 1
0
  f 3
0
  f 6
¯61J0 
  f 10
¯50521J¯8.890242766E¯9 
  f 10x
¯50521J0 
  f 20x
370371188237525J0 
  f 30x
¯441543893249023104553682821J0 
  f 40x
14851150718114980017877156781405826684425J0 
  f 400x
290652112822334583927483864434329346014178100708615375725038705263971249271772421890927613982905400870578615922728
  107805634246727371465484012302031163270328101126797841939707163099497536820702479746686714267778811263343861
  344990648676537202541289333151841575657340742634189439612727396128265918519683720901279100496205972446809988
  880945212776281115581267184426274778988681851866851641727953206090552901049158520028722201942987653512716826
  524150450130141785716436856286094614730637618087804268356432570627536028770886829651448516666994497921751407
  121752827492669601130599340120509192817404674513170334607613808215971646794552204048850269569900253391449524
  735072587185797183507854751762384660697046224773187826603393443429017928197076520780169871299768968112010396
  81980247383801787585348828625J0 

El resultado anterior es un número complejo que solo tiene la parte real.