Bei zwei Polynomen f,gwillkürlichen Grades über den ganzen Zahlen sollte Ihr Programm / Ihre Funktion das erste Polynom im zweiten Polynom auswerten. f(g(x))(auch bekannt als die Zusammensetzung (fog)(x) der beiden Polynome)

Einzelheiten

Builtins sind erlaubt. Sie können jede sinnvolle Formatierung als Eingabe / Ausgabe annehmen, aber das Eingabe- und Ausgabeformat sollte übereinstimmen. ZB Formatierung als String

x^2+3x+5

oder als Koeffizientenliste:

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

Weiterhin kann angenommen werden, dass die Eingabepolynome vollständig expandiert sind, und es wird auch erwartet, dass die Ausgaben vollständig expandiert sind.

Beispiele

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 Bytes

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

Definiert eine Funktion o, o g fdie die Komposition f ∘ g berechnet. Polynome werden durch eine nicht leere Liste von Koeffizienten dargestellt, die mit dem konstanten Term beginnen.

Demo

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

Wie es funktioniert

Keine polynombezogenen Buildins oder Bibliotheken. Beachten Sie die ähnlichen Rezidive

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 & sub1; (g (x)) g (x),

für die Polynommultiplikation bzw. -zusammensetzung. Sie nehmen beide die Form an

f (x) = a + f & sub1; (x) x ⇒ W (f) (x) = C (a) (x) + U (W (f & sub1;)) (x).

Der Operator !löst eine Wiederholung dieser Form für W mit U und C unter Verwendung der zipWith(+).(++[0,0..])Polynomaddition (vorausgesetzt, das zweite Argument ist länger - für unsere Zwecke wird es immer länger sein). Dann,

(0:)multipliziert ein Polynomargument mit x (indem ein Nullkoeffizient vorangestellt wird);
(<$>g).(*)multipliziert ein skalares Argument mit dem Polynom g;
(0:)!((<$>g).(*))multipliziert ein Polynomargument mit dem Polynom g;
purehebt ein skalares Argument auf ein konstantes Polynom (Singleton-Liste);
(0:)!((<$>g).(*))!puresetzt mit dem Polynom ein Polynomargument zusammen g.

Mathematica, 17 Bytes

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

Anwendungsbeispiel:

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 Bytes

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

Die Verwendung ist unkompliziert, zB für das erste Beispiel:

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

Welches kehrt zurück

y^2+5y+9

Python 2, 138 156 162 Bytes

Es wird erwartet, dass die Eingaben Ganzzahllisten mit den kleinsten Potenzen zuerst sind.

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

Bei dieser Berechnung werden die Polynomkoeffizienten als Ziffern (die negativ sein können) einer Zahl auf einer sehr großen Basis betrachtet. Nachdem Polynome in diesem Format vorliegen, ist die Multiplikation oder Addition eine einzelne Ganzzahloperation. Solange die Basis ausreichend groß ist, werden keine Überträge in benachbarte Ziffern übertragen.

-18 von Verbesserung gebunden an, Bwie von @xnor vorgeschlagen.

Python + SymPy, 59-35 Byte

from sympy import*
var('x')
compose

Danke an @asmeurer für das Golfen mit 24 Bytes!

Testlauf

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

Salbei, 24 Bytes

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

Ab Sage 6.9 (die Version, die unter http://sagecell.sagemath.org ausgeführt wird ) führen Funktionsaufrufe ohne explizite Argumentzuweisung ( f(2) rather than f(x=2)) dazu, dass eine nervige und nicht hilfreiche Nachricht an STDERR ausgegeben wird. Da STDERR im Codegolf standardmäßig ignoriert werden kann, ist dies weiterhin gültig.

Dies ist Dennis 'SymPy-Antwort sehr ähnlich, da Sage a) auf Python basiert und b) Maxima verwendet , ein Computeralgebrasystem, das SymPy in vielerlei Hinsicht sehr ähnlich ist. Allerdings ist Sage mit SymPy viel leistungsfähiger als Python und daher eine Sprache, die eine eigene Antwort verdient.

Überprüfen Sie alle Testfälle online

PARI / GP , 19 Bytes

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

was können Sie tun

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

bekommen

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

MATLAB mit Symbolic Toolbox, 28 Byte

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

Dies ist eine anonyme Funktion. Um es aufzurufen, weisen Sie es einer Variablen zu oder verwenden Sie ans. Eingaben sind Zeichenfolgen mit dem Format (Leerzeichen sind optional)

x^2 + 3*x + 5

Beispiellauf:

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

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

Eine "richtige" Implementierung, die keine Basen missbraucht. Niedrigster signifikanter Koeffizient zuerst.

aist Polynomaddition, mist Polynommultiplikation und oist Zusammensetzung.

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

Akzeptiert und gibt Polynome als Array a = [a ₀ , a ₁ , a ₂ , ...] zurück, das a ₀ + a ₁ * x + a ₂ * x ² ... darstellt.

Bearbeiten: 47 Bytes durch Umschalten von rekursiver zu iterativer Polynommultiplikation gespart, wodurch ich zwei mapAufrufe zusammenführen konnte.

Erklärung: r ist das Ergebnis, das bei Null beginnt, dargestellt durch ein leeres Array, und p ist g ^h , das bei Eins beginnt. p wird von jedem multipliziert f _h wiederum , und das Ergebnis der aufgelaufenen r . Gleichzeitig wird p mit g multipliziert .

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

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

Testsuite .

Ruby 2.4 + Polynom , 41 + 12 = 53 Bytes

Verwendet Flagge -rpolynomial. Die Eingabe besteht aus zwei PolynomialObjekten.

Wenn mich jemand in Vanille Ruby (keine polynomiale externe Bibliothek) überlistet, bin ich sehr beeindruckt.

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