Diberikan bilangan bulat non-negatif output nomor Euler ( Oei A122045 ).$n ,$$n^{\text{th}}$

Semua angka Euler yang diindeks ganjil adalahAngka Euler yang diindeks genap dapat dihitung dengan rumus berikut ( merujuk ke unit imajiner): $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} } } \,.$$

Aturan

• $n$ akan menjadi bilangan bulat non-negatif sehingga nomor Euler berada dalam kisaran integer yang dapat diwakili untuk bahasa Anda.$n^{\text{th}}$

Uji Kasus

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

Mathematica, 6 byte

EulerE

-batuk-

J , 10 byte

(1%6&o.)t:

Cobalah online!

Menggunakan definisi untuk fungsi penghasil eksponensial, sech (x).

Pari / GP , 32 byte

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

Cobalah online!

Maple, 5 byte

euler

Hore untuk builtin?

Maksima , 5 byte / 42 byte

Maxima memiliki bawaan:

euler

Cobalah online!

Solusi berikut ini tidak memerlukan bawaan dari atas, dan menggunakan rumus yang awalnya mendefinisikan angka euler.

Kami pada dasarnya mencari koefisien ke-n dari ekspansi seri 1/cosh(t) = sech(t)(hingga n!)

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

Cobalah online!

Mathematica, tanpa built-in, 18 byte

Menggunakan rumus @ rahnema1 :

2Im@PolyLog[-#,I]&

---

21 byte:

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

Python 2.7, 46 byte

Menggunakan scipy.

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

Perl 6 , 78 byte

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

Gunakan rumus berulang dari sini :

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

Bagaimana itu bekerja

Struktur umum adalah lambda di mana urutan yang tak terbatas dihasilkan, oleh ekspresi yang disebut berulang kali dan mendapatkan semua nilai sebelumnya dari urutan dalam variabel @E, dan kemudian urutan itu diindeks dengan argumen lambda:

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

Ekspresi yang dipanggil untuk setiap langkah dari urutan, adalah:

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

Maxima, 29 byte

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

Cobalah secara Online!

Dua kali bagian imajiner fungsi polilogaritma keteraturan -ndengan argumen i [1]

JavaScript (Node.js) , 46 45 byte

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

Cobalah online!

Berlaku untuk semua nilai (sesuai kebutuhan), tetapi tidak untuk secara umum (output untuk odd s.) Kode dimodifikasi untuk mengurangi satu byte dengan mengubah output ke di mana didefinisikan sebagai berikut. Secara khusus, rumus perulangan untuk adalah$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 byte

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

Cobalah online!

Terkejut belum menemukan jawaban JavaScript, jadi saya akan mencoba.

Kode hanya terdiri dari matematika dasar, tetapi matematika di belakang kode membutuhkan kalkulus. Rumus rekursi berasal dari perluasan turunan dari dari pesanan yang berbeda.$\mathrm{sech}(x)$

Penjelasan

Di sini saya akan menggunakan beberapa notasi yang mudah. Misalkan dan . Lalu kita punya$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}$$

Karena dan , kita dapat menyimpulkan bahwa$\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}$$

Misalkan dan , kita dapat menulis ulang relasi di atas sebagai$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}$$

Yaitu, berkontribusi pada dan . Sebagai hasilnya, kita dapat menulis dalam bentuk dan :$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)$$

dengan kondisi awal dan mana .$F(0,0)=1$$F(0,i)=0$$i\neq 0$

Bagian terkait dari kode a?-F(--a,b)*++b+F(a,b-=3)*(a-b):+!bpersis menghitung menggunakan rumus perulangan di atas. Berikut rinciannya:

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

Karena dan , sama dengan koefisien dalam perluasan , yaitu .$T(0)=0$$S(0)=1$$E_n$$S^{n+1}$$\frac{d^nS}{dt^n}$$F(n,n)$

Untuk cabang yang tidak pernah dapat dijangkau, perulangan selalu berakhir pada 0, jadi mana atau adalah ganjil. Yang terakhir, khususnya, menyiratkan bahwa untuk semua odd s. Untuk bahkan benar-benar lebih besar dari , perulangan pada akhirnya dapat memungkinkan terjadi pada beberapa titik, tetapi sebelum langkah itu harus mencapai titik di mana , dan rumus perulangan menunjukkan bahwa nilai harus 0 pada titik itu (karena suku pertama dikalikan dengan , dan suku kedua lebih jauh dari "segitiga" dari$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$). Akibatnya, mana . Ini melengkapi bukti validitas algoritma.$F(n,i)=0$$i > n$

Ekstensi

Kode dapat dimodifikasi untuk menghitung tiga urutan terkait:

Nomor Tangen (46 byte)

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

Nomor Seri (45 byte)

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

Nomor Euler Zigzag (48 byte)

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

Befunge, 115 byte

Ini hanya mendukung satu set kode 16 angka Euler pertama (yaitu E ₀ hingga E ₁₅ ). Apa pun yang melampaui itu tidak akan cocok dengan nilai Befunge 32-bit.

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

Cobalah online!

Saya juga telah melakukan implementasi penuh dari formula yang disediakan dalam tantangan, tetapi ukurannya hampir dua kali lipat, dan itu masih terbatas pada 16 nilai pertama pada TIO, meskipun itu adalah interpreter 64-bit.

<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

Cobalah online!

Masalah dengan algoritma ini adalah bahwa nilai-nilai perantara dalam seri overflow jauh lebih cepat daripada totalnya. Pada interpreter 32-bit, ia hanya dapat menangani 10 nilai pertama (yaitu E ₀ hingga E ₉ ). Juru bahasa yang menggunakan bignum harus melakukan jauh lebih baik - PyFunge dan Befungee keduanya bisa menangani setidaknya hingga E ₃₀ .

Python2, (sympy rasional), 153 byte

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

Ini sangat suboptimal tetapi sedang mencoba untuk menggunakan fungsi sympy dasar dan menghindari floating point. Terima kasih @Mego karena telah meluruskan saya pada formula asli yang tercantum di atas. Saya mencoba menggunakan sesuatu seperti @ xnor "kombinasikan dua loop" dari Tips untuk bermain golf dengan Python

CJam (34 byte)

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

Demo online yang mencetak E (0) hingga E (19). Ini adalah blok anonim (fungsi).

Implementasi meminjam kekambuhan Shieru Akasoto dan menulis ulang dengan gaya yang lebih ramah CJam, memanipulasi seluruh baris sekaligus.

Pembedahan

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

Bahasa Wolfram (Mathematica) , 47 46 byte

Tanpa menggunakan fungsi khusus:

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

Cobalah online!

Aksioma, 5 byte

euler

untuk OEIS A122045; ini adalah 57 byte

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

kode uji dan hasil

(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 karakter, 84 byte

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

Ikuti formula yang ditunjukkan dari "smls", tes:

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

kasus terakhir mengembalikan satu rasional besar sebagai hasilnya karena saya memasukkan 20x (20/1 rasional besar) dan bukan 20 karena saya pikir 20.0 float 64 bit ...

  E 20x
370371188237525 

Akan lebih cepat jika seseorang mengembalikan 0 segera tetapi akan menjadi sedikit lebih panjang (50 karakter):

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

akan lebih cepat jika digunakan definisi pada pertanyaan (dan akan menjadi 75 karakter sedikit lebih panjang):

  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 

Hasil di atasnya adalah satu bilangan kompleks yang hanya memiliki bagian nyata.