Bei einer nicht negativen ganzen Zahl $n ,$ Ausgabe der Eulersche Zahl ( OEIS A122045 ).$n^{\text{th}}$

Alle ungeradzahligen Euler-Zahlen sindDie geraden Euler-Zahlen können mit der folgenden Formel berechnet werden ( bezieht sich auf die imaginäre Einheit): $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} } } \,.$$

Regeln

• $n$ ist eine nicht negative Ganzzahl, sodass die Euler-Zahl innerhalb des für Ihre Sprache darstellbaren Bereichs von Ganzzahlen liegt.$n^{\text{th}}$

Testfälle

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

Mathematica, 6 Bytes

EulerE

-Husten-

J 10 Bytes

(1%6&o.)t:

Probieren Sie es online!

Verwendet die Definition für die Exponentialfunktion sech (x).

Pari / GP , 32 Bytes

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

Probieren Sie es online!

Ahorn, 5 Bytes

euler

Hurra für Builtins?

Maxima , 5 Bytes / 42 Bytes

Maxima hat eingebaut:

euler

Probieren Sie es online!

Die folgende Lösung erfordert nicht das von oben eingebaute und verwendet die Formel, die ursprünglich die Eulernummern definiert hat.

Wir suchen grundsätzlich den n-ten Koeffizienten der Reihenexpansion von 1/cosh(t) = sech(t)(bis zum n!)

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

Probieren Sie es online!

Mathematica, ohne eingebautes, 18 Bytes

Mit der Formel von @ rahnema1 :

2Im@PolyLog[-#,I]&

---

21 Bytes:

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

Python 2.7, 46 Bytes

Mit scipy.

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

Perl 6 , 78 Bytes

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

Verwendet die iterative Formel von hier :

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

Wie es funktioniert

Die allgemeine Struktur ist ein Lambda, in dem eine unendliche Folge durch einen Ausdruck generiert wird, der wiederholt aufgerufen wird und alle vorherigen Werte der Folge in der Variablen @Eabruft. Diese Folge wird dann mit dem Lambda-Argument indiziert:

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

Der für jeden Schritt der Sequenz aufgerufene Ausdruck lautet:

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

Probieren Sie es online!

Zweifacher Imaginärteil der Polylogarithmusfunktion der Ordnung -nmit Argument i [1]

JavaScript (Node.js) , 46-45 Byte

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

Probieren Sie es online!

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

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

Probieren Sie es online!

Überrascht, dass ich noch keine JavaScript-Antwort gefunden habe, also werde ich es versuchen.

$\mathrm{sech}(x)$

Erläuterung

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

Schon seit $\frac{dT}{dt}=S^2$ und $\frac{dS}{dt}=-TS$können wir das ableiten

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

Lassen $b=i+1$ und $a=n-i$Wir können die obige Beziehung umschreiben als

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

Das ist, $F(n,i)$ trägt zu beidem bei $F(n+1,i+2)$ und $F(n+1,i)$. Infolgedessen können wir schreiben$F(n,i)$ bezüglich $F(n-1,i-2)$ und $F(n-1,i)$:

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

mit anfänglichem Zustand $F(0,0)=1$ und $F(0,i)=0$ woher $i\neq 0$.

Der zugehörige Teil des Codes a?-F(--a,b)*++b+F(a,b-=3)*(a-b):+!bberechnet exakt mit der obigen Wiederholungsformel. Hier ist die Aufteilung:

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

Schon seit $T(0)=0$ und $S(0)=1$, $E_n$ gleich dem Koeffizienten von $S^{n+1}$ in der Expansion von $\frac{d^nS}{dt^n}$, welches ist $F(n,n)$.

Für Zweige, die $F(0,0)$ kann nie erreicht werden, die Wiederholungen enden immer bei 0, also $F(n,i)=0$ woher $i<0$ oder $i$ist ungerade. Insbesondere letzteres impliziert dies$E_n=0$ für alle ungeraden $n$s. Für gerade$i$ist streng größer als $n$kann die Wiederholung schließlich ermöglichen $0\leq i\leq n$ irgendwann passieren, aber vor diesem Schritt muss es einen Punkt erreichen, wo $i=n+1$, und die Wiederholungsformel zeigt, dass der Wert an diesem Punkt 0 sein muss (da der erste Term mit multipliziert wird $n-i+1=n-(n+1)+1=0$, und der zweite Term ist weiter vom "Dreieck" von $0\leq i\leq n$). Als Ergebnis,$F(n,i)=0$ woher $i > n$. Damit ist der Nachweis der Gültigkeit des Algorithmus abgeschlossen.

Erweiterungen

Der Code kann geändert werden, um drei weitere verwandte Sequenzen zu berechnen:

Tangentenzahlen (46 Bytes)

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

Sekantenzahlen (45 Bytes)

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

Euler-Zick-Zack-Zahlen (48 Bytes)

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

Befunge, 115 Bytes

Dies unterstützt nur einen fest codierten Satz der ersten 16 Euler-Zahlen (dh E ₀ bis E ₁₅ ). Alles darüber hinaus würde sowieso nicht in einen 32-Bit-Befunge-Wert passen.

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

Probieren Sie es online!

Ich habe die in der Challenge bereitgestellte Formel auch vollständig implementiert, aber sie ist fast doppelt so groß und immer noch auf die ersten 16 Werte in TIO beschränkt, obwohl es sich um einen 64-Bit-Interpreter handelt.

<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

Probieren Sie es online!

Das Problem bei diesem Algorithmus ist, dass die Zwischenwerte in der Reihe viel früher überlaufen als die Summe. Auf einem 32-Bit-Interpreter können nur die ersten 10 Werte (dh E ₀ bis E ₉ ) verarbeitet werden. Dolmetscher, die Bignums verwenden, sollten jedoch viel besser abschneiden - PyFunge und Befungee könnten beide mindestens bis zu E ₃₀ bewältigen .

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

Dies ist sehr suboptimal, aber es wird versucht, grundlegende Sympy-Funktionen zu verwenden und Gleitkommazahlen zu vermeiden. Vielen Dank an @Mego, dass ich mich direkt an die oben aufgeführte Originalformel gewandt habe. Ich habe versucht, so etwas wie @ xnors "Combine Two Loops" von Tips for Golfing in Python zu verwenden

CJam (34 Bytes)

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

Online-Demo, die E (0) bis E (19) druckt. Dies ist ein anonymer Block (Funktion).

Die Implementierung übernimmt die Wiederholung von Shieru Akasoto und schreibt sie in einem CJam-freundlicheren Stil neu, wobei ganze Zeilen gleichzeitig bearbeitet werden.

Präparation

{           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

Ohne irgendwelche speziellen Funktionen zu benutzen:

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

Probieren Sie es online!

Axiom, 5 Bytes

euler

für OEIS A122045; das sind 57 bytes

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

Testcode und Ergebnisse

(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 Zeichen, 84 Byte

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

Befolgen Sie die Formel aus "smls", Test:

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

Der letzte Fall liefert einen großen rationalen Wert als Ergebnis, da ich 20x (den großen rationalen 20/1) eingebe und nicht 20, da ich denke, dass 20.0 64-Bit float ...

  E 20x
370371188237525 

Es wäre schneller, wenn man bald 0 zurückgeben würde, aber etwas länger (50 Zeichen):

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

Es wäre schneller, wenn die Definition in Frage kommt (und wäre etwas länger als 75 Zeichen):

  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 

Das Ergebnis darüber ist eine komplexe Zahl, die nur den Realteil enthält.