Dato un intero non negativo uscita numero Eulero ( OEIS A122045 ). $n ,$ $n^{\text{th}}$

Tutti i numeri di Eulero indicizzati in modo dispari sono $0 .$ I numeri di Eulero con indice pari possono essere calcolati con la seguente formula ( $i \equiv \sqrt{-1}$ riferisce all'unità immaginaria):

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

Regole

$n$ sarà un numero intero non negativo in modo tale che ilnumero di Eulero $n^{\text{th}}$ sia compreso nell'intervallo rappresentabile di numeri interi per la tua lingua.

Casi test

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

— Mego
fonte

1

@donbright Ti manca un set di parentesi: wolframalpha.com/input/… - con ciò, i due riassunti sono entrambi -i/2, che producono -iquando vengono aggiunti. Moltiplicalo per l' iesterno della somma e otterrai 1.

— Mego,

18

Mathematica, 6 byte

EulerE

-tosse-

— Greg Martin
fonte

9

Quando ho visto il titolo, ho subito pensato "Sicuramente Mathematica deve avere una struttura per questo".

— HyperNeutrino,

12

Questo vale per quasi tutti i titoli ... persino per individuare le capre nelle immagini

— Luis Mendo,

GoatImageQè sottovalutato

— Greg Martin,

1

Puoi spiegarlo? Modifica: questo era uno scherzo.

— Magic Octopus Urn

13

J , 10 byte

(1%6&o.)t:

Provalo online!

Usa la definizione per la funzione generatrice esponenziale sech (x).

— miglia
fonte

J esegue analisi simboliche per ottenere la funzione di generazione? Non si verificano errori in virgola mobile anche per n = 30.

— orlp

@orlp Non sono sicuro di cosa faccia internamente, ma J conosce la serie di Taylor per un sottoinsieme di verbi . Qualsiasi funzione che puoi definire usando una combinazione di quei verbi sarà valida per t.o t:dove sono gf ed egf Una nota curiosa è che tan (x) non è supportata ma sin (x) / cos (x) lo è.

— miglia

12

Pari / GP , 32 byte

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

Provalo online!

— alephalpha
fonte

11

Acero, 5 byte

euler

Evviva i builtin?

— miglia
fonte

4

Lo

— adoro

11

Massimi , 5 byte / 42 byte

Maxima ha un integrato:

euler

Provalo online!

La seguente soluzione non richiede l'integrazione dall'alto e utilizza la formula che originariamente definiva i numeri di eulero.

Stiamo sostanzialmente cercando l'ennesimo coefficiente dell'espansione in serie di 1/cosh(t) = sech(t)(fino al n!)

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

Provalo online!

— flawr
fonte

9

Mathematica, senza built-in, 18 byte

Usando la formula di @ rahnema1 :

2Im@PolyLog[-#,I]&

21 byte:

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

— alephalpha
fonte

5

Python 2.7, 46 byte

Usando Scipy.

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

— hashcode55
fonte

5

Perl 6 , 78 byte

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

Utilizza la formula iterativa da qui :

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

Come funziona

La struttura generale è una lambda in cui viene generata una sequenza infinita, da un'espressione che viene chiamata ripetutamente e ottiene tutti i valori precedenti della sequenza nella variabile @E, quindi quella sequenza viene indicizzata con l'argomento lambda:

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

L'espressione chiamata per ogni passaggio della sequenza è:

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

— LMS
fonte

4

Maxima, 29 byte

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

Provalo online!

Parte immaginaria due volte della funzione di ordine del poligrafo -ncon argomento i [1]

— rahnema1
fonte

4

JavaScript (Node.js) , 46 45 byte

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

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

$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

Provalo online!

Sorpreso di non aver ancora trovato una risposta JavaScript, quindi proverò.

$\mathrm{sech}(x)$

Spiegazione

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

$\frac{dT}{dt}=S^2$ $\frac{dS}{dt}=-TS$

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

$b=i+1$ $a=n-i$

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

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

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

$F(0,0)=1$ $F(0,i)=0$ $i\neq 0$

La parte correlata del codice a?-F(--a,b)*++b+F(a,b-=3)*(a-b):+!bsta calcolando esattamente utilizzando la formula di ricorrenza sopra. Ecco la ripartizione:

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

$T(0)=0$ $S(0)=1$ $E_n$ $S^{n+1}$ $\frac{d^nS}{dt^n}$ $F(n,n)$

$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$ $F(n,i)=0$ $i > n$

estensioni

Il codice può essere modificato per calcolare altre tre sequenze correlate:

Numeri tangenti (46 byte)

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

Numeri di secante (45 byte)

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

Euler Zigzag Numbers (48 byte)

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

— Shieru Asakoto
fonte

3

Befunge, 115 byte

Questo supporta solo un set hardcoded dei primi 16 numeri di Eulero (cioè da E ₀ a E ₁₅ ). Qualsiasi cosa oltre a quella non rientrerebbe comunque in un valore Befunge a 32 bit.

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

Provalo online!

Ho anche realizzato un'implementazione completa della formula fornita nella sfida, ma è quasi il doppio della dimensione ed è ancora limitata ai primi 16 valori su TIO, anche se si tratta di un interprete a 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

Provalo online!

Il problema con questo algoritmo è che i valori intermedi nella serie traboccano molto prima del totale. Su un interprete a 32 bit può gestire solo i primi 10 valori (cioè da E ₀ a E ₉ ). Gli interpreti che usano i bignum dovrebbero comunque fare molto meglio: PyFunge e Befungee potrebbero entrambi gestire almeno fino a E ₃₀ .

— James Holderness
fonte

1

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

Questo è molto subottimale ma sta cercando di usare le funzioni sympy di base ed evitare il virgola mobile. Grazie @Mego per avermi indicato la formula originale sopra elencata. Ho provato a usare qualcosa come "combina due loop" di @ xnor da Tips for golfing in Python

— don luminoso
fonte

1

Puoi fare import*(rimuovere lo spazio in mezzo) per salvare un byte. Inoltre, devi prendere il numero come input in qualche modo (non sono ammessi frammenti che presuppongono che l'input sia in una variabile).

— FlipTack

1

CJam (34 byte)

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

Demo online che stampa da E (0) a E (19). Questo è un blocco anonimo (funzione).

L'implementazione prende in prestito la ricorrenza di Shieru Akasoto e la riscrive in uno stile più amichevole per CJam, manipolando intere file alla volta.

Dissezione

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

1

Wolfram Language (Mathematica) , 47 46 byte

Senza utilizzare alcuna funzione speciale:

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

Provalo online!

— romano
fonte

0

Assioma, 5 byte

euler

per OEIS A122045; questo è 57 byte

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

codice test e risultati

(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
fonte

0

APL (NARS), 42 caratteri, 84 byte

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

Segui la formula mostrata da "smls", prova:

l'ultimo caso restituisce un grande razionale come risultato perché inserisco 20x (il grande razionale 20/1) e non 20 come penso 20.0 float 64 bit ...

  E 20x
370371188237525

Sarebbe più veloce se uno restituisse 0 presto ma sarebbe un po 'più lungo (50 caratteri):

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

sarebbe più veloce se fosse usata la definizione in questione (e sarebbe un po 'più lunga di 75 caratteri):

  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

Il risultato sopra è un numero complesso che ha solo la parte reale.

— RosLuP
fonte

Stampa i numeri di Eulero

Regole

Casi test

Mathematica, 6 byte

J , 10 byte

Pari / GP , 32 byte

Acero, 5 byte

Massimi , 5 byte / 42 byte

Mathematica, senza built-in, 18 byte

Python 2.7, 46 byte

Perl 6 , 78 byte

Come funziona

Maxima, 29 byte

JavaScript (Node.js) , 46 45 byte

JavaScript (Node.js) , 70 46 byte

Spiegazione

estensioni

Befunge, 115 byte

Python2, (sympy razionale), 153 byte

CJam (34 byte)

Dissezione

Wolfram Language (Mathematica) , 47 46 byte

Assioma, 5 byte

APL (NARS), 42 caratteri, 84 byte