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_{2 n} = ich \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} {ich}^{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} } } \,.$

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

— Mego
quelle

1

@donbright Es fehlen ein paar Klammern: wolframalpha.com/input/… - damit sind beide Summanden -i/2, die sich ergeben, -iwenn sie hinzugefügt werden. Multiplizieren Sie das mit dem iÄußeren der Summe, und Sie erhalten 1.

— Mego

18

Mathematica, 6 Bytes

EulerE

-Husten-

— Greg Martin
quelle

9

Als ich den Titel sah, dachte ich sofort "Sicherlich muss Mathematica einen eingebauten dafür haben".

— HyperNeutrino

12

Das gilt für so ziemlich jeden Titel ... sogar für das Erkennen von Ziegen in Bildern

— Luis Mendo

GoatImageQwird unterschätzt

— Greg Martin

1

Kannst du das erklären? Edit: das war ein Witz.

— Magic Octopus Urn

13

J 10 Bytes

(1%6&o.)t:

Probieren Sie es online!

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

— Meilen
quelle

Führt J eine symbolische Analyse durch, um die Erzeugungsfunktion zu erhalten? Es treten auch für n = 30 keine Gleitkommafehler auf.

— Orlp

@orlp Ich bin mir nicht sicher, was es intern macht, aber J kennt die Taylor-Reihe für eine Untergruppe von Verben . Jede Funktion, die Sie mit einer Kombination dieser Verben definieren können, ist gültig für t.oder t:wo gf und egf sind. Eine merkwürdige Anmerkung ist, dass tan (x) nicht unterstützt wird, sin (x) / cos (x) jedoch.

— Meilen

12

Pari / GP , 32 Bytes

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

Probieren Sie es online!

— Alephalpha
quelle

11

Ahorn, 5 Bytes

euler

Hurra für Builtins?

— Meilen
quelle

4

— Ich

11

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!

— fehlerhaft
quelle

9

Mathematica, ohne eingebautes, 18 Bytes

Mit der Formel von @ rahnema1 :

2Im@PolyLog[-#,I]&

21 Bytes:

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

— Alephalpha
quelle

5

Python 2.7, 46 Bytes

Mit scipy.

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

— hashcode55
quelle

5

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

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
}

— smls
quelle

4

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]

— rahnema1
quelle

4

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, ich) = (ich - n - 1) F^{'} (n - 1, ich - 2) + (ich + 1) F^{'} (n - 1, ich)

$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^{n} S}{d t^{n}} = \sum_{ich = 0}^{n} F (n, ich) T^{n - ich} S^{ich + 1}

$\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{aligned} \frac{d}{d t} (T^{ein} S^{b}) & = ein T^{ein - 1} (S^{2}) (S^{b}) + b S^{b - 1} (- T S) (T^{ein}) \\ = ein T^{ein - 1} S^{b + 2} - b T^{ein + 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}$

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

\begin{aligned} \frac{d}{d t} (T^{n - ich} S^{ich + 1}) & = (n - ich) T^{n - ich - 1} S^{ich + 3} - (ich + 1) T^{n - ich + 1} S^{ich + 1} \\ = (n - ich) T^{(n + 1) - (ich + 2)} S^{(ich + 2) + 1} - (ich + 1) T^{(n + 1) - ich} S^{ich + 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}$

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, ich) = (n - ich + 1) F (n - 1, ich - 2) - (ich + 1) F (n - 1, ich)

$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

— Shieru Asakoto
quelle

3

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

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 .

— James Holderness
quelle

1

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

— Don Bright
quelle

1

Sie können tun import*(das Leerzeichen dazwischen entfernen), um ein Byte zu speichern. Außerdem müssen Sie die Zahl irgendwie als Eingabe verwenden (Ausschnitte, die davon ausgehen, dass sich die Eingabe in einer Variablen befindet, sind nicht zulässig).

— FlipTack

1

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
}

— Peter Taylor
quelle

1

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!

— römisch
quelle

0

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

— RosLuP
quelle

0

APL (NARS), 42 Zeichen, 84 Byte

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

Befolgen Sie die Formel aus "smls", Test:

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.

— RosLuP
quelle

Geben Sie die Eulernummern aus

Regeln

Testfälle

Mathematica, 6 Bytes

J 10 Bytes

Pari / GP , 32 Bytes

Ahorn, 5 Bytes

Maxima , 5 Bytes / 42 Bytes

Mathematica, ohne eingebautes, 18 Bytes

Python 2.7, 46 Bytes

Perl 6 , 78 Bytes

Wie es funktioniert

Maxima, 29 Bytes

JavaScript (Node.js) , 46-45 Byte

JavaScript (Node.js) , 70 46 Bytes

Erläuterung

Erweiterungen

Befunge, 115 Bytes

Python2 (sympy rational), 153 Byte

CJam (34 Bytes)

Präparation

Wolfram Language (Mathematica) , 47 46 Bytes

Axiom, 5 Bytes

APL (NARS), 42 Zeichen, 84 Byte