27
\$\begingroup\$

Given a non-negative integer n, output the nth Euler number (OEIS A122045).

All odd-indexed Euler numbers are 0. The even-indexed Euler numbers can be computed with the following formula (i refers to the imaginary unit):

Euler numbers

Rules

  • n will be a non-negative integer such that the nth Euler number is within the representable range of integers for your language.

Test Cases

0 -> 1
1 -> 0
2 -> -1
3 -> 0
6 -> -61
10 -> -50521
20 -> 370371188237525
\$\endgroup\$
  • 1
    \$\begingroup\$ @donbright You're missing a set of parentheses: wolframalpha.com/input/… - with that, the two summands are both -i/2, which yield -i when added. Multiply that by the i outside of the summation, and you get 1. \$\endgroup\$ – Mego Jan 22 '17 at 21:01

14 Answers 14

17
\$\begingroup\$

Mathematica, 6 bytes

EulerE

-cough-

\$\endgroup\$
  • 8
    \$\begingroup\$ When I saw the title, I immediately thought "Surely Mathematica must have a builtin for this". \$\endgroup\$ – HyperNeutrino Jan 21 '17 at 2:48
  • 10
    \$\begingroup\$ That applies to pretty much every title... even detecting goats in images \$\endgroup\$ – Luis Mendo Jan 21 '17 at 16:19
  • \$\begingroup\$ GoatImageQ is underappreciated \$\endgroup\$ – Greg Martin Jan 21 '17 at 19:34
  • \$\begingroup\$ Can you explain this? Edit: this was a joke. \$\endgroup\$ – Magic Octopus Urn Jan 24 '17 at 21:30
12
\$\begingroup\$

J, 10 bytes

(1%6&o.)t:

Try it online!

Uses the definition for the exponential generating function sech(x).

\$\endgroup\$
  • \$\begingroup\$ Does J do symbolic analysis to get the generating function? It doesn't run into floating point errors even for n=30. \$\endgroup\$ – orlp Jan 21 '17 at 0:49
  • \$\begingroup\$ @orlp I'm not sure what it does internally, but J knows the Taylor series for a subset of verbs. Any function you can define using a combination of those verbs will be valid for t. or t: where are g.f. and e.g.f. A curious note is that tan(x) is not supported but sin(x)/cos(x) is. \$\endgroup\$ – miles Jan 21 '17 at 0:57
12
\$\begingroup\$

Pari/GP, 32 bytes

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

Try it online!

\$\endgroup\$
10
\$\begingroup\$

Maple, 5 bytes

euler

Hurray for builtins?

\$\endgroup\$
  • 4
    \$\begingroup\$ Love it when mathematica is too verbose for a maths problem... \$\endgroup\$ – theonlygusti Jan 21 '17 at 7:48
10
\$\begingroup\$

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!

\$\endgroup\$
8
\$\begingroup\$

Mathematica, without built-in, 18 bytes

Using @rahnema1's formula:

2Im@PolyLog[-#,I]&

21 bytes:

Sech@x~D~{x,#}/.x->0&
\$\endgroup\$
5
\$\begingroup\$

Python 2.7, 46 bytes

Using scipy.

from scipy.special import*
lambda n:euler(n)[n]
\$\endgroup\$
4
\$\begingroup\$

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]

\$\endgroup\$
4
\$\begingroup\$

Perl 6, 78 bytes

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

Uses the iterative formula from here:

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

How it works

The general structure is a lambda in which an infinite sequence is generated, by an expression that is called repeatedly and gets all previous values of the sequence in the variable @E, and then that sequence is indexed with the lambda argument:

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

The expression called for each step of the sequence, is:

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

JavaScript (Node.js), 46 45 bytes

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

Try it online!

Valid for all \$E_n\$ values (as required), but not for \$F(n, i)\$ generally (outputs \$-F(n,i)\$ for odd \$n\$s.) The code is modified to reduce one byte by changing the output to \$F'(n,i)=(-1)^nF(n,i)\$ where \$F\$ is defined as below. Specifically, the recurrence formula for \$F'\$ is $$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

Try it online!

Surprised to find no JavaScript answer yet, so I'll have a try.

The code consists of only basic mathematics, but the mathematics behind the code requires calculus. The recursion formula is derived from the expansion of the derivatives of \$\mathrm{sech}(x)\$ of different orders.

Explanation

Here I'll use some convenient notation. Let \$T^n:=\mathrm{tanh}^n(t)\$ and \$S^n:=\mathrm{sech}^n(t)\$. Then we have

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

Since \$\frac{dT}{dt}=S^2\$ and \$\frac{dS}{dt}=-TS\$, we can deduce that

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

Let \$b=i+1\$ and \$a=n-i\$, we can rewrite the relation above as

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

That is, \$F(n,i)\$ contributes to both \$F(n+1,i+2)\$ and \$F(n+1,i)\$. As a result, we can write \$F(n,i)\$ in terms of \$F(n-1,i-2)\$ and \$F(n-1,i)\$:

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

with initial condition \$F(0,0)=1\$ and \$F(0,i)=0\$ where \$i\neq 0\$.

The related part of the code a?-F(--a,b)*++b+F(a,b-=3)*(a-b):+!b is exactly calculating using the above recurrence formula. Here's the breakdown:

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

Since \$T(0)=0\$ and \$S(0)=1\$, \$E_n\$ equals the coefficient of \$S^{n+1}\$ in the expansion of \$\frac{d^nS}{dt^n}\$, which is \$F(n,n)\$.

For branches that \$F(0,0)\$ can never be reached, the recurrences always end at 0, so \$F(n,i)=0\$ where \$i<0\$ or \$i\$ is odd. The latter one, particularly, implies that \$E_n=0\$ for all odd \$n\$s. For even \$i\$s strictly larger than \$n\$, the recurrence may eventually allow \$0\leq i\leq n\$ to happen at some point, but before that step it must reach a point where \$i=n+1\$, and the recurrence formula shows that the value must be 0 at that point (since the first term is multiplied by \$n-i+1=n-(n+1)+1=0\$, and the second term is farther from the "triangle" of \$0\leq i\leq n\$). As a result, \$F(n,i)=0\$ where \$i > n\$. This completes the proof of the validity of the algorithm.

\$\endgroup\$
2
\$\begingroup\$

Befunge, 115 bytes

This just supports a hardcoded set of the first 16 Euler numbers (i.e. E0 to E15). 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. E0 to E9). Interpreters that use bignums should do much better though - PyFunge and Befungee could both handle at least up to E30.

\$\endgroup\$
1
\$\begingroup\$

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

\$\endgroup\$
  • 1
    \$\begingroup\$ You can do import* (remove the space in between) to save a byte. Also, you need to take the number as an input somehow (snippets which assume the input to be in a variable are not allowed). \$\endgroup\$ – FlipTack Jan 25 '17 at 21:20
1
\$\begingroup\$

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
}
\$\endgroup\$
0
\$\begingroup\$

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]]
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.