Mfcttrf

I solved the following problem:

Write a function expand that takes in an expresion with a single, one character variable, and expands it. The expresion is in the form (ax+b)^n where a and b are integers which may be positive or negative, x is any one-character long variable, and n is a natural number. If a = 1, no coeficient will be placed in front of the variable. If a = -1, a "-" will be placed in front of the variable.
The expanded form should be returned as a string in the form ax^b+cx^d+ex^f... where a, c, and e are the coefficients of the term, x is the original one character variable that was passed in the original expression and b, d, and f, are the powers that x is being raised to in each term and are in decreasing order. If the coeficient of a term is zero, the term should not be included. If the coeficient of a term is one, the coeficient should not be included. If the coeficient of a term is -1, only the "-" should be included. If the power of the term is 0, only the coeficient should be included. If the power of the term is 1, the carrot and power should be excluded.

Examples:

expand("(p-1)^3"); // returns "p^3-3p^2+3p-1"
expand("(2f+4)^6"); // returns "64f^6+768f^5+3840f^4+10240f^3+15360f^2+12288f+4096"
expand("(-2a-4)^0"); // returns "1"
expand("(-12t+43)^2"); // returns "144t^2-1032t+1849"
expand("(r+0)^203"); // returns "r^203"
expand("(-x-1)^2"); // returns "x^2+2x+1"

My solution passed all tests but I would like to know how can it be improved.

function expand(str) 
 const fac = n => n < 2 ? 1 : n * fac(n - 1);
 let result = '', [_, a, x, b, n] = str.match(/((-?d*)([a-z])([-+]d+))^(d+)/);

 a = a ? a == '-' ? -1 : parseInt(a) : 1;
 b = parseInt(b); n = parseInt(n);

 for (let i = n; i >= 0; i--) 
 let k = n - i;
 let c = !b && k > 0
 ? 0
 : a**i * b**k * (k == 0
 ? 1
 : fac(n) / (fac(k) * fac(n - k)));

 if (Math.abs(c) == 1 && i > 0) c = c > 0 ? '+' : '-';
 else c = c > 0 ? `+$c` : c;
 if (c) result += c;

 if (i > 0 && c) result += x;
 if (i > 1 && c) result += `^$i`;
 

 return result[0] == '+' ? result.substr(1) : result;

You don't need the special case for k == 0. When k == 0, the result of the other expression will be 1 as well.

For this sequence of binomial coefficients you don't need to calculate the full fak expression each time. You can also start with c = a ** i, and then, for each k, multiply by (n - k) / (k + 1). That's a bit faster and provides less risk of producing numeric overflows, which would result in slightly incorrect coefficients. The Wikipedia article on binomial coefficients should explain this in more detail.

Due to the lack of real context here (and issues I'll mention later), I can't really speak to the algorithm. I'll just focus on style.

First, you need to take far greater care in creating meaningful names. This is incredibly hard to comprehend; and naming is the biggest contributor to the problem.

Take a step back, pretend you didn't write this, and look at

let result = '', [_, a, x, b, n] = str.match(/((-?d*)([a-z])([-+]d+))^(d+)/);

What are a, x, b, and n? Because they're coming from a regex match, they aren't self-descriptive. You need to give them proper names so that people like me (and others reading your code) can know the intent of the variable at a glance without needed to dig through and "discover" what they're for. I can't give suggestions due to the lack of context, but any names would be better than the single-letters being used now.

If the line gets long, split it up. Do the deconstruction on a second line if need-be.

I'm not a fan of your use of nested ternaries here. A line like

a = a ? a == '-' ? -1 : parseInt(a) : 1;

is unfortunate and takes longer to comprehend than it should, but is still mostly legible. At the very least, I'd add some brackets in so the grouping is more obvious:

a = a ? (a == '-' ? -1 : parseInt(a)) : 1;

or maybe, split that off into a function (local or otherwise):

function magnitude(a) 
 return a == '-' ? -1 : parseInt(a);


. . .

a = a ? magnitude(a) : 1;

At least now the line is simplified, and there's a name associated with part of the operation (magnitude was a bad guess. You know the intent so you'll be able to come up with a better name).

On the other hand though,

let c = !b && k > 0
 ? 0
 : a**i * b**k * (k == 0
 ? 1
 : fac(n) / (fac(k) * fac(n - k)));

is bad. You are attempting to cram far too much functionality into too small of a space. Between the lack of proper names and the density, this is very hard to comprehend. I would definitely split this up. Maybe split it over a couple lines (with descriptively-named variables holding intermediate results), or maybe even split some off into a function.

Along the same theme, you also have lines like

let result = '', [_, a, x, b, n] = str.match(/((-?d*)([a-z])([-+]d+))^(d+)/);

b = parseInt(b); n = parseInt(n);

There's little need to put them on the same line like this. I always advocate for declarations to be split over multiple lines in most cases (with the exception being maybe a simple destructuring).

I would split these up:

let [_, a, x, b, n] = str.match(/((-?d*)([a-z])([-+]d+))^(d+)/);
let result = "";

let b = parseInt(b);
let n = parseInt(n);

Overall, I would encourage you to spend far more time practicing making your code readable. Practice putting yourself in the shoes of someone who has never seen your code before. This can be hard to do, but allows you to find your own readability problems. I would also like to emphasize that dense, packed, small code is not good in most scenarios. If code needs to be minified, it can be run through a minifier after the fact. Your base source should be readable so it can be maintained into the future.

It was pointed out that a, x, b, and n are pulled directly from the question, so they're appropriate. If possible I still think they should have better names, but if those are the accepted names to be used in the math equation, or they're too arbitrary for proper names, then yes, they're fine. k and c though both seem like they're not directly related to the equation, so better name there would help.