Polynomialception

Question

f,gपूर्णांकों पर मनमानी डिग्री के दो बहुपदों को देखते हुए , आपके कार्यक्रम / फ़ंक्शन को दूसरे बहुपद में पहले बहुपद का मूल्यांकन करना चाहिए। f(g(x))( दो बहुपद की रचना उर्फ (fog)(x))

विवरण

बिल बनाने की अनुमति है। आप इनपुट / आउटपुट के रूप में किसी भी उचित प्रारूपण को मान सकते हैं, लेकिन इनपुट और आउटपुट प्रारूप को मेल खाना चाहिए। जैसे स्ट्रिंग के रूप में स्वरूपण

x^2+3x+5

या गुणांक की सूची के रूप में:

[1,3,5] or alternatively [5,3,1]

इसके अलावा इनपुट बहुपद को पूरी तरह से विस्तारित माना जा सकता है, और आउटपुट भी पूरी तरह से विस्तारित होने की उम्मीद है।

उदाहरण

A(x) = x^2 + 3x + 5, B(y) = y+1
A(B(y)) = (y+1)^2 + 3(y+1) + 5 = y^2 + 5y + 9

A(x) = x^6 + x^2 + 1, B(y) = y^2 - y
A(B(y))= y^12 - 6y^11 + 15y^10 - 20y^9 + 15y^8 - 6y^7 + y^6 + y^4 - 2 y^3 + y^2 + 1

A(x) = 24x^3 - 144x^2 + 288x - 192, B(y) = y + 2
A(B(y)) = 24y^3

A(x) = 3x^4 - 36x^3 + 138x^2 - 180x + 27, B(y) = 2y + 3
A(B(y)) = 48y^4 - 96y^2

Comments

बिल्डिंस के बारे में क्या?

— माल्टसेन

@Maltysen "विवरण: बिल की अनुमति है। (...)" : D

— त्रुट

मुझे लगता है कि "कोई भी उचित प्रारूप" थोड़ा लंबा हो सकता है। यदि बहुपद का मूल्यांकन करने वाले एक फ़ंक्शन की अनुमति है, तो रचना फ़ंक्शन (.)हास्केल में एक उत्तर है। आप शायद गुणांक की सूची के कुछ प्रतिनिधित्व का मतलब है।

— xnor

शीर्षक! मुझे बस मिल गया :-D

— लुइस मेंडो

@LuisMendo त्वरित विचारक = पी

— त्रुटी २४'१६

Answer 1

हास्केल, 86 72 बाइट्स

u!c=foldr1((.u).zipWith(+).(++[0,0..])).map c
o g=(0:)!((<$>g).(*))!pure

को परिभाषित करता है एक समारोह oऐसा है कि o g fरचना च ∘ जी गणना करता है। पॉलीओनियम्स को निरंतर अवधि में शुरू होने वाले गुणांक की एक गैर-रिक्त सूची द्वारा दर्शाया जाता है।

डेमो

*Main> o [1,1] [5,3,1]
[9,5,1]
*Main> o [0,-1,1] [1,0,1,0,0,0,1]
[1,0,1,-2,1,0,1,-6,15,-20,15,-6,1]
*Main> o [2,1] [-192,288,-144,24]
[0,0,0,24]
*Main> o [3,2] [27,-180,138,-36,3]
[0,0,-96,0,48]

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

कोई बहुपद-संबंधी भवन या पुस्तकालय नहीं। इसी तरह की पुनरावृत्ति पर ध्यान दें

f (x) = a + f₁ (x) x ⇒ f (x) g (x) = ag (x) + f g (x) g (x) x,
f (x) = a + f₁ (x) x ⇒ f (g (x)) = a + f g (g (x)) g (x),

बहुपद गुणन और रचना के लिए, क्रमशः। वे दोनों रूप लेते हैं

f (x) = a + f₁ (x) x ⇒ W (f) (x) = C (a) (x) + U (W (f₁)) (x)।

ऑपरेटर !डब्ल्यू दिए गए यू और सी के लिए इस रूप की पुनरावृत्ति को हल करता है, zipWith(+).(++[0,0..])बहुपद जोड़ के लिए उपयोग करता है (यह मानते हुए कि दूसरा तर्क लंबा है - हमारे उद्देश्यों के लिए, यह हमेशा रहेगा)। फिर,

(0:)एक्स द्वारा एक बहुपद तर्क को गुणा करता है (एक शून्य गुणांक को तैयार करके);
(<$>g).(*)बहुपद द्वारा एक अदिश तर्क को गुणा करता है g;
(0:)!((<$>g).(*))बहुपद द्वारा बहुपद तर्क को गुणा करता है g;
pureएक स्थिर बहुपद (सिंगलटन सूची) के लिए एक स्केलर तर्क लिफ्ट करता है;
(0:)!((<$>g).(*))!pureबहुपद के साथ एक बहुपद तर्क देता है g।

Answer 2

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

Expand[#/.x->#2]&

उदाहरण का उपयोग:

In[17]:= Expand[#/.x->#2]& [27 - 180x + 138x^2 - 36x^3 + 3x^4, 3 + 2x]

              2       4
Out[17]= -96 x  + 48 x

Answer 3

टीआई-बेसिक 68k, 12 बाइट्स

a|x=b→f(a,b)

पहला उदाहरण के लिए उपयोग सीधा है, उदाहरण के लिए:

f(x^2+3x+5,y+1)

जो लौटता है

y^2+5y+9

Comments

ऐसा लगता है कि विभिन्न चर में इनपुट की आवश्यकता के लिए मुझे धोखा देना है। क्या इस जवाब के लिए यह मायने रखता है?

— feersum

ऐसा करने के लिए स्वतंत्र महसूस करें, मैंने स्पष्ट रूप से किसी भी उचित सुविधाजनक इनपुट प्रारूप की अनुमति दी है।

— दोष

अपनी टिप्पणी के संपादन के बारे में: हाँ यह मायने रखता है।

— दोष

मैं इस साइट के नियमों से बहुत परिचित नहीं हूँ। क्या →TI-BASIC में 1 बाइट होना सही है ?

— asmeurer

@asmeurer वास्तव में: TI-Basic इसी कैलकुलेटर पर इस्तेमाल एन्कोडिंग द्वारा बनाया गया है। यदि आप विवरण में रुचि रखते हैं, तो आप यहां मेटा पर पढ़ सकते हैं । टिक-बेसिक-देव पर टोकन की एक तालिका यहां पाई जा सकती है ।

— flawr

Answer 4

पायथन 2, 138 156 162 बाइट्स

इनपुट की उम्मीद है कि सबसे पहले छोटी शक्तियों के साथ पूर्णांक सूची होगी।

def c(a,b):
 g=lambda p,q:q>[]and q[0]+p*g(p,q[1:]);B=99**len(`a+b`);s=g(g(B,b),a);o=[]
 while s:o+=(s+B/2)%B-B/2,;s=(s-o[-1])/B
 return o

Ungolfed:

def c(a,b):
 B=sum(map(abs,a+b))**len(a+b)**2
 w=sum(B**i*x for i,x in enumerate(b))
 s=sum(w**i*x for i,x in enumerate(a))
 o=[]
 while s:o+=min(s%B,s%B-B,key=abs),; s=(s-o[-1])/B
 return o

इस गणना में, बहुपद गुणांक को एक बहुत बड़े आधार में एक संख्या के अंकों (जो नकारात्मक हो सकता है) के रूप में देखा जाता है। बहुपद के बाद इस प्रारूप में हैं, गुणा या जोड़ एक पूर्णांक ऑपरेशन है। जब तक आधार पर्याप्त रूप से बड़ा नहीं हो जाता, तब तक कोई भी वहन नहीं किया जाएगा जो पड़ोसी अंकों में फैल जाएगा।

-18 Bमें @xnor द्वारा सुझाए गए सुधार से बाध्य है ।

Comments

अच्छी विधि है। के लिए B, 10**len(`a+b`)पर्याप्त होगा ?

— 1

@xnor हो सकता है ... मुझे बताना मुश्किल है।

— feersum

+1 यह वास्तव में रचनात्मक समाधान है, और बड़े संकेतों का एक अच्छा उपयोग !!!

— दोष

@xnor अब मैं खुद को समझाने में कामयाब रहा हूं कि hte गुणांक लंबाई इनपुट लंबाई में रैखिक है :)

— feersum

Answer 5

पायथन + सिम्पी, 59 35 बाइट्स

from sympy import*
var('x')
compose

24 बाइट बंद करने के लिए @asmeurer को धन्यवाद!

परीक्षण चालन

>>> from sympy import*
>>> var('x')
x
>>> f = compose
>>> f(x**2 + 3*x + 5, x + 1)
x**2 + 5*x + 9

Comments

सिम्पी का एक compose()फंक्शन है।

— 16

जवाब कहां है? यह अब किसी भी कार्य को परिभाषित नहीं करता है या कुछ भी करता है ...

— feersum

@ Faersum ऐसा कभी नहीं हुआ। आपने अभी उस मेटा पोस्ट को संपादित किया है।

— मेगो

@ Faersum आपने अपने स्वयं के एजेंडे के लिए नीति को संशोधित करने के लिए एक स्वीकृत मेटा पोस्ट संपादित किया। यह ठीक नहीं है।

— मेगो

@ फ़ेर्सम हालांकि आपने सोचा होगा कि आपका शब्दांकन अस्पष्ट था, यह स्पष्ट रूप से बाकी समुदाय के लिए नहीं था। हमने सर्वसम्मति को स्वीकार कर लिया जो from module import*;functionएक वैध प्रस्तुतिकरण था। भले ही, यह एक अधिक हालिया नीति है, जो अनाम लैम्ब्डा के साथ आयात और सहायक कार्यों की अनुमति देता है।

— मेगो

Answer 6

ऋषि, 24 बाइट्स

lambda A,B:A(B).expand()

जैसा कि 6.9 6.9 (संस्करण जो http://sagecell.sagemath.org पर चलता है ), स्पष्ट तर्क असाइनमेंट ( f(2) rather than f(x=2)) के बिना फ़ंक्शन कॉल एक कष्टप्रद और अनैतिक संदेश STDERR पर मुद्रित होने का कारण बनता है। क्योंकि कोड गोल्फ में डिफ़ॉल्ट रूप से STDERR को अनदेखा किया जा सकता है, फिर भी यह मान्य है।

यह डेनिस के सिम्पी उत्तर के समान है क्योंकि ऋषि एक) पायथन पर बनाया गया है, और बी) मैक्सिमा का उपयोग करता है , जो एक कंप्यूटर बीजगणित प्रणाली है जो कई तरह से सिम्पी के समान है। हालांकि, ऋषि सिम्पी के साथ अजगर की तुलना में बहुत अधिक शक्तिशाली है, और इस तरह एक अलग भाषा है कि यह अपने स्वयं के उत्तर का गुण है।

सभी परीक्षण मामलों को ऑनलाइन सत्यापित करें

Answer 7

PARI / GP , 19 बाइट्स

(a,b)->subst(a,x,b)

जो आपको करने देता है

%(x^2+1,x^2+x-1)

लेना

% 2 = x ^ 4 + 2 * x ^ 3 - x ^ 2 - 2 * x + 2

Answer 8

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

@(f,g)collect(subs(f,'x',g))

यह एक अनाम फ़ंक्शन है। इसे कॉल करने के लिए इसे किसी वैरिएबल या यूज को असाइन करें ans। इनपुट प्रारूप के साथ तार हैं (रिक्त स्थान वैकल्पिक हैं)

x^2 + 3*x + 5

उदाहरण रन:

>> @(f,g)collect(subs(f,'x',g))
ans = 
    @(f,g)collect(subs(f,'x',g))
>> ans('3*x^4 - 36*x^3 + 138*x^2 - 180*x + 27','2*x + 3')
ans =
48*x^4 - 96*x^2

Answer 9

पायथन 2, 239 232 223 बाइट्स

r=range
e=reduce
a=lambda*l:map(lambda x,y:(x or 0)+(y or 0),*l)
m=lambda p,q:[sum((p+k*[0])[i]*(q+k*[0])[k-i]for i in r(k+1))for k in r(len(p+q)-1)]
o=lambda f,g:e(a,[e(m,[[c]]+[g]*k)for k,c in enumerate(f)])

एक 'उचित' कार्यान्वयन जो ठिकानों का दुरुपयोग नहीं करता है। पहले कम से कम महत्वपूर्ण गुणांक।

aबहुपद जोड़ है, mबहुपद गुणन है और oरचना है।

Comments

के m([c],e(m,[[1]]+[g]*k))रूप में ही नहीं है e(m,[[c]]+[g]*k)?

— नील

@ नील अच्छा कॉल, उस के साथ एक में दो स्क्वैश कर सकते हैं!

— orlp

a=lambda*l:map(lambda x,y:(x or 0)+(y or 0),*l)

— एंडर्स कासोर्ग

@AndersKaseorg राइट, मैंने इसे जोड़ा, धन्यवाद :)

— orlp

आपके बहुपत्नी जोड़ को सरल बनाना संभव हो सकता है, क्योंकि मुझे लगता है कि एक सूची हमेशा दूसरे की तुलना में लंबी होगी, इसलिए आपको ( or 0)उस संस्करण की आवश्यकता नहीं है ।

— नील

Answer 10

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

(f,g)=>f.map(n=>r=p.map((m,i)=>(g.map((n,j)=>p[j+=i]=m*n+(p[j]||0)),m*n+(r[i]||0)),p=[]),r=[],p=[1])&&r

स्वीकार करता है और रिटर्न एक सरणी एक के रूप में बहुआयामी पद = [एक ₀ , एक ₁ , एक ₂ , ...] है कि एक का प्रतिनिधित्व करता है ₀ + एक ₁ * x + एक ₂ * x ² ...

संपादित करें: पुनरावर्ती से पुनरावृत्ति बहुपद गुणन में स्विच करके 47 बाइट्स सहेजे गए, जिसने मुझे दो mapकॉल मर्ज करने की अनुमति दी ।

स्पष्टीकरण: आर परिणाम है, जो शून्य से शुरू होती है, एक खाली सरणी का प्रतिनिधित्व करती है, और है पी है जी ^एच , जो एक पर शुरू होता है। पी को बदले में प्रत्येक एफ _एच से गुणा किया जाता है , और परिणाम आर में जमा होता है । p को उसी समय g से गुणा किया जाता है ।

(f,g)=>f.map(n=>            Loop through each term of f (n = f[h])
 r=p.map((m,i)=>(           Loop through each term of p (m = p[i])
  g.map((n,j)=>             Loop though each term of g (n = g[j])
   p[j+=i]=m*n+(p[j]||0)),  Accumulate p*g in p
  m*n+(r[i]||0)),           Meanwhile add p[i]*f[h] to r[i]
  p=[]),                    Reset p to 0 each loop to calculate p*g
 r=[],                      Initialise r to 0
 p=[1]                      Initialise p to 1
)&&r                        Return the result

Answer 11

पायथ, 51 34 बाइट्स

AQsM.t*LVG.usM.t.e+*]0k*LbHN0tG]1Z

टेस्ट सूट ।

Comments

जब अजगर प्रकोष्ठों से बाहर निकलता है

— डाउनप्रैप_नेशन

@downrep_nation अब और नहीं :)

— लीकी नून

Answer 12

रूबी 2.4 + बहुपद , 41 + 12 = 53 बाइट्स

ध्वज का उपयोग करता है -rpolynomial। इनपुट दो Polynomialऑब्जेक्ट हैं।

यदि कोई मुझे वेनिला रूबी (कोई बहुपद बाहरी पुस्तकालय) में नहीं छोड़ता है, तो मैं बहुत प्रभावित होऊंगा।

->a,b{i=-1;a.coefs.map{|c|c*b**i+=1}.sum}