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_{2 n} = i \sum_{k = 1}^{2 n + 1} \sum_{j = 0}^{k} (\begin{matrix} k \\ j \end{matrix}) \frac{{(- 1)}^{j} {(k - 2 j)}^{2 n + 1}}{2^{k} i^{k} k} .

$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^{\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

code-golf math number sequence integer Mego
fuente

1

@donbright Te estás perdiendo un conjunto de paréntesis: wolframalpha.com/input/… - con eso, los dos sumandos son ambos -i/2, que producen -icuando se agregan. Multiplique eso por el iexterior de la suma y obtendrá 1.

Mego

18

Mathematica, 6 bytes

EulerE

-tos-

Greg Martin
fuente

99

Cuando vi el título, inmediatamente pensé: "Seguramente Mathematica debe tener una construcción para esto".

HyperNeutrino

12

Eso se aplica a casi todos los títulos ... incluso a la detección de cabras en imágenes

Luis Mendo

GoatImageQse subestima

Greg Martin

1

¿Puede explicar esto? Editar: esto fue una broma.

Magic Octopus Urn

13

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

millas
fuente

¿J hace un análisis simbólico para obtener la función generadora? No se encuentra con errores de coma flotante incluso para n = 30.

orlp

@orlp No estoy seguro de lo que hace internamente, pero J conoce la serie Taylor para un subconjunto de verbos . Cualquier función que pueda definir usando una combinación de esos verbos será válida para t.o t:donde están gf y egf. Una nota curiosa es que tan (x) no es compatible pero sí (x) / cos (x) sí.

millas

12

Pari / GP , 32 bytes

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

Pruébalo en línea!

alephalpha
fuente

11

Arce, 5 bytes

euler

¿Hurra por las builtins?

millas
fuente

44

Me encanta cuando Mathematica es demasiado detallada de un problema de matemáticas ...

theonlygusti

11

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!

falla
fuente

9

Mathematica, sin incorporado, 18 bytes

Usando la fórmula de @ rahnema1 :

2Im@PolyLog[-#,I]&

21 bytes:

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

alephalpha
fuente

5

Python 2.7, 46 bytes

Usando scipy.

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

hashcode55
fuente

5

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} [E_{k} \cdot 2^{(n - 1 - k)} \cdot (\binom{n}{k})]

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

smls
fuente

4

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]

rahnema1
fuente

4

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)

$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^{n} S}{d t^{n}} = \sum_{i = 0}^{n} F (n, i) T^{n - i} S^{i + 1}

$\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{aligned} \frac{d}{d t} (T^{a} S^{b}) & = a T^{a - 1} (S^{2}) (S^{b}) + b S^{b - 1} (- T S) (T^{a}) \\ = a T^{a - 1} S^{b + 2} - b T^{a + 1} S^{b} \end{aligned}

$\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{aligned} \frac{d}{d t} (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}

$\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)

$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

Shieru Asakoto
fuente

3

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
[email protected]_2/:
_1.@v:-1
v:-1_1-.@
_5.@v:-1
v:-1_"="-.@
_"}$#"*+.@v:-1
8**-.@v:-1_"'PO"
"0h;"3_"A+y^"9*+**[email protected]*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 ₃₀ .

James Holderness
fuente

1

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

don brillante
fuente

1

Puede hacer import*(eliminar el espacio intermedio) para guardar un byte. Además, debe tomar el número como una entrada de alguna manera (los fragmentos que suponen que la entrada está en una variable no están permitidos).

FlipTack el

1

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
}

Peter Taylor
fuente

1

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!

romano
fuente

0

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

RosLuP
fuente

0

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:

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.

RosLuP
fuente

Salida de los números de Euler

Reglas

Casos de prueba

Respuestas:

Mathematica, 6 bytes

J , 10 bytes

Pari / GP , 32 bytes

Arce, 5 bytes

Máximo , 5 bytes / 42 bytes

Mathematica, sin incorporado, 18 bytes

Python 2.7, 46 bytes

Perl 6 , 78 bytes

Cómo funciona

Máxima, 29 bytes

JavaScript (Node.js) , 46 45 bytes

JavaScript (Node.js) , 70 46 bytes

Explicación

Extensiones

Befunge, 115 bytes

Python2, (sympy racional), 153 bytes

CJam (34 bytes)

Disección

Wolfram Language (Mathematica) , 47 46 bytes

Axioma, 5 bytes

APL (NARS), 42 caracteres, 84 bytes