Étant donné un entier non négatif sortez le numéro Euler ( OEIS A122045 ). $n ,$ $n^{\text{th}}$

Tous les nombres d'Euler à index impair sontLes nombres d'Euler à index pair peuvent être calculés avec la formule suivante ( fait référence à l'unité imaginaire): $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} } } \,.$

Règles

$n$ sera un entier non négatif tel que le nombre d'Euler se situe dans la plage représentable des entiers pour votre langue. $n^{\text{th}}$

Cas de test

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

— Mego
source

1

@donbright Vous manquez un ensemble de parenthèses: wolframalpha.com/input/… - avec cela, les deux sommets sont les deux -i/2, qui cèdent -ilorsqu'ils sont ajoutés. Multipliez cela par l' iextérieur de la sommation, et vous obtenez 1.

— Mego

18

Mathematica, 6 octets

EulerE

-la toux-

— Greg Martin
source

9

Quand j'ai vu le titre, j'ai immédiatement pensé "sûrement Mathematica doit avoir une fonction intégrée pour cela".

— HyperNeutrino

12

Cela s'applique à presque tous les titres ... même en détectant des chèvres dans les images

— Luis Mendo

GoatImageQest sous-estimé

— Greg Martin

1

Pouvez-vous expliquer cela? Edit: c'était une blague.

— Urne de poulpe magique du

13

J , 10 octets

(1%6&o.)t:

Essayez-le en ligne!

Utilise la définition de la fonction de génération exponentielle sech (x).

— miles
source

J fait-il une analyse symbolique pour obtenir la fonction génératrice? Il ne rencontre pas d'erreurs en virgule flottante même pour n = 30.

— orlp

@orlp Je ne sais pas ce qu'il fait en interne, mais J connaît la série Taylor pour un sous - ensemble de verbes . Toute fonction que vous pouvez définir en utilisant une combinaison de ces verbes sera valide pour t.ou t:où sont gf et egf Une note curieuse est que tan (x) n'est pas pris en charge mais sin (x) / cos (x) l'est.

— miles

12

Pari / GP , 32 octets

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

Essayez-le en ligne!

— alephalpha
source

11

Érable, 5 octets

euler

Vive les builtins?

— miles
source

4

J'adore quand mathématique est trop verbeuse pour un problème de maths ...

— theonlygusti

11

Maxima , 5 octets / 42 octets

Maxima a intégré:

euler

Essayez-le en ligne!

La solution suivante ne nécessite pas l'intégration depuis le dessus et utilise la formule qui définissait à l'origine les nombres euler.

Nous recherchons essentiellement le n-ième coefficient de l'expansion en série de 1/cosh(t) = sech(t)(jusqu'au n!)

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

Essayez-le en ligne!

— flawr
source

9

Mathematica, sans intégré, 18 octets

En utilisant la formule de @ rahnema1 :

2Im@PolyLog[-#,I]&

21 octets:

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

— alephalpha
source

5

Python 2.7, 46 octets

En utilisant scipy.

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

— hashcode55
source

5

Perl 6 , 78 octets

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

Utilise la formule itérative d'ici :

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

Comment ça marche

La structure générale est un lambda dans lequel une séquence infinie est générée, par une expression qui est appelée à plusieurs reprises et obtient toutes les valeurs précédentes de la séquence dans la variable @E, puis cette séquence est indexée avec l'argument lambda:

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

L'expression appelée pour chaque étape de la séquence est:

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

— smls
source

4

Maxima, 29 octets

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

Essayez-le en ligne!

Partie imaginaire deux fois de la fonction polylogarithme d'ordre -navec argument i [1]

— rahnema1
source

4

JavaScript (Node.js) , 46 45 octets

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

Essayez-le en ligne!

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

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

JavaScript (Node.js) , 70 46 octets

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

Essayez-le en ligne!

Surpris de ne pas trouver de réponse JavaScript pour le moment, je vais donc essayer.

$\mathrm{sech}(x)$ d'ordres différents.

Explication

$T^n:=\mathrm{tanh}^n(t)$ $S^n:=\mathrm{sech}^n(t)$

\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
source

3

Befunge, 115 octets

Cela ne prend en charge qu'un ensemble codé en dur des 16 premiers nombres d'Euler (c'est-à-dire E ₀ à E ₁₅ ). Quoi que ce soit au-delà de cela ne rentrerait pas dans une valeur Befunge 32 bits de toute façon.

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

Essayez-le en ligne!

J'ai également fait une implémentation complète de la formule fournie dans le défi, mais c'est presque le double de la taille, et elle est toujours limitée aux 16 premières valeurs sur TIO, même s'il s'agit d'un interpréteur 64 bits.

<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

Essayez-le en ligne!

Le problème avec cet algorithme est que les valeurs intermédiaires de la série débordent beaucoup plus tôt que le total. Sur un interpréteur 32 bits, il ne peut gérer que les 10 premières valeurs (c'est-à-dire E ₀ à E ₉ ). Les interprètes qui utilisent des bignums devraient cependant faire beaucoup mieux - PyFunge et Befungee pourraient tous deux gérer au moins jusqu'à E ₃₀ .

— James Holderness
source

1

Python2, (sympy rational), 153 octets

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

Ceci est très sous-optimal mais essaie d'utiliser des fonctions sympy de base et d'éviter la virgule flottante. Merci @Mego de m'avoir mis directement sur la formule originale listée ci-dessus. J'ai essayé d'utiliser quelque chose comme @ xnor "combine deux boucles" de Tips for golfing in Python

— Don Bright
source

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
source

1

Wolfram Language (Mathematica) , 47 46 octets

Sans utiliser de fonctions spéciales:

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

Essayez-le en ligne!

— Roman
source

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
source

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
source

Sortie des nombres d'Euler

Règles

Cas de test

Mathematica, 6 octets

J , 10 octets

Pari / GP , 32 octets

Érable, 5 octets

Maxima , 5 octets / 42 octets

Mathematica, sans intégré, 18 octets

Python 2.7, 46 octets

Perl 6 , 78 octets

Comment ça marche

Maxima, 29 octets

JavaScript (Node.js) , 46 45 octets

JavaScript (Node.js) , 70 46 octets

Explication

Extensions

Befunge, 115 octets

Python2, (sympy rational), 153 octets

CJam (34 bytes)

Dissection

Wolfram Language (Mathematica) , 47 46 octets

Axiom, 5 bytes

APL(NARS), 42 chars, 84 bytes