एक तर्कसंगत उत्पादक फ़ंक्शन के गुणांक का पता लगाएं

12

यदि हम संख्याओं के अनुक्रम को एक शक्ति श्रृंखला के गुणांक के रूप में लिखते हैं, तो उस क्रम की शक्ति श्रृंखला को (साधारण) जनन क्रिया (या Gf) कहा जाता है। यदि हमारे पास F(x)पूर्णांकों के कुछ फ़ंक्शन और श्रृंखला हैं, a(n)तो:

a(0) + a(1)x + a(2)x^2 + a(3)x^3 + a(4)x^4 + ... = F(x)

तब F(x)का जनरेटिंग फंक्शन है a। उदाहरण के लिए, ज्यामितीय श्रृंखला हमें बताती है कि:

1 + x + x^2 + x^3 + x^4 + ... = 1/(1-x)

तो जनरेटिंग फंक्शन 1, 1, 1, ...है 1/(1-x)। यदि हम उपरोक्त समीकरण के दोनों किनारों को अलग-अलग करते हैं और xहम निम्नलिखित समानता प्राप्त करते हैं:

x + 2x^2 + 3x^3 + 4x^4 + ... = x/(1-x)^2

तो जनरेटिंग फंक्शन 1, 2, 3, ...है x/(1-x)^2। निर्माण कार्य एक बहुत शक्तिशाली उपकरण है, और आप उनके साथ कई उपयोगी चीजें कर सकते हैं। एक संक्षिप्त परिचय यहां पाया जा सकता है , लेकिन वास्तव में पूरी तरह से स्पष्टीकरण के लिए अद्भुत पुस्तक जेनरेटफंक्शनोलॉजी है।

इस चुनौती में आप एक तर्कसंगत कार्य (पूर्णांक गुणांक वाले दो बहुपद के भागफल) को पूर्णांक गुणांक के दो सरणियों के रूप में इनपुट के रूप में लेंगे , पहले अंश फिर भाजक। उदाहरण के लिए फ़ंक्शन f(x) = x / (1 - x - x^2)को [0, 1], [1, -1, -1]इनपुट के रूप में एन्कोड किया जाएगा ।

इस इनपुट को देखते हुए, आपके प्रोग्राम को विद्युत श्रृंखला के गुणांक को प्रिंट करना होगा जो कि जनरेटिंग फंक्शन, एक प्रति पंक्ति, बराबर गुणांक x, फिर x^2, आदि पर शुरू होता है ।

उदाहरण:

[1], [1, -1] -> 1, 1, 1, 1, 1, 1, 1, ...
[1], [2, -2] -> 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, ...
[0, 1], [1, -2, 1] -> 1, 2, 3, 4, 5, 6, 7, 8, ...
[0, 1], [1, -1, -1] -> 1, 1, 2, 3, 5, 8, 13, 21, 34, ...
[1], [1, -2] -> 1, 2, 4, 8, 16, 32, 64, 128, ...
[0, 1, 1], [1, -3, 3, -1] -> 1, 4, 9, 16, 25, 36, ...
code-golf  math  integer  polynomials  code-golf  math  abstract-algebra  restricted-time  code-golf  math  primes  code-golf  math  number  arithmetic  code-golf  quine  code-golf  number  sequence  code-golf  string  number  code-golf  array-manipulation  code-golf  number  code-golf  string  code-golf  arithmetic  code-golf  string  array-manipulation  rubiks-cube  code-golf  math  number  code-golf  tips  bash  code-golf  ascii-art  music  code-golf  arithmetic  code-golf  math  number  arithmetic  integer  code-golf  number  array-manipulation  code-golf  geometry  grid  set-partitions  code-golf  math  number  code-golf  combinatorics  code-golf  regular-expression  code-golf  permutations  code-golf  ascii-art  code-golf  number  array-manipulation  matrix  code-golf  kolmogorov-complexity  compile-time  cops-and-robbers  polyglot  cops-and-robbers  polyglot  code-golf  string  code-golf  string  ascii-art  matrix  animation  code-golf  ascii-art  code-golf  string  balanced-string  code-golf  integer  integer-partitions  expression-building 
— orlp
स्रोत
बकवास, मेरी भाषा इस क्रम के लिए बनी है, लेकिन मैं वास्तव में बहुआयामी सरणी इनपुट नहीं कर सकता :(
— स्टीफन
2
मैं वास्तव में सिर्फ गणितीय रूप से इस कल्पना के लिए पर्याप्त नहीं हूं, कोई भी मौका जो आप आम लोगों के लिए आम आदमी के स्पष्टीकरण के बारे में बता सकें?
— स्कंददेव
2
— ट्राइकोप्लाक्स
1
@trichoplax जो हमेशा अंश को 1 होने के लिए मजबूर करता है, जो समान नहीं है। उदाहरण के लिए यह मेरे अंतिम उदाहरण, वर्गों को व्यक्त नहीं कर सकता है।
— orlp
1
इसे फिर से बनाने का एक वैकल्पिक तरीका यह है कि यह एक सामान्य रेखीय पुनरावृत्ति का मूल्यांकन करता है। इस तरह यह इस सवाल को सामान्य करता है , और भविष्य के पुनरावृत्ति के सवालों के लिए एक कठिन लक्ष्य के रूप में काम कर सकता है।
— पीटर टेलर

जवाबों:

7

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

z=0:z
(a:b)%y@(c:d)=a/c:zipWith(-)(b++z)(map(a/c*)d++z)%y
_%_=z

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

एक ऑपरेटर को परिभाषित करता है जो %गुणांकों की एक अनंत आलसी सूची लौटाता है। सूची शून्य-अनुक्रमित है, इसलिए निरंतर गुणांक शामिल है।

— एंडर्स कसीर्ग
स्रोत
3

गणितज्ञ, ६४ 83 90 बाइट्स

Do[Echo@Limit[D[#/#2/i!&@@Fold[x#+#2&]/@#,{x,i}],x->0],{i,∞}‌​]&

@Ngenisis और @ जेनी_मैथी को धन्यवाद!

इनपुट को दो सूचियों के रूप में लें।

Alt+.परिणाम देखने के लिए निष्पादन को समाप्त करने की आवश्यकता है। तेज आउटपुट के कारण फ्रंटेंड क्रैश हो सकता है।

83 बाइट्स संस्करण (@ जेनी_मैथी):

i=1;v=Tr[#*x^Range@Length@#]&;While[1<2,Echo@Limit[D[v@#/v@#2/i!,{x,i}],x->0];i++]&
— कीउ गण
स्रोत
83 बाइट्स: i = 1; v = Tr [# * x ^ रेंज @ लंबाई @ #] &; जबकि [1 <2, इको @ लिमिट [डी [वी # # / वी @ # 2 / आई !, {x, i}], x -> 0]; i ++] &
— J42161217
@ जेनी_मथी को परेशान करने के लिए क्षमा करें। मुझे पता है कि आपकी पहली टिप्पणी में कुछ रद्दी अदृश्य यूनिकोड वर्ण हैं। एक बार साफ हो जाने के बाद, कोड ठीक है।
— कीउ गण
3
64बाइट: Do[Echo@Limit[D[#/#2/i!&@@Fold[x#+#2&]/@#,{x,i}],x->0],{i,∞}]&। यह मानता है कि इनपुट दो सूचियों की सूची है और गुणांक डिग्री के क्रम में हैं। केवल निर्मित में मुझे पता है कि क्या vकरना हैInternal`FromCoefficientList
— नाइजनिसिस
क्या यह बार-बार चलने से काम चल जाता है? मुझे लगता है कि अतिरिक्त कोष्ठकों के एक जोड़े को मेमने के iअंदर रखना आवश्यक हो सकता है । (दूसरी तरफ, मुझे वास्तव में यकीन नहीं है कि क्या बार-बार दौड़ने की क्षमता प्रासंगिक है जब लक्ष्य एक अनंत सूची को प्रिंट करना है ... क्या इस पर एक मेटा सहमति बनी है?)
— जूलियन वुल्फ
@ngenisis: आप किस संस्करण का उपयोग कर रहे हैं? V10.0 पर, आपका समाधान मुझे देता है Iterator {i,∞} does not have appropriate bounds।
— जूलियन वुल्फ
1

CJam (22 बाइट्स)

{\{(W$(@\/_pW*f*.+1}g}

ऑनलाइन डेमो । ध्यान दें कि मौजूदा उत्तरों में से कई में, यह आउटपुट में 0 वां गुणांक शामिल करता है।

विच्छेदन

{           e# Define a block which takes numerator N and denominator D as arguments
  \         e# Flip to put D at the bottom, since that won't change
  {         e# Infinite loop:
    (       e#   Pop the first element of (the modified) N
    W$(     e#   Copy D and pop its first element
            e#   Stack: D N[1:] N[0] D[1:] D[0]
    @\/     e#   Bring N[0] to top, flip, divide
            e#   Stack: D N[1:] D[1:] N[0]/D[0]
    _p      e#   Print a copy
    W*f*.+  e#   Multiply by -1, multiply all, pointwise add
            e#   Stack: D N[1:]-(N[0]/D[0])*D[1:]
  1}g
}
— पीटर टेलर
स्रोत
0

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

f=x^Range@Length@#.#&;For[n=1,8>3,Print@SeriesCoefficient[f@#/f@#2,{x,0,n++}]]&

इनपुट को दो अलग-अलग सूचियों (अंश गुणांक, हर गुणांक) के रूप में लेता है। यदि गुणांक के सूचियों के बजाय इनपुट को सीधे बहुपद के एक अंश के रूप में लिया जा सकता है, तो इसे काफी छोटा किया जा सकता है।

ऐसा लगता है कि Dov11 में अनंत सीमा के साथ काम कर सकता है। मैं इसका स्थानीय रूप से परीक्षण नहीं कर सकता, लेकिन, अगर ऐसा है, तो इस समाधान को 75 बाइट्स तक छोटा किया जा सकता है :

f=x^Range@Length@#.#&;Do[Print@SeriesCoefficient[f@#/f@#2,{x,0,n}],{n,∞}]&
— जूलियन वुल्फ
स्रोत
अंतिम परीक्षण मामला 0. से शुरू नहीं होता है
— J42161217
@ जेनी_मैथी: शूट, हेड्स अप के लिए धन्यवाद। लगता है कि परीक्षण के मामले ज़ीरोथ के पहले से शुरू होने की उम्मीद है ... बहुत यकीन है कि यह मुझे कुछ बाइट्स को बचाने देना चाहिए।
— जूलियन वुल्फ
@ जेनी_मैथी: मुझे लगता है कि परीक्षण के मामले विजयी हो सकते हैं। 1 nसे शुरू होकर 0, यह आपके समाधान के समान परिणाम देता है; दोनों विफल, हालांकि, दूसरे से अंतिम परीक्षण के मामले में, जो यह समाधान n0. से शुरू होने पर गुजरता है
— जूलियन वुल्फ
0

पायथ , 23 बाइट्स

JE#
KchQhJ=t-M.t,Q*LKJ0

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

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

                       Q = eval(input())
JE                     J = eval(input())
  #                    infinite loop:
 chQhJ                   Q[0]/J[0]
K                        assign that to K (and print it, because of the preceding newline)
              *LKJ       K times every element of J
            ,Q           [Q, that]
          .t      0      transpose, padding with 0s
        -M               subtract each pair
       t                 remove the first element
      =                  assign that back to Q
— एंडर्स कसीर्ग
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.