Dado um número inteiro não negativo $n ,$ saída do $n^{\text{th}}$ número de Euler ( OEIS A122045 ).

Todos os números de Euler com índice ímpar sãoOs números de Euler indexados pares podem ser calculados com a seguinte fórmula ( refere-se à unidade imaginária): $0 .$$i \equiv \sqrt{-1}$

$$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} } } \,.$$

Regras

• $n$ será um número inteiro não negativo, de modo que o número de Euler esteja dentro do intervalo representável de números inteiros para o seu idioma.$n^{\text{th}}$

Casos de teste

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

Mathematica, 6 bytes

EulerE

-tosse-

J , 10 bytes

(1%6&o.)t:

Experimente online!

Usa a definição para a função geradora exponencial sech (x).

Pari / GP , 32 bytes

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

Experimente online!

Maple, 5 bytes

euler

Hurray for builtins?

Maxima, 5 bytes / 42 bytes

Maxima has a built in:

euler

Try it online!

The following solution does not require the built in from above, and uses the formula that originally defined the euler numbers.

We are basically looking for the n-th coefficient of the series expansion of 1/cosh(t) = sech(t) (up to the n!)

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

Try it online!

Mathematica, without built-in, 18 bytes

Using @rahnema1's formula:

2Im@PolyLog[-#,I]&

---

21 bytes:

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

Python 2.7, 46 bytes

Using scipy.

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

Perl 6 , 78 bytes

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

Usa a fórmula iterativa daqui :

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

Como funciona

A estrutura geral é uma lambda na qual uma sequência infinita é gerada, por uma expressão que é chamada repetidamente e obtém todos os valores anteriores da sequência na variável @Ee, em seguida, essa sequência é indexada com o argumento lambda:

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

A expressão chamada para cada etapa da sequência é:

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

Maxima, 29 bytes

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

Try It Online!

Two times imaginary part of polylogarithm function of order -n with argument i [1]

JavaScript (Node.js) , 46 45 bytes

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

Experimente online!

Válido para todos $E_n$ valores (conforme necessário), mas não para $F(n, i)$ geralmente (saídas $-F(n,i)$ para estranho $n$s.) O código é modificado para reduzir um byte, alterando a saída para $F'(n,i)=(-1)^nF(n,i)$ Onde $F$é definido como abaixo. Especificamente, a fórmula de recorrência para$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

Experimente online!

Surpreso por não encontrar resposta em JavaScript ainda, então tentarei.

O código consiste apenas em matemática básica, mas a matemática por trás do código requer cálculo. A fórmula de recursão deriva da expansão dos derivativos de$\mathrm{sech}(x)$ de ordens diferentes.

Explicação

Aqui vou usar alguma notação conveniente. Deixei$T^n:=\mathrm{tanh}^n(t)$ e $S^n:=\mathrm{sech}^n(t)$. Então nós temos

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

Desde a $\frac{dT}{dt}=S^2$ e $\frac{dS}{dt}=-TS$, podemos deduzir que

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

Deixei $b=i+1$ e $a=n-i$, podemos reescrever a relação acima como

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

Isso é, $F(n,i)$ contribui para ambos $F(n+1,i+2)$ e $F(n+1,i)$. Como resultado, podemos escrever$F(n,i)$ em termos de $F(n-1,i-2)$ e $F(n-1,i)$:

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

com condição inicial $F(0,0)=1$ e $F(0,i)=0$ Onde $i\neq 0$.

A parte relacionada do código a?-F(--a,b)*++b+F(a,b-=3)*(a-b):+!bé exatamente calculada usando a fórmula de recorrência acima. Aqui está o detalhamento:

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

Desde a $T(0)=0$ e $S(0)=1$, $E_n$ é igual ao coeficiente de $S^{n+1}$ na expansão de $\frac{d^nS}{dt^n}$, qual é $F(n,n)$.

Para galhos que $F(0,0)$ nunca pode ser alcançado, as recorrências sempre terminam em 0, então $F(n,i)=0$ Onde $i<0$ ou $i$é estranho. Este último, particularmente, implica que$E_n=0$ para todos ímpares $n$s. Por até$i$s estritamente maior que $n$, a recorrência pode eventualmente permitir $0\leq i\leq n$ acontecer em algum momento, mas antes desse passo ele deve chegar a um ponto em que $i=n+1$, e a fórmula de recorrência mostra que o valor deve ser 0 nesse ponto (já que o primeiro termo é multiplicado por $n-i+1=n-(n+1)+1=0$e o segundo termo está mais distante do "triângulo" de $0\leq i\leq n$) Como um resultado,$F(n,i)=0$ Onde $i > n$. Isso completa a prova da validade do algoritmo.

Extensões

O código pode ser modificado para calcular mais três seqüências relacionadas:

Números tangentes (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 em ziguezague de Euler (48 bytes)

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

Befunge, 115 bytes

This just supports a hardcoded set of the first 16 Euler numbers (i.e. E₀ to E₁₅). Anything beyond that wouldn't fit in a 32-bit Befunge value anyway.

&: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+*:*

Try it online!

I've also done a full implementation of the formula provided in the challenge, but it's nearly twice the size, and it's still limited to the first 16 values on TIO, even though that's a 64-bit interpreter.

<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

Try it online!

The problem with this algorithm is that the intermediate values in the series overflow much sooner than the total does. On a 32-bit interpreter it can only handle the first 10 values (i.e. E₀ to E₉). Interpreters that use bignums should do much better though - PyFunge and Befungee could both handle at least up to E₃₀.

Python2, (sympy rational), 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)])))

This is very suboptimal but it's trying to use basic sympy functions and avoid floating point. Thanks @Mego for setting me straight on the original formula listed above. I tried to use something like @xnor's "combine two loops" from Tips for golfing in Python

CJam (34 bytes)

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

Online demo which prints E(0) to E(19). This is an anonymous block (function).

The implementation borrows Shieru Akasoto's recurrence and rewrites it in a more CJam friendly style, manipulating entire rows at a time.

Dissection

{           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

Without using any special functions:

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

Try it online!

Axiom, 5 bytes

euler

for OEIS A122045; this is 57 bytes

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

test code and results

(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 a fórmula mostrada em "smls", teste:

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

o último caso retorna um grande racional como resultado, porque eu insiro 20x (o grande racional 20/1) e não 20, como penso 20,0 flutuam 64 bits ...

  E 20x
370371188237525 

Seria mais rápido se um retornasse 0 em breve, mas seria um pouco mais longo (50 caracteres):

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

seria mais rápido se fosse usada a definição em questão (e seriam 75 caracteres um pouco mais longos):

  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 

O resultado acima é um número complexo que possui apenas a parte real.