음이 아닌 정수 주어진 출력 오일러 번호 ( OEIS A122045 ). $n ,$ $n^{\text{th}}$

홀수 색인의 오일러 수는짝수 색인 오일러 수는 다음 공식으로 계산할 수 있습니다 ( 은 허수를 나타냄). $0 .$ $i \equiv \sqrt{-1}$

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

규칙

$n$ 은 음수가 아닌 정수이므로 오일러 숫자는 사용자 언어의 표현 가능한 정수 범위 내에 있습니다. $n^{\text{th}}$

테스트 사례

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

— 메고
소스

1

@donbright 당신은 괄호의 집합이 누락 : wolframalpha.com/input/...을 - 그와 함께 두 피가수가 모두 -i/2있는 수율 -i추가 할 때입니다. 그것을 i합의 바깥에 곱 하면 얻을 수 1있습니다.

— Mego

18

Mathematica, 6 바이트

EulerE

-기침-

— 그렉 마틴
소스

9

제목을 보자 마자 "확실히 Mathematica에 내장해야합니다"라고 생각했습니다.

— HyperNeutrino

12

그것은 거의 모든 타이틀에 적용됩니다 ... 심지어 이미지에서 염소를 감지하기

— Luis Mendo

GoatImageQ감사합니다

— Greg Martin

1

이것을 설명 할 수 있습니까? 편집 : 이것은 농담이었습니다.

— Magic Octopus Urn

13

J , 10 바이트

(1%6&o.)t:

온라인으로 사용해보십시오!

지수 생성 함수 sech (x)에 대한 정의를 사용합니다.

— 마일
소스

J는 생성 함수를 얻기 위해 기호 분석을 수행합니까? n = 30의 경우에도 부동 소수점 오류가 발생하지 않습니다.

— orlp

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

— miles

12

Pari/GP, 32 bytes

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

Try it online!

— alephalpha
소스

11

Maple, 5 bytes

euler

Hurray for builtins?

— miles
소스

4

Love it when mathematica is too verbose for a maths problem...

— theonlygusti

11

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!

— flawr
소스

9

Mathematica, without built-in, 18 bytes

Using @rahnema1's formula:

2Im@PolyLog[-#,I]&

21 bytes:

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

— alephalpha
소스

5

Python 2.7, 46 bytes

Using scipy.

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

— hashcode55
소스

5

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

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
}

— smls
소스

4

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]

— rahnema1
소스

4

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)

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

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

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

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

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

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)

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

Extensions

The code can be modified to calculate three more related sequences:

Tangent Numbers (46 bytes)

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

Secant Numbers (45 bytes)

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

Euler Zigzag Numbers (48 bytes)

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

— Shieru Asakoto
소스

3

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

— James Holderness
소스

1

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

— don bright
소스

1

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

— FlipTack

1

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
}

— Peter Taylor
소스

1

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!

— Roman
소스

0

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

— RosLuP
소스

0

APL(NARS), 42 chars, 84 bytes

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

Follow the formula showed from "smls", test:

the last case return one big rational as result because i enter 20x (the big rational 20/1) and not 20 as i think 20.0 float 64 bit...

  E 20x
370371188237525

It would be more fast if one return 0 soon but would be a little more long (50 chars):

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

it would be more fast if it is used the definition on question (and would be a little more long 75 chars):

  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

The result above it is one complex number that has only the real part.

— RosLuP
소스

오일러 수 출력

규칙

테스트 사례

Mathematica, 6 바이트

J , 10 바이트

Pari/GP, 32 bytes

Maple, 5 bytes

Maxima, 5 bytes / 42 bytes

Mathematica, without built-in, 18 bytes

Python 2.7, 46 bytes

Perl 6, 78 bytes

How it works

Maxima, 29 bytes

JavaScript (Node.js), 46 45 bytes

JavaScript (Node.js), 70 46 bytes

Explanation

Extensions

Befunge, 115 bytes

Python2, (sympy rational), 153 bytes

CJam (34 bytes)

Dissection

Wolfram Language (Mathematica), 47 46 bytes

Axiom, 5 bytes

APL(NARS), 42 chars, 84 bytes