Taylor Series of a Function with Periodic Derivatives Taylor series are a very useful tool in calculating values of analytic functions that cannot be expressed in terms of elementary functions, using only information about that function at a single point.
In this challenge, you won't be actually doing any math with them, but merely making string representations of taylor series of functions with periodic derivatives.
Specs
You will takes a input three things:

A cycle of the derivatives of the function, including the original function as a list of strings, e.g. [&quot;sin(x)&quot;, &quot;cos(x)&quot;, &quot;-sin(x)&quot;, &quot;-cos(x)&quot;].
A number a, the point around which to center the approximation.
A positive integer n, the number of terms of the series to output.

The general form for the nth term of a taylor series is:
f^(n)(a)/n!*(x-a)^n

where f^(n) is the nth derivative of f. Here is the taylor series of f in a better formatted image from wikipedia:
.
The above example with sin(x), and a of 1, and n of 6, would have an output of:
sin(1) + cos(1)*(x-1) - sin(1)/2*(x-1)^2 - cos(1)/6*(x-1)^3 + sin(1)/24*(x-1)^4 + cos(1)/120*(x-1)^5

You can do the whitespace want. However, you have to replace + - and - - with - and + respectively. Also, if the series is a maclaurin series, and a is 0, you cannot have (x-0). (x) and just x is fine, but not (x-0). Niether can you have ^0 nor ^1 nor /1 . Additionally, you must expand out the factorials in the denominators. Multiplication by juxtaposition is not allowed.
Test cases
[&quot;e^x&quot;], 0, 4  -&gt;  e^0 + e^0*x + e^0*x^2/2 + e^0*x^3/6
[&quot;sin(x)&quot;, &quot;cos(x)&quot;, &quot;-sin(x)&quot;, &quot;-cos(x)&quot;], 1, 6 -&gt; sin(1) + cos(1)*(x-1) - sin(1)/2*(x-1)^2 - cos(1)/6*(x-1)^3 + sin(1)/24*(x-1)^4 + cos(1)/120*(x-1)^5
[&quot;e^(i*x)&quot;, &quot;i * e^(i*x)&quot;, &quot;-e^(i*x)&quot;, &quot;-i*e^(i*x)&quot;], 0, 7 -&gt; e^(i*0) + i*e^(i*0)*x - e^(i*0)*x^2/2 - i*e^(i*0)*x^3/6 + e^(i*0)*x^4/24 + i*e^(i*0)*x^5/120 - e^(i*0)*x^6/720

This is code-golf, so shortest code in bytes wins!
JavaScript (ES6), 183 bytes

(c,a,n)=&gt;[...Array(n)].map((_,i)=&gt;(s=c[i%c.length].replace(/x/g,a),i?s=s.replace(/^-?/,c=&gt;c?` - `:` + `)+(a&gt;0?`*(x-${a})`:a&lt;0?`*(x+${-a})`:`*x`):s,i&gt;1?s+`^${i}/${f*=i}`:s),f=1).join``


Lots of tedious string manipulation. Explanation:

(c,a,n)=&gt;                               Parameters
 [...Array(n)].map((_,i)=&gt;(             Loop i from 0 to n-1
  s=c[i%c.length]                       Get the right element from the cycle
   .replace(/x/g,a),                    Substitute a in for x
  i?                                    If i &gt; 0
   s=s.replace(/^-?/,c=&gt;c?` - `:` + `)  Turn the sign into an operator
    +(a&gt;0?`*(x-${a})`                   If a &gt; 0 then * (x - a)
     :a&lt;0?`*(x+${-a})`                  If a &lt; 0 then * (x + -a)
     :`*x`)                             If a == 0 then * x
   :s,                                  No change if i &lt; 1
  i&gt;1?                                  If i &gt; 1
   s+`^${i}/${f*=i}`                    Append ^ i / i!
   :s),                                 No change if i &lt; 2
  f=1                                   0! == 1
 ).join``                               Join all the results together


170 bytes if you remove all the whitespace:

(c,a,n)=&gt;[...Array(n)].map((_,i)=&gt;(s=c[i%c.length].replace(/x/g,a),i?s=(s[0]=='-'?'':'+')+s+(a&gt;0?`*(x-${a})`:a&lt;0?`*(x+${-a})`:`*x`):s,i&gt;1?s+`^${i}/${f*=i}`:s),f=1).join``