โปรแกรมสองฟังก์ชันf,gของคุณควรประเมินพหุนามแรกในพหุนามที่สอง f(g(x))(aka องค์ประกอบ (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

Haskell, 86 72 ไบต์

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

กำหนดฟังก์ชั่นoที่o g fคำนวณองค์ประกอบ f ∘ g พหุนามมีการแสดงรายการค่าสัมประสิทธิ์ที่ไม่ว่างเปล่าซึ่งเริ่มต้นที่คำคงที่

การสาธิต

*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₁ (x) g (x) x,
f (x) = a + f₁ (x) x ⇒ f (g (x)) = a + f₁ (g (x)) g (x),

สำหรับการคูณพหุนามและองค์ประกอบตามลำดับ พวกเขาทั้งสองใช้แบบฟอร์ม

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

โอเปอเรเตอร์!แก้ปัญหาการเกิดซ้ำของแบบฟอร์มนี้สำหรับ W ที่ให้ U และ C โดยใช้zipWith(+).(++[0,0..])สำหรับการบวกพหุนาม (สมมติว่าอาร์กิวเมนต์ที่สองยาวกว่า - สำหรับจุดประสงค์ของเรา จากนั้น

(0:)คูณอาร์กิวเมนต์พหุนามด้วย x (โดยการเติมสัมประสิทธิ์เป็นศูนย์);
(<$>g).(*)คูณอาร์กิวเมนต์เกลาโดยพหุนามg;
(0:)!((<$>g).(*))คูณอาร์กิวเมนต์พหุนามโดยพหุนามg;
pureยกอาร์กิวเมนต์สเกลาร์เป็นพหุนามคงที่ (รายการเดี่ยว); ประกอบด้วยอาร์กิวเมนต์พหุนามกับพหุนาม
(0:)!((<$>g).(*))!pureg

Mathematica ขนาด 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

TI-Basic 68k, 12 ไบต์

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

การใช้ตรงไปตรงมาเช่นสำหรับตัวอย่างแรก:

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

ซึ่งผลตอบแทน

y^2+5y+9

Python 2, 138 156 162 bytes

อินพุตที่คาดว่าจะเป็นรายการจำนวนเต็มที่มีพลังน้อยที่สุดก่อน

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

Python + SymPy, 59 35 ไบต์

from sympy import*
var('x')
compose

ขอบคุณ @asmeurer สำหรับการเล่นกอล์ฟ 24 ไบต์!

ทดสอบการทำงาน

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

Sage 24 ไบต์

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

ตั้งแต่ Sage 6.9 (รุ่นที่ทำงานบนhttp://sagecell.sagemath.org ) การเรียกใช้ฟังก์ชันโดยไม่มีการกำหนดอาร์กิวเมนต์ที่ชัดเจน ( f(2) rather than f(x=2)) ทำให้ข้อความที่น่ารำคาญและไม่ช่วยเหลือจะถูกพิมพ์ไปยัง STDERR เนื่องจาก STDERR สามารถละเว้นได้ตามค่าเริ่มต้นในการตีกอล์ฟจึงยังคงใช้ได้

นี่คล้ายกับคำตอบ SymPy ของเดนนิสเพราะ Sage เป็น a) สร้างบน Python และ b) ใช้Maximaระบบพีชคณิตคอมพิวเตอร์คล้ายกับ SymPy ในหลาย ๆ ทาง อย่างไรก็ตาม Sage นั้นมีประสิทธิภาพมากกว่า Python กับ SymPy และเป็นภาษาที่แตกต่างกันพอสมควรที่จะได้คำตอบของมัน

ตรวจสอบกรณีทดสอบทั้งหมดออนไลน์

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

MATLAB พร้อม Symbolic Toolbox ขนาด 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

Python 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เป็นองค์ประกอบ

JavaScript (ES6), 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

ยอมรับและส่งคืนพหุนามเป็นอาร์เรย์ a = [a ₀ , a ₁ , a , ₂ , ... ] ที่แทน₀ + a ₁ * x + a ₂ * x ² ...

แก้ไข: บันทึก 47 bytes โดยเปลี่ยนจากการเรียกซ้ำแบบวนซ้ำเป็นพหุนามซ้ำแล้วจึงอนุญาตให้ฉันรวมสองmapสาย

คำอธิบาย: rคือผลลัพธ์ซึ่งเริ่มต้นที่ศูนย์แสดงด้วยอาร์เรย์ว่างและpคือg ^hซึ่งเริ่มต้นที่หนึ่ง Pคูณแต่ละฉ_{ชั่วโมง}ในการเปิดและผลที่ได้สะสมในR 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

Pyth, 51 34 ไบต์

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

ชุดทดสอบ

Ruby 2.4 + พหุนาม , 41 + 12 = 53 ไบต์

-rpolynomialธงใช้ อินพุตเป็นสองPolynomialวัตถุ

หากมีใครชนะฉันใน Vanilla Ruby (ไม่มีห้องสมุดภายนอกพหุนาม) ฉันจะต้องประทับใจมาก

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