Wyjście liczb Eulera

28

Biorąc nieujemną liczbę całkowitą wyjście Numer Eulera ( OEIS A122045 ).n,nth

Wszystkie liczby Eulera o indeksie nieparzystym wynosząLiczby Eulera o indeksie parzystym można obliczyć za pomocą następującego wzoru ( odnosi się do jednostki urojonej): 0.i1

E2n=ik=12n+1j=0k(kj)(1)j(k2j)2n+12kikk.

Zasady

  • n będzie nieujemną liczbą całkowitą, tak że liczba Eulera będzie w reprezentatywnym zakresie liczb całkowitych dla twojego języka.nth

Przypadki testowe

0 -> 1
1 -> 0
2 -> -1
3 -> 0
6 -> -61
10 -> -50521
20 -> 370371188237525
Mego
źródło
1
@donbright Brakuje zestawu nawiasów: wolframalpha.com/input/… - dzięki temu oba sumy są oba -i/2, które ustępują-i po dodaniu. Pomnóż to przez izewnętrzną sumę, a otrzymasz 1.
Mego

Odpowiedzi:

18

Mathematica, 6 bajtów

EulerE

-kaszel-

Greg Martin
źródło
9
Kiedy zobaczyłem tytuł, od razu pomyślałem: „Na pewno Mathematica musi mieć do tego wbudowaną funkcję”.
HyperNeutrino
12
Dotyczy to prawie każdego tytułu ... nawet wykrywania kóz na obrazach
Luis Mendo
GoatImageQjest niedoceniany
Greg Martin
1
Czy możesz to wyjaśnić? Edycja: to był żart.
Magic Octopus Urn
13

J , 10 bajtów

(1%6&o.)t:

Wypróbuj online!

Wykorzystuje definicję wykładniczej funkcji generowania sech (x).

mile
źródło
Czy J wykonuje analizę symboliczną, aby uzyskać funkcję generującą? Nie napotyka błędów zmiennoprzecinkowych nawet dla n = 30.
orlp
@orlp Nie jestem pewien, co robi wewnętrznie, ale J zna serię Taylora dla podzbioru czasowników . Każda funkcja, którą możesz zdefiniować za pomocą kombinacji tych czasowników, będzie ważna dla t.lub t:gdzie są gf i egf Ciekawe jest to, że tan (x) nie jest obsługiwany, ale sin (x) / cos (x) jest.
mile
11

Klon, 5 bajtów

euler

Hurra dla wbudowanych?

mile
źródło
4
Uwielbiam to, gdy matematyka jest zbyt gadatliwa, by rozwiązywać problemy matematyczne ...
theonlygusti
11

Maxima , 5 bajtów / 42 bajty

Maxima ma wbudowane:

euler

Wypróbuj online!

Poniższe rozwiązanie nie wymaga wbudowania z góry i wykorzystuje wzór, który pierwotnie zdefiniował liczby euler.

Zasadniczo szukamy n-tego współczynnika rozszerzenia szeregu 1/cosh(t) = sech(t)(aż do n!)

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

Wypróbuj online!

wada
źródło
9

Mathematica, bez wbudowanego, 18 bajtów

Korzystanie ze wzoru @ rahnema1 :

2Im@PolyLog[-#,I]&

21 bajtów:

Sech@x~D~{x,#}/.x->0&
alephalpha
źródło
5

Python 2.7, 46 bajtów

Korzystanie z Scipy.

from scipy.special import*
lambda n:euler(n)[n]
hashcode55
źródło
5

Perl 6 , 78 bajtów

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

Wykorzystuje iteracyjny wzór stąd :

En=1k=0n1[Ek2(n1k)(nk)]

Jak to działa

Ogólna struktura to lambda, w której generowana jest nieskończona sekwencja, poprzez wyrażenie, które jest wywoływane wielokrotnie i pobiera wszystkie poprzednie wartości sekwencji w zmiennej @E, a następnie sekwencja ta jest indeksowana argumentem lambda:

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

Wyrażenie wywoływane dla każdego kroku sekwencji to:

1 - sum @E».&{              # 1 - ∑
    $_                      # Eₙ
    * 2**(@E - 1 - $++)     # 2ⁿ⁻ˡ⁻ᵏ
    * [*](@E - $++ ^.. @E)  # (n-k-1)·...·(n-1)·n
    / [*] 1..$++            # 1·2·...·k
}
smls
źródło
4

Maxima, 29 bajtów

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

Wypróbuj online!

Dwukrotnie urojona część funkcji polilogarytmu porządku -nz argumentem i [1]

rahnema1
źródło
4

JavaScript (Node.js) , 46 45 bajtów

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

Wypróbuj online!

EnF(n,i)F(n,i)nF(n,i)=(1)nF(n,i)FF

F(n,i)=(in1)F(n1,i2)+(i+1)F(n1,i)

JavaScript (Node.js) , 70 46 bajtów

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

Wypróbuj online!

Zaskoczony, że nie znalazłem jeszcze odpowiedzi na JavaScript, więc spróbuję.

sech(x)

Wyjaśnienie

Tn:=tanhn(t)S.n: =smidohn(t)

renS.retn=ja=0nfa(n,ja)T.n-jaS.ja+1

reT.ret=S.2)reS.ret=-T.S.

reret(T.zaS.b)=zaT.za-1(S.2))(S.b)+bS.b-1(-T.S.)(T.za)=zaT.za-1S.b+2)-bT.za+1S.b

b=i+1a=ni

ddt(TniSi+1)=(ni)Tni1Si+3(i+1)Tni+1Si+1=(ni)T(n+1)(i+2)S(i+2)+1(i+1)T(n+1)iSi+1

F(n,i)F(n+1,i+2)F(n+1,i)F(n,i)F(n1,i2)F(n1,i)

F(n,i)=(ni+1)F(n1,i2)(i+1)F(n1,i)

F(0,0)=1F(0,i)=0i0

Powiązana część kodu a?-F(--a,b)*++b+F(a,b-=3)*(a-b):+!bjest dokładnie obliczana przy użyciu powyższej formuły rekurencyjnej. Oto podział:

-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)=0S(0)=1EnSn+1dnSdtnF(n,n)

F(0,0)F(n,i)=0i<0iEn=0nin0ini=n+1ni+1=n(n+1)+1=00inF(n,i)=0i>n

Rozszerzenia

Kod można zmodyfikować, aby obliczyć trzy kolejne powiązane sekwencje:

Liczby styczne (46 bajtów)

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
źródło
3

Befunge, 115 bajtów

To po prostu obsługuje zakodowany zestaw pierwszych 16 liczb Eulera (tj. E 0 do E 15 ). Cokolwiek poza tym i tak nie zmieściłoby się w 32-bitowej wartości Befunge.

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

Wypróbuj online!

Zrobiłem również pełną implementację formuły podanej w wyzwaniu, ale jest ona prawie dwa razy większa i nadal jest ograniczona do pierwszych 16 wartości w TIO, nawet jeśli jest to 64-bitowy interpreter.

<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

Wypróbuj online!

Problem z tym algorytmem polega na tym, że wartości pośrednie w serii przepełniają się znacznie wcześniej niż suma całkowita. W 32-bitowym interpretatorze może obsłużyć tylko pierwsze 10 wartości (tj. E 0 do E 9 ). Tłumacze używający bignum powinni jednak działać znacznie lepiej - PyFunge i Befungee mogą obsłużyć co najmniej do E 30 .

James Holderness
źródło
1

Python2, (sympy rational), 153 bajty

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

Jest to bardzo nieoptymalne, ale próbuje użyć podstawowych funkcji sympy i uniknąć zmiennoprzecinkowego. Dzięki @Mego za postawienie mnie na oryginalnej formule wymienionej powyżej. Próbowałem użyć czegoś takiego jak „Połącz dwie pętle” @ xnor z Porad do gry w golfa w Pythonie

Don Bright
źródło
1
Możesz zrobić import*(usunąć spację między nimi), aby zapisać bajt. Ponadto musisz jakoś wziąć liczbę jako dane wejściowe (fragmenty, które zakładają, że dane wejściowe są zmienne, nie są dozwolone).
FlipTack,
1

CJam (34 bajty)

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

Demo online, które drukuje litery E (0) do E (19). To anonimowy blok (funkcja).

Implementacja pożycza rekurencję Shieru Akasoto i przepisuje ją w bardziej przyjaznym dla CJam stylu, manipulując jednocześnie całymi wierszami.

Sekcja

{           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
źródło
0

Aksjomat, 5 bajtów

euler

dla OEIS A122045; to jest 57 bajtów

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

kod testowy i wyniki

(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
źródło
0

APL (NARS), 42 znaki, 84 bajty

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

Postępuj zgodnie ze wzorem pokazanym w „smls”, test:

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

ostatni przypadek zwraca jeden duży wymierny wynik, ponieważ wprowadzam 20x (duży wymierny 20/1), a nie 20, jak myślę 20.0 zmiennoprzecinkowy 64-bitowy ...

  E 20x
370371188237525 

Byłoby to szybsze, gdyby jedno szybko zwróciło 0, ale byłoby trochę dłuższe (50 znaków):

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

byłby szybszy, gdyby użył definicji, o której mowa (i miałby nieco więcej 75 znaków):

  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 

Wynik powyżej to jedna liczba zespolona, ​​która ma tylko rzeczywistą część.

RosLuP
źródło