Cho hai đa thức bậc f,gtùy ý trên các số nguyên, chương trình / hàm của bạn sẽ đánh giá đa thức thứ nhất trong đa thức thứ hai. f(g(x))(còn gọi là thành phần (fog)(x) của hai đa thức)

Chi tiết

Nội tích được cho phép. Bạn có thể giả sử bất kỳ định dạng hợp lý nào là đầu vào / đầu ra, nhưng định dạng đầu vào và đầu ra phải khớp. Ví dụ: định dạng dưới dạng chuỗi

x^2+3x+5

hoặc như danh sách các hệ số:

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

Hơn nữa, các đa thức đầu vào có thể được coi là được mở rộng hoàn toàn, và các đầu ra cũng được dự kiến ​​sẽ được mở rộng hoàn toàn.

Ví dụ

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 byte

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

Xác định hàm osao cho o g ftính toán thành phần f ∘ g. Đa thức được biểu diễn bằng một danh sách các hệ số không trống bắt đầu từ số hạng không đổi.

Bản giới thiệu

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

Làm thế nào nó hoạt động

Không có nội dung hoặc thư viện liên quan đến đa thức. Quan sát các đợt tái phát tương tự

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

cho phép nhân đa thức và thành phần, tương ứng. Cả hai đều có hình thức

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

Toán tử !giải quyết sự lặp lại của biểu mẫu này đối với W đã cho U và C, sử dụng zipWith(+).(++[0,0..])cho phép cộng đa thức (giả sử đối số thứ hai dài hơn đối với mục đích của chúng tôi, nó sẽ luôn như vậy). Sau đó,

(0:)nhân một đối số đa thức với x (bằng cách đặt trước một hệ số 0);
(<$>g).(*)nhân một đối số vô hướng bằng đa thức g;
(0:)!((<$>g).(*))nhân một đối số đa thức bằng đa thức g;
purenâng một đối số vô hướng thành một đa thức không đổi (danh sách singleton);
(0:)!((<$>g).(*))!puresoạn thảo một đối số đa thức với đa thức g.

Toán học, 17 byte

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

Ví dụ sử dụng:

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 byte

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

Việc sử dụng rất đơn giản, ví dụ như ví dụ đầu tiên:

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

Trả về

y^2+5y+9

Python 2, 138 156 162 byte

Đầu vào dự kiến ​​là danh sách số nguyên với quyền hạn nhỏ nhất trước tiên.

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

Ung dung:

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

Trong tính toán này, các hệ số đa thức được xem là chữ số (có thể âm) của một số trong một cơ sở rất lớn. Sau khi đa thức ở định dạng này, phép nhân hoặc phép cộng là một phép toán số nguyên đơn. Miễn là cơ sở đủ lớn, sẽ không có bất kỳ vật mang nào tràn ra các chữ số lân cận.

-18 từ cải thiện ràng buộc Btheo đề xuất của @xnor.

Python + SymPy, 59 35 byte

from sympy import*
var('x')
compose

Cảm ơn @asmeker đã chơi golf 24 byte!

Chạy thử nghiệm

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

Sage, 24 byte

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

Kể từ Sage 6.9 (phiên bản chạy trên http://sagecell.sagemath.org ), các lệnh gọi hàm không có phân công đối số rõ ràng ( f(2) rather than f(x=2)) gây ra một thông báo khó chịu và không có ích được in ra STDERR. Vì STDERR có thể bị bỏ qua theo mặc định trong mã golf, nên điều này vẫn hợp lệ.

Điều này rất giống với câu trả lời SymPy của Dennis vì Sage là một) được xây dựng trên Python và b) sử dụng Maxima , một hệ thống đại số máy tính rất giống với SymPy theo nhiều cách. Tuy nhiên, Sage mạnh hơn nhiều so với Python với SymPy và do đó, đây là một ngôn ngữ đủ khác để nó xứng đáng với câu trả lời của chính nó.

Xác nhận tất cả các trường hợp kiểm tra trực tuyến

PARI / GP , 19 byte

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

cho phép bạn làm

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

để có được

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

MATLAB với Hộp công cụ tượng trưng, ​​28 byte

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

Đây là một chức năng ẩn danh. Để gọi nó gán nó cho một biến hoặc sử dụng ans. Đầu vào là các chuỗi có định dạng (khoảng trắng là tùy chọn)

x^2 + 3*x + 5

Chạy ví dụ:

>> @(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 byte

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

Việc thực hiện 'đúng' không lạm dụng căn cứ. Ít nhất hệ số đáng kể đầu tiên.

alà mphép cộng đa thức, phép nhân đa thức và olà thành phần.

JavaScript (ES6), 150 103 byte

(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

Chấp nhận và trả về đa thức dưới dạng một mảng a = [a ₀ , a ₁ , a ₂ , ...] đại diện cho ₀ + a ₁ * x + a ₂ * x ² ...

Chỉnh sửa: Đã lưu 47 byte bằng cách chuyển từ phép nhân đệ quy sang phép nhân đa thức lặp, sau đó cho phép tôi hợp nhất hai mapcuộc gọi.

Giải thích: r là kết quả, bắt đầu từ 0, được biểu thị bằng một mảng trống và p là g ^h , bắt đầu từ một. p được nhân với mỗi f _h lần lượt và kết quả được tích lũy trong r . p cũng được nhân với g cùng một lúc.

(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

Bình thường, 51 34 byte

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

Bộ thử nghiệm .

Đa thức Ruby 2.4 + , 41 + 12 = 53 byte

Sử dụng cờ -rpolynomial. Đầu vào là hai Polynomialđối tượng.

Nếu ai đó vượt qua tôi trong vanilla Ruby (không có thư viện bên ngoài đa thức), tôi sẽ rất ấn tượng.

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