Hampir setiap fungsi dapat diekspresikan sebagai polinomial dengan suku tak terbatas.

Sebagai contoh, e^x = 1 + x + x^2/2! + x^3/3! + x^4/4! + ...

Sebagai contoh, sin(x) = x - x^3/3! + x^5/5! - x^7/7! + ...

Koefisien dari nistilah -th membentuk urutan, dan fungsi yang sesuai disebut Fungsi Pembangkitan urutan.

Koefisien dari nistilah -th membentuk urutan.

Seringkali, nistilah -th akan memiliki penyebut n!. Oleh karena itu, kami melipatgandakan koefisien dengan n!memperoleh urutan lain, yang Fungsi Penghasil Eksponensial akan menjadi fungsi asli.

Sebagai contoh, urutan yang Fungsi eksponensial Membangkitkan adalah e^xakan 1,1,1,1,....

Sebagai contoh, urutan yang Fungsi eksponensial Membangkitkan adalah sin(x)akan 0,1,0,-1,0,1,0,-1,....

Tugas

Tugas Anda adalah untuk menemukan nistilah -th dari urutan yang Fungsi eksponensial Membangkitkan adalah tan(x).

Testcases

n result
0 0
1 1
2 0
3 2
4 0
5 16
6 0
7 272
8 0
9 7936
10 0
11 353792
12 0
13 22368256
14 0
15 1903757312
16 0
17 209865342976
18 0
19 29088885112832
20 0
21 4951498053124096
22 0
23 1015423886506852352
24 0
25 246921480190207983616
26 0

(Disalin dari sini .) (Peringatan: 0istilah -th berbeda)

Contoh implementasi

# copied from https://github.com/Mego/Seriously/blob/v2.0/SeriouslyCommands.py#L16
def memoized(f):
    memo = {}
    def m_fun(*args):
        if args in memo:
            return memo[args]
        else:
            res = f(*args)
            memo[args] = res
            return res
    return m_fun

# copied from https://github.com/Mego/Seriously/blob/v2.0/SeriouslyCommands.py#L169
@memoized
def binomial(n,r):
    if r > n:
        return 0
    elif r==n:
        return 1
    res = 1
    i = 1
    while i<=r:
        res *= (n+1-i)
        res /= i
        i+=1
    return int(res)

# 2*u(n+1) = Sum_{k=0..n} binomial(n, k)*u(k)*u(n-k)
# from A000111
@memoized
def u(n):
    if n<0: return 0
    if n==0: return 1
    if n==1: return 1
    return sum([binomial(n-1,k)*u(k)*u(n-1-k) for k in range(n)])//2     

def t(n):
    if n%2 == 0: return 0
    return u(n)

print('\n'.join([str(x) + ' ' + str(t(x)) for x in range(26)]))

Ide itu!

Referensi

• Menghasilkan fungsi di Wikipedia
• Fungsi menghasilkan eksponensial di Wikipedia
• Contoh fungsi penghasil eksponensial di Wikipedia
• Menghasilkan fungsi di MathWorld
• Fungsi menghasilkan eksponensial di MathWorld
• Serial Taylor di Wikipedia
• Penurunan 9 syarat pertama dari urutan yang diperlukan
• Wajib OEIS A009006 (Perhatikan bahwa 0istilah -th berbeda)
• Algoritma
• OEIS A000111: angka atas / bawah

CJam ( 33 32 27 26 23 20 byte)

2,{ee::*_(@+.+}ri*0=

Demo online

Pembedahan

Ini pada dasarnya mengimplementasikan perulangan yang dijelaskan oleh xnor .

2,        e# [0 1] represents the base case f(0,j) = j==1
{         e# Loop...
  ee::*   e#   Multiply each array element by its index
  _(@+.+  e#   Sum the array shifted left and the array shifted right
}ri*      e# ... n times
0=        e# Evaluate at j=0

Atau dengan pendekatan yang agak berbeda, untuk 23 byte:

ri_1&a{{1$+}*]W%0+}@*0=

Demo online . Terima kasih kepada Dennis untuk 3 byte.

Pembedahan

1a         e# Push [1]
{          e# Repeat...
  {1$+}*]  e#   Compute array of partial sums
  W%0+     e#   Reverse and append 0
}qi:A*     e# ... A times, where A is the input value
0=A1&*     e# Result is first element if A odd, and 0 otherwise

Atau dengan pendekatan yang sangat berbeda, untuk 29 byte:

qie!Ma-{W\+W+3ew{_$.=1=},!},,

Demo online

Sayangnya diperlukan kasus khusus untuk input 0.

Pembedahan

qi            e# Take an integer n from stdin
e!            e#   Compute all permutations of [0 ... n-1]
Ma-           e#   Special-case n=0
{             e#   Filter...
  W\+W+       e#     Prepend and postpend -1
  3ew         e#     Take slices of 3 consecutive elements
  {           e#     Filter...
    _$.=1=    e#       Test whether the middle element is the second largest
  },!         e#     ... and require no matches
},,           e#   ... and count

Anda mungkin berpikir "WTF ?! Dia menjawab pertanyaan yang salah." Jika demikian, itu bisa dimengerti, tetapi kedua pendekatan itu memang memberikan hasil yang benar .

Julia, 40 38 32 byte

!n=2(2*4^n-2^n-0^n)abs(zeta(-n))

Input dan output dalam bentuk BigFloats. Cobalah online!

Latar Belakang

Rangkaian fungsi tangen Maclaurin memenuhi identitas

setiap kali x terletak pada jari-jari konvergensi, di mana B _n adalah angka Bernoulli.

Karena B _{2 (n + 1)} dan (-1) ⁿ memiliki tanda yang sama, B _{2n + 1} = 0 jika n> 0 dan B ₁ = 1/2 , kita dapat menulis ulang di atas sebagai berikut.

Selanjutnya, setiap kali n adalah bilangan bulat non-negatif, kita miliki

di mana ζ menunjukkan fungsi Riemann zeta .

Dari ini, dengan konvensi 0 ⁰ = 1 , ia mengikutinya

yang merupakan formula yang digunakan implementasi.

Python, 57 byte

f=lambda i,j=0:~-j*f(i-1,j-1)-~j*f(i-1,j+1)if i else j==1

Kurang golf:

f=lambda i,j=0:j==1 if i==0 else (j-1)*f(i-1,j-1)+(j+1)*f(i-1,j+1)

Kita dapat menghitung ikoefisien th dari fungsi pembangkit eksponensial dengan membedakan waktu fungsi tangen idan mengevaluasi pada 0. Setiap turunan adalah polinomial dalam tan(x), dan nilainya pada 0 adalah istilah konstannya.

Kami secara ekspresif mengekspresikan koefisien tan(x)**jdalam iturunan tandengan fungsi f(i,j). Ekspresi rekursif berasal dari relasi tan(x)' = 1 + tan(x)**2.

Jadi, turunan dari tan(x)**jadalah

j*tan(x)**(j-1)*(tan(x)**2+1), or equivalently
j*tan(x)**(j+1) + j*tan(x)**(j-1)

Jadi, kontributor tan(x)**jdalam iturunannya adalah tan(x)**(j-1)dan tan(x)**(j+1)dalam (i-1)turunan pertama, masing-masing dengan koefisien sama dengan kekuatannya. Ini memberikan ekspresi rekursif

f(i,j) = (j-1)*f(i-1,j-1) + (j+1)*f(i-1,j+1)

Perhatikan bahwa kita tidak perlu mengecualikan eksponen negatif jkarena mereka tetap mengevaluasi ke nol dan tidak berkontribusi karena persimpangan j=0memberikan pengganda 0.

Kasus dasar i==0korespondensi dengan tan(x)dirinya sendiri j==1, dan nol koefisien sebaliknya. Evaluasi akhir terjadi pada istilah konstan j=0, yang dimasukkan sebagai nilai default.

Mathematica, 20 byte

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

Pendekatan lurus ke depan. Hitung n ^th turunan dari tan (x) dan mengevaluasinya di x = 0 .

Pemakaian

Haskell, 48 byte

0%1=1
0%_=0
i%j=sum[k*(i-1)%k|k<-[j+1,j-1]]
(%0)

Kita dapat menghitung ikoefisien th dari fungsi pembangkit eksponensial dengan membedakan waktu fungsi tangen idan mengevaluasi pada 0. Setiap turunan adalah polinomial dalam tan(x), dan nilai 0 adalah istilah konstannya.

Kami secara ekspresif mengekspresikan koefisien tan(x)^jdalam iturunan tandengan fungsi i%j. Ekspresi rekursif berasal dari relasi tan(x)' = 1 + tan(x)^2.

Jadi, turunan dari tan(x)^jadalah

j*tan(x)^(j-1)*(tan(x)^2+1), or equivalently
j*tan(x)^(j+1) + j*tan(x)^(j-1)

Jadi, kontributor tan(x)^jdalam iturunannya adalah tan(x)^(j-1)dan tan(x)^(j+1)dalam (i-1)turunan pertama, masing-masing dengan koefisien sama dengan kekuatannya.

Jelly , 12 11 byte

Ṛ+\;S
ḂÇ⁸¡Ḣ

Seperti jawaban CJam Peter Taylor , ini menghitung suku ke- n dari urutan naik / turun Euler jika n adalah kasus ganjil dan khusus bahkan n sebagai 0 .

Cobalah online! atau verifikasi semua kasus uji .

Bagaimana itu bekerja

ḂÇ⁸¡Ḣ  Main link. Argument: n

Ḃ       Bit; yield n's parity.
 Ç⁸¡    Apply the helper link (Ç) n (⁸) times.
    Ḣ   Head; retrieve the first element of the resulting list.


Ṛ+\;S   Helper link. Argument: A (list or 1/0)

Ṛ       Cast A to list (if necessary) and reverse the result.
 +\     Take the cumulative sum.
   ;S   Append the sum of A.

Sage, 26 byte

lambda n:tan(x).diff(n)(0)

Seperti solusi lain dalam bahasa yang berorientasi matematika, fungsi ini menghitung nturunannya tan(x)dan mengevaluasinya di x = 0.

Cobalah online

J, 15 13 byte

Ada juga builtin t:yang menghitung koefisien ^ke- n dari fungsi pembangkit eksponensial tan (x) .

(1&o.%2&o.)t:

Terima kasih kepada @ Leaky Nun karena mengingatkan saya pada adverbia seri Taylor dalam J yang menghemat 2 byte.

Alternatif untuk 15 byte .

3 :'(3&o.d.y)0'

Pendekatan lain adalah untuk menghitung n ^th turunan dari tan (x) dan mengevaluasinya di x = 0 .

Catatan: Dalam J , jumlah memori yang digunakan oleh fungsi turunan d.tumbuh dengan cepat ketika n melewati 10.

Pemakaian

   f =: (1&o.%2&o.)t:
   f 7
272
   (,.f"0) i. 11  NB. Additional commands are just for formatting the output
 0    0
 1    1
 2    0
 3    2
 4    0
 5   16
 6    0
 7  272
 8    0
 9 7936
10    0

Penjelasan

(1&o.%2&o.)t:  Input: n
(         )    Define a monad (one argument function), call the input y
 1&o.          Get the trig function sin(x) and call it on y
      2&o.     Get the trig function cos(x) and call it on y
     %         Divide sin(y) by cos(y) to get tan(y)
           t:  Get the nth coefficient of the exponential generating series
               for that function and return

3 :'(3&o.d.y)0'  Input: n
3 :'          '  Define a monad (one argument function) with input y
     3&o.        Get the trig function tan(x)
           y     The input n
         d.      Get the nth derivative of tan(x)
             0   Evaluate the nth derivative at x = 0 and return

Julia, 39 37 byte

!n=(spdiagm((0:n,1:n+1),(1,-1))^n)[2]

Disimpan 2 byte berkat Dennis.

Bukan solusi Julia terpendek (lihat solusi Dennis), tetapi yang ini dilakukan murni menggunakan logika derivatif ... dalam bentuk matriks.

Pada dasarnya, ia menggunakan fakta bahwa turunan dari tan (x) adalah 1 + tan (x) ^ 2. Jadi karena turunan dari setiap kekuatan tan (x), katakan tan (x) ^ k, adalah k tan (x) ^ (k-1) tan (x) '= k tan (x) ^ (k-1) + k tan (x) ^ (k + 1), kita dapat menggunakan kekuatan matriks sederhana pada matriks dengan nilai yang sesuai untuk menghasilkan ekspansi, dengan baris atau kolom kedua (tergantung pada konstruksi) memegang turunan dari tan (x ) diri.

Jadi kita hanya perlu menemukan konstanta dalam ekspresi yang dihasilkan, dan itulah nilai pertama pada baris atau kolom yang sesuai.

JavaScript (ES6), 127 45 byte

f=(n,m=0)=>n?++m*f(--n,m--)+--m*f(n,m):m-1?0:1

Solusi Port of xnor.

Haskell, 95 93 byte

p=product
f n=sum[(-1)^(n`div`2+j+1)*j^n*p[k-j+1..n+1]`div`p[1..n+1-k+j]|k<-[1..n],j<-[0..k]]

Ini pada dasarnya merupakan implementasi dari formula umum dengan beberapa optimasi kecil.

MATLAB dengan Symbolic Toolbox, 84 byte

n=input('');syms x;c=coeffs(taylor(tan(x),'Order',n+1))*factorial(n);c(end)*mod(n,2)

Contoh berjalan:

>> n=input('');syms x;c=coeffs(taylor(tan(x),'Order',n+1))*factorial(n);c(end)*mod(n,2)
7
ans =
272

>> n=input('');syms x;c=coeffs(taylor(tan(x),'Order',n+1))*factorial(n);c(end)*mod(n,2)
8
ans =
0

>> n=input('');syms x;c=coeffs(taylor(tan(x),'Order',n+1))*factorial(n);c(end)*mod(n,2)
9
ans =
7936

Haskell (terlalu banyak byte)

Hanya menggunakan operasi pada daftar dan Raymond Manzoni ini hasil :

c n = last $ map numerator $ zipWith (*) (scanl (*) (1) [2,3..]) (intersperse 0 $ foldr (.) id (replicate n (\xs->(xs ++ [(1%(1+2*length xs)) * (sum (zipWith (*) xs (reverse xs)))]))) [1])

Sayangnya, ini melimpah untuk nilai sederhana n, karena menggunakan Intnilai. Saya akan mencoba untuk memperbaiki masalah menggunakan Integernilai. Sampai saat itu, saran dipersilahkan.

Aksioma, 46 byte

f(n:NNI):NNI==(n=0=>0;eval(D(tan(x),x,n),x=0))

kode untuk pengujian dan hasil

(32) -> [[i, f(i)] for i in 0..26]
   (32)
   [[0,0], [1,1], [2,0], [3,2], [4,0], [5,16], [6,0], [7,272], [8,0], [9,7936],
    [10,0], [11,353792], [12,0], [13,22368256], [14,0], [15,1903757312],
    [16,0], [17,209865342976], [18,0], [19,29088885112832], [20,0],
    [21,4951498053124096], [22,0], [23,1015423886506852352], [24,0],
    [25,246921480190207983616], [26,0]]
                                       Type: List List NonNegativeInteger