Если задано неотрицательное целое число выведите число Эйлера ( OEIS A122045 ).$n ,$$n^{\text{th}}$

Все нечетные числа Эйлера равныЧетные числа Эйлера могут быть вычислены по следующей формуле ( относится к мнимой единице): $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} } } \,.$$

правила

• $n$n th будет неотрицательным целым числом, так что число Эйлера находится в пределах представимого диапазона целых чисел для вашего языка.$n^{\text{th}}$

Тестовые случаи

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

Mathematica, 6 байтов

EulerE

-кашель-

J , 10 байт

(1%6&o.)t:

Попробуйте онлайн!

Используется определение для экспоненциальной производящей функции sech (x).

Пари / ГП , 32 байта

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

Попробуйте онлайн!

Клен, 5 байт

euler

Ура для встроенных?

Максима , 5 байтов / 42 байта

Максима имеет встроенный:

euler

Попробуйте онлайн!

Следующее решение не требует встроенного сверху и использует формулу, которая первоначально определила числа Эйлера.

В основном мы ищем n-й коэффициент расширения серии 1/cosh(t) = sech(t)(до n!)

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

Попробуйте онлайн!

Mathematica, без встроенного, 18 байт

Используя формулу @ rahnema1 :

2Im@PolyLog[-#,I]&

---

21 байт:

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

Python 2.7, 46 байт

С помощью Сципи.

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

Perl 6 , 78 байт

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

Использует итерационную формулу отсюда :

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

Как это работает

Общая структура - это лямбда, в которой генерируется бесконечная последовательность, выражением, которое вызывается повторно и получает все предыдущие значения последовательности в переменной @E, а затем эта последовательность индексируется с помощью аргумента лямбда:

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

Выражение, вызываемое для каждого шага последовательности:

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

Максима, 29 байт

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

Попробуйте онлайн!

Дважды мнимая часть функции полилогарифма порядка -nс аргументом i [1]

JavaScript (Node.js) , 46 45 байт

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

Попробуйте онлайн!

Действителен для всех значений (как требуется), но не для целом (выводит для нечетных s.) Код модифицируется для уменьшения одного байта путем изменения вывода на где определено, как показано ниже. В частности, формула повторения для имеет вид$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 байт

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

Попробуйте онлайн!

Удивлен, пока не нашел ответ на JavaScript, так что я попробую.

Код состоит только из базовой математики, но математика, стоящая за кодом, требует исчисления. Формула рекурсии получается из разложения производных от разных порядков.$\mathrm{sech}(x)$

объяснение

Здесь я буду использовать некоторые удобные обозначения. Пусть и . Тогда у нас есть$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}$$

Поскольку и , мы можем сделать вывод, что$\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}$$

Пусть и , мы можем переписать вышеприведенное соотношение как$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}$$

То есть вносит вклад как в и в . В результате мы можем написать в терминах и :$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(0,0)=1$$F(0,i)=0$$i\neq 0$

Связанная часть кода a?-F(--a,b)*++b+F(a,b-=3)*(a-b):+!bточно рассчитывается с использованием приведенной выше формулы повторения. Вот разбивка:

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

Для ветвей, которые никогда не могут быть достигнуты, повторения всегда заканчиваются на 0, поэтому где или нечетно. Последнее, в частности, подразумевает, что для всех нечетных s. Даже если строго больше , повторение может в конечном итоге позволить произойти в некоторой точке, но перед этим шагом оно должно достичь точки, где , а формула повторения показывает, что значение должно быть 0 в этой точке (поскольку первое слагаемое умножается на , а второе слагаемое находится дальше от "треугольника"$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$

расширения

Код может быть изменен для вычисления еще трех связанных последовательностей:

Касательные числа (46 байтов)

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

Secant Numbers (45 байтов)

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

Зигзагообразные числа Эйлера (48 байт)

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

Befunge, 115 байт

Это только поддерживает жестко заданный набор первых 16 чисел Эйлера (то есть E ₀ - E ₁₅ ). Все, что за этим, в любом случае не вписывается в 32-битное значение Befunge.

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

Попробуйте онлайн!

Я также полностью реализовал формулу, представленную в задаче, но она почти в два раза больше и по-прежнему ограничена первыми 16 значениями в TIO, хотя это 64-разрядный интерпретатор.

<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

Попробуйте онлайн!

Проблема с этим алгоритмом состоит в том, что промежуточные значения в ряду переполняются намного раньше, чем общее. На 32-битном интерпретаторе он может обрабатывать только первые 10 значений (т. Е. От E ₀ до E ₉ ). Тем не менее, переводчики, использующие bignums, должны работать намного лучше - PyFunge и Befungee могут справиться как минимум с E ₃₀ .

Python2, (разумно рационально), 153 байта

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

Это очень неоптимально, но он пытается использовать базовые функции sympy и избегать чисел с плавающей запятой. Спасибо @Mego за то, что я прямо указал на оригинальную формулу, указанную выше. Я пытался использовать что-то вроде @ xnor's "объединить две петли" из Tips для игры в гольф на Python

CJam (34 байта)

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

Демонстрация онлайн, которая печатает E (0) к E (19). Это анонимный блок (функция).

Реализация заимствует повторение Shieru Akasoto и переписывает его в более дружественном для CJam стиле, манипулируя целыми строками за раз.

рассечение

{           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 байтов

Без использования каких-либо специальных функций:

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

Попробуйте онлайн!

Аксиома, 5 байт

euler

для OEIS A122045; это 57 байт

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

код теста и результаты

(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 символа, 84 байта

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

Следуйте формуле, показанной в «smls», тестируйте:

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

последний случай возвращает одно большое рациональное значение в качестве результата, потому что я ввожу 20x (большое рациональное значение 20/1), а не 20, как мне кажется, 20.0 с плавающей запятой 64-разрядной

  E 20x
370371188237525 

Было бы быстрее, если бы один вернул 0 в ближайшее время, но был бы немного длиннее (50 символов):

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

было бы быстрее, если бы использовалось определение по вопросу (и было бы немного длиннее 75 символов):

  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 

Результат выше это одно комплексное число, которое имеет только действительную часть.