<aside> 💖 This is a demonstration/showcase for how a power rule differentiation algorithm can be implemented programatically!

</aside>

$\color{#ff99c9} \utilde{\mathit{Prerequisites/Validation}}$

• If there’s no polynomial to begin with then return null early
• If the “polynomial” is just a constant then return 0
• Get rid of any spaces the user might have added for formatting.
• Split the polynomial on + and - but maintain the symbols in the matches
  • This is done via the RegExp /(?=[+-])/g
• Get rid of any terms that have no variable x term (they are constants)

$\color{#ff99c9} \utilde{\mathit{Parsing~each~term}}$

• Go through each term in the array and split the term on the variable x or whatever variable is passed into the function
  • For example, if the input is 4x^3 and the variable is x then splitting will return something similar to ['+4', '^3'].
• If there’s no exponent (basically nothing after the x) then we can assume that it is x^1 and return just the constant coefficient.
• Also get rid of the ^ character as this is just semantics.
• If the first match before the x is just an empty string or +/- then we can assume that there is no coefficient and make it 1.
• Obtain the new term, this is done with the formula $\frac{d}{dx}ax^n=anx^{n-1}$, the power rule of differentiation.
• If the coefficient is more than 0 then we need to re-add the + symbol to maintain the original sign of the expression, as parseInt will omit the + internally when parsing to a number.
• If the new exponent is:
  • 0: There is no longer any x term, so just return the constant coefficient an.
  • 1: There is only a single x , so don’t include the ^n exponent, just return anx
  • Anything else: Return anx^{n-1}

$\color{#ff99c9} \utilde{\mathit{Finalizing~our~expression}}$

• Now we can join all of these parts back together, because all the signs were maintained and we omitted constants from the expression beforehand this is as simple as just an array join.
• Due to our manual handling of the signs, we may end up with a + at the beginning of the parsed expression. If we do, then simply remove it before returning to the user.
• And that’s it! You can now differentiate using the power rule programatically.

$\color{#ff99c9} \utilde{\mathit{Example~implementation~in~TypeScript}}$

// <https://bit.ly/cute-power-rule>
function differentiate(polynomial: string | null, variable = 'x') {
    if (!polynomial) return null;
    if (!isNaN(+polynomial)) return '0';

    const terms = polynomial.replace(/[ ]/g, '').split(/(?=[+-])/g).filter(x => x.includes(variable));

    const parsedParts = terms.map(term => {
        const [coefficient, exponent] = term.split(variable);
        if (!exponent) return `${coefficient}`

        const parsedExponent = exponent.replace('^', '');
        const parsedCoefficient = ['', '+', '-'].includes(coefficient) ? `${coefficient}1` : coefficient;

        const newCoefficient = parseInt(parsedCoefficient) * parseInt(parsedExponent);
        const newExponent = parseInt(parsedExponent) - 1;
        const signedCoefficient = `${newCoefficient > 0 ? '+' : ''}${newCoefficient}`;

        switch (newExponent) {
            case 0:
                return `${signedCoefficient}`;
            case 1:
                return `${signedCoefficient}${variable}`;
            default:
                return `${signedCoefficient}${variable}^${newExponent}`
        }
    })

    const result = parsedParts.join('');

    if (result.startsWith('+')) {
        return result.replace('+', '');
    }

    return result;
}