15

लगभग हर फ़ंक्शन को अनंत शब्दों के साथ एक बहुपद के रूप में व्यक्त किया जा सकता है।

उदाहरण के लिए, e^x = 1 + x + x^2/2! + x^3/3! + x^4/4! + ...

उदाहरण के लिए, sin(x) = x - x^3/3! + x^5/5! - x^7/7! + ...

n-Th शब्द के गुणांक एक अनुक्रम बनाते हैं, और संबंधित फ़ंक्शन को अनुक्रम का जनरेटिंग फ़ंक्शन कहा जाता है ।

n-Th शब्द के गुणांक एक क्रम बनाते हैं।

अक्सर, n-थ शब्द का एक भाजक होगा n!। इसलिए, हम गुणांक n!को एक और अनुक्रम प्राप्त करने के लिए गुणा करते हैं , जिसका एक्सपोनेंशियल जनरेटिंग फंक्शन मूल कार्य होगा।

उदाहरण के लिए, अनुक्रम जिसका घातीय उत्पन्न समारोह है e^xकिया जाएगा 1,1,1,1,...।

उदाहरण के लिए, अनुक्रम जिसका घातीय उत्पन्न समारोह है sin(x)किया जाएगा 0,1,0,-1,0,1,0,-1,...।

कार्य

आपका कार्य nउस अनुक्रम के -थ टर्म को खोजना है जिसका एक्सपोनेंशियल जनरेटिंग फंक्शन है tan(x)।

परीक्षण के मामलों

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

( यहां से नकल की गई है ।) (चेतावनी: 0-यह शब्द अलग है)

उदाहरण कार्यान्वयन

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

Ideone यह!

संदर्भ

— लीक नन
स्रोत

4

यदि आप गणित में उत्पन्न होने वाले कार्यों और उनके उपयोग के बारे में अधिक जानना चाहते हैं, विशेष रूप से कॉम्बीनेटरिक्स और संख्याएँ I तो मैं H. Wilf द्वारा इस "प्रसिद्ध" पाठ्यपुस्तक के निर्माण की सलाह देता हूँ ।

— दोष

5

(विरोध नहीं कर सकते): शाब्दिक रूप से लिया गया, आपका पहला वाक्य बेहद गलत है!

— फ्लॉंडर

आपके पास "जनरेटिंग फंक्शन" और "एक्सपोनेंशियल जनरेटिंग फंक्शन" का अर्थ है। $ \ sin (x) $ 0,1,0, -1,0,1,0, -1,0, के अनुक्रम का घातीय उत्पादक कार्य है ... - यह वह अनुक्रम नहीं है जो घातीय उत्पादक कार्य है $ \ sin (x) $ का। आप हमसे जो करने के लिए कह रहे हैं वह $ \ tan (x) $ द्वारा उत्पन्न अनुक्रम को तेजी से कोडित करना है।

— ग्लेन ओ

ठीक लग रहा है, सिवाय "इसे उस फ़ंक्शन का जेनरेटिंग फ़ंक्शन भी कहा जाता है। n-वें-वें के गुणांक एक अनुक्रम बनाते हैं।", जो शायद कुछ कहना चाहिए जैसे "एन-वें शब्दों के गुणांक एक अनुक्रम बनाते हैं, और" इसी कार्य को अनुक्रम का जनरेटिंग फंक्शन कहा जाता है।

— ग्लेन ओ

@ गलेनो संपादित

— लीक नून

8

CJam ( 33 32 27 26 23 20 बाइट्स)

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

ऑनलाइन डेमो

विच्छेदन

यह अनिवार्य रूप से 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

या 23 बाइट्स के लिए एक अलग दृष्टिकोण के साथ:

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

ऑनलाइन डेमो । 3 बाइट्स के लिए डेनिस को धन्यवाद।

विच्छेदन

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

या 29 बाइट्स के लिए एक बहुत अलग दृष्टिकोण के साथ:

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

ऑनलाइन डेमो

दुर्भाग्य से इनपुट के लिए एक विशेष मामले की आवश्यकता होती है 0।

विच्छेदन

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

आप सोच रहे होंगे "डब्ल्यूटीएफ ?! वह गलत सवाल का जवाब दे रहा है।" यदि हां, तो यह समझ में आता है, लेकिन दोनों दृष्टिकोण वास्तव में सही परिणाम देते हैं ।

— पीटर टेलर
स्रोत

यदि ओटी मदद करता है, तो टीआईओ पर रात का निर्माण एक खाली सरणी देता है [WW]3ew।

— डेनिस

@ डेनिस, धन्यवाद। हालांकि, यह पता चला है कि 0वैसे भी एक विशेष मामला होने की आवश्यकता है, क्योंकि यह मूल्यांकन करता है 1।

— पीटर टेलर

1

एक केवल आपको लगता है कि आप गलत प्रश्न का उत्तर दे रहे हैं यदि किसी ने मेरे लिंक पर क्लिक नहीं किया है।

— लीक नून

ri_1&a{{1$+}*]W%0+}@*0=3 बाइट्स बचाता है।

— डेनिस

2

@LeakyNun, तो वह हर कोई होगा। मैंने लिंक और tl की सूची देखी, डॉ।

— पीटर टेलर

7

जूलिया, 40 38 32 बाइट्स

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

इनपुट और आउटपुट BigFloats के रूप में है । इसे ऑनलाइन आज़माएं!

पृष्ठभूमि

स्पर्शरेखा फ़ंक्शन की मैकलॉरीन श्रृंखला पहचान को संतुष्ट करती है

जब कभी x अपने अभिसरण त्रिज्या में स्थित हो, जहां B _n एक बर्नौली संख्या है।

चूँकि B _{2 (n + 1)} और (-1) ⁿ का चिन्ह समान है, B _{2n + 1} = 0 यदि n> 0 है और B ₁ = 1/2 है , तो हम उपरोक्त को फिर से लिख सकते हैं।

इसके अलावा, जब भी n एक गैर-नकारात्मक पूर्णांक है, हमारे पास है

कहाँ पे ζ रीमैन ज़ेटा फ़ंक्शन को दर्शाता है ।

इससे, सम्मेलन के साथ ०⁰ = 1 के साथ , यह इस प्रकार है

कार्यान्वयन का उपयोग करने वाला सूत्र है।

— डेनिस
स्रोत

6

पायथन, 57 बाइट्स

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

कम गोल्फ वाला:

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)

हम iस्पर्शरेखा फ़ंक्शन के iसमय को अलग करके और मूल्यांकन करके घातीय उत्पन्न करने वाले फ़ंक्शन के वें गुणांक की गणना कर सकते हैं 0। प्रत्येक व्युत्पन्न एक बहुपद है tan(x)और 0 पर इसका मान इसकी निरंतर अवधि है।

हम रिकर्सिवली के गुणांक व्यक्त tan(x)**jमें iकी वें व्युत्पन्न tanसमारोह के साथ f(i,j)। पुनरावर्ती अभिव्यक्ति संबंध से आती है tan(x)' = 1 + tan(x)**2।

तो, व्युत्पन्न tan(x)**jहै

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

तो, वें व्युत्पन्न tan(x)**jमें योगदानकर्ताओं और में हैंitan(x)**(j-1)tan(x)**(j+1)(i-1) सेंट व्युत्पन्न, गुणांक के साथ प्रत्येक का सत्ता में बराबर है। यह पुनरावर्ती अभिव्यक्ति देता है

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

ध्यान दें कि हमें नकारात्मक प्रतिपादकों को बाहर करने की आवश्यकता नहीं है jक्योंकि वे वैसे भी शून्य का मूल्यांकन करते हैं और पार करने के लिए योगदान नहीं करते हैंj=0 एक गुणक देता है 0।

आधार मामले के साथ ही i==0मेल खाती है , और शून्य गुणांक अन्यथा। अंतिम मूल्यांकन निरंतर शब्द पर होता है , जिसे डिफ़ॉल्ट मान के रूप में रखा जाता है।tan(x)j==1j=0

— XNOR
स्रोत

CJam में 20 बाइट्स के लिए यह पोर्ट। क्या आपको बुरा लगता है अगर मैं इसे अपना प्राथमिक उत्तर बनाता हूं, या क्या आप इसे पोर्ट और पोस्ट करना चाहते हैं?

— पीटर टेलर

आपको इसे पोस्ट करना चाहिए, मैं सीजाम को नहीं जानता।

— xnor

4

गणितज्ञ, 20 बाइट्स

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

सीधे-सीधे दृष्टिकोण। T (x) के n ^वें व्युत्पन्न की गणना करें और x = 0 पर इसका मूल्यांकन करें ।

प्रयोग

— मील की दूरी पर
स्रोत

3

हास्केल, 48 बाइट्स

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

हम iस्पर्शरेखा फ़ंक्शन के iसमय को अलग करके और मूल्यांकन करके घातीय उत्पन्न करने वाले फ़ंक्शन के वें गुणांक की गणना कर सकते हैं 0। प्रत्येक व्युत्पन्न एक बहुपद हैtan(x) , और 0 पर मान इसकी निरंतर अवधि है।

हम रिकर्सिवली के गुणांक व्यक्त tan(x)^jमें iकी वें व्युत्पन्न tanसमारोह के साथ i%j। पुनरावर्ती अभिव्यक्ति संबंध से आती हैtan(x)' = 1 + tan(x)^2।

तो, व्युत्पन्न tan(x)^jहै

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

तो, योगदानकर्ताओं tan(x)^jमें iवें व्युत्पन्न हैं tan(x)^(j-1)और tan(x)^(j+1)में (i-1)सेंट व्युत्पन्न, गुणांक के साथ प्रत्येक अपनी शक्ति के बराबर।

— XNOR
स्रोत

3

जेली , 12 11 बाइट्स

Ṛ+\;S
ḂÇ⁸¡Ḣ

जैसा पीटर टेलर के CJam जवाब , इस गणना करता है n के वें अवधि यूलर अनुक्रम नीचे हो रहा है / यदि n अजीब और विशेष मामलों है यहां तक कि एन के रूप में 0 ।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

ḂÇ⁸¡Ḣ  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.

— डेनिस
स्रोत

3

ऋषि, 26 बाइट्स

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

गणित-उन्मुख भाषाओं में अन्य समाधानों की तरह, यह फ़ंक्शन nवें व्युत्पन्न की गणना करता है tan(x)और इसका मूल्यांकन करता है x = 0।

इसे ऑनलाइन आज़माएं

— मै जाऊं
स्रोत

2

जे, 15 13 बाइट्स

इसमें बिलिन भी है t:जो घातीय जनन क्रिया के n ^वें गुणांक की गणना करता है टैन (एक्स) ।

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

करने के लिए धन्यवाद @ लीक ननJ श्रृंखला में टेलर श्रृंखला के क्रियाविशेषणों की याद दिलाने जिसने 2 बाइट्स बचाए।

15 बाइट्स के लिए वैकल्पिक ।

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

एक और तरीका है एन ^वें व्युत्पन्न टैन की गणना करना (x) और एक्स = 0 पर इसका मूल्यांकन करें ।

नोट: जे में , व्युत्पन्न फ़ंक्शन द्वारा उपयोग की जाने वाली मेमोरी की मात्राd. एन के रूप में जल्दी से बढ़ती है पास 10 के ।

प्रयोग

   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

व्याख्या

(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

— मील की दूरी पर
स्रोत

2

जूलिया, 39 37 बाइट्स

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

डेनिस की बदौलत 2 बाइट्स बचाए।

कम से कम जूलिया समाधान नहीं है (डेनिस का समाधान देखें), लेकिन यह एक शुद्ध रूप से व्युत्पन्न तर्क का उपयोग करके किया जाता है ... मैट्रिस के रूप में।

असल में, यह इस तथ्य का उपयोग करता है कि टैन (एक्स) का व्युत्पन्न 1 + टैन (एक्स) ^ 2 है। इसलिए टैन (x) की किसी भी शक्ति के व्युत्पन्न के बाद से, tan (x) ^ k, k टैन (x) ^ (k-1) टैन (x) '= k टैन (x) ^ (k-1) कहते हैं। + k tan (x) ^ (k + 1), हम विस्तार को उत्पन्न करने के लिए उचित मानों के साथ एक मैट्रिक्स पर एक सरल मैट्रिक्स पावर का उपयोग कर सकते हैं, दूसरी पंक्ति या स्तंभ (निर्माण पर निर्भर करता है) के साथ tan (x) का डेरिवेटिव पकड़ते हैं। ) अपने आप।

इसलिए हमें केवल परिणामी अभिव्यक्ति में स्थिरांक खोजने की आवश्यकता है, और इसी पंक्ति या स्तंभ में पहला मान है।

— ग्लेन हे
स्रोत

!n=(spdiagm((0:n,1:n+1),(1,-1))^n)[2]कार्य करना चाहिए।

— डेनिस

@ डेनिस - अच्छी पकड़। एहसास नहीं था spdiagmकि निर्माण की शैली की अनुमति होगी - इसके साथ की कोशिश की diagm, लेकिन निश्चित रूप से यह काम नहीं किया।

— ग्लेन ओ

2

जावास्क्रिप्ट (ईएस 6), 127 45 बाइट्स

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

@ Xnor के समाधान का पोर्ट।

— नील
स्रोत

0

हास्केल, 95 93 बाइट्स

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

यह मूल रूप से कुछ मामूली अनुकूलन के साथ सामान्य सूत्र का कार्यान्वयन है।

— flawr
स्रोत

0

MATLAB प्रतीकात्मक टूलबॉक्स के साथ, 84 बाइट्स

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

उदाहरण चलता है:

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

— लुइस मेंडो
स्रोत

0

हास्केल (बहुत सारे बाइट्स)

सूची और रेमंड मंज़ोनी के परिणामों पर केवल संचालन का उपयोग करना :

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

दुर्भाग्य से, यह मामूली मूल्यों के लिए अधिक है n, क्योंकि यह Intमूल्यों का उपयोग करता है। मैं Integerमानों का उपयोग करके समस्या को ठीक करने का प्रयास करूंगा । तब तक, सुझावों का स्वागत है।

— रोड्रिगो डी अजेवेडो
स्रोत

0

Axiom, 46 बाइट्स

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

परीक्षण और परिणामों के लिए कोड

(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

— RosLuP
स्रोत

गोल्फ सीक्वेंस जिसका एक्सपोनेंशियल जेनरेटिंग फंक्शन स्पर्शरेखा है

कार्य

परीक्षण के मामलों

उदाहरण कार्यान्वयन

संदर्भ

CJam ( 33 32 27 26 23 20 बाइट्स)

विच्छेदन

विच्छेदन

विच्छेदन

जूलिया, 40 38 32 बाइट्स

पृष्ठभूमि

पायथन, 57 बाइट्स

गणितज्ञ, 20 बाइट्स

प्रयोग

हास्केल, 48 बाइट्स

जेली , 12 11 बाइट्स

यह काम किस प्रकार करता है

ऋषि, 26 बाइट्स

जे, 15 13 बाइट्स

प्रयोग

व्याख्या

जूलिया, 39 37 बाइट्स

जावास्क्रिप्ट (ईएस 6), 127 45 बाइट्स

हास्केल, 95 93 बाइट्स

MATLAB प्रतीकात्मक टूलबॉक्स के साथ, 84 बाइट्स

Axiom, 46 बाइट्स