Find The Local Maxima And Minima
Jelly, 20 bytes
ASŒRḅ@Ðḟ
J’U×µṖÇḅ@€³
Try it online!
Explanation
ASŒRḅ@Ðḟ Helper Function; find all integer solutions to a polynomial
All integer roots are within the symmetric range of the sum of the absolute values of the coefficients
A Absolute Value (Of Each)
S Sum
ŒR Symmetric Range; `n -> [-n, n]`
Ðḟ Filter; keep elements where the result is falsy for:
ḅ@ Base conversion, which acts like the application of the polynomial
J’U×µṖÇḅ@€³ Main Link
J Range of length
’ Lowered
U Reversed
× Multiplied with the original list (last value is 0)
µ Begin new monadic chain
Ṗ Pop; all but the last element
Ç Apply last link (get all integer solutions of the derivative)
ḅ@€³ Base conversion of the polynomial into each of the solutions; apply polynomial to each solution of the derivative.
The helper function in this program was taken from Mr. Xcoder's answer here which was based off of Luis's answer here
JavaScript (ES7), 129 120 bytes
Takes the coefficients in increasing order of power.
a=>(g=x=>x+k?(A=g(x-1),h=e=>a.reduce((s,n,i)=>s+n*(e||i&&i--)*x**i,0))()?A:[h(1),...A]:[])(k=Math.max(...a.map(n=>n*n)))
Test cases
let f =
a=>(g=x=>x+k?(A=g(x-1),h=e=>a.reduce((s,n,i)=>s+n*(e||i&&i--)*x**i,0))()?A:[h(1),...A]:[])(k=Math.max(...a.map(n=>n*n)))
console.log(JSON.stringify(f([0,-8,2]))) // (-8)
console.log(JSON.stringify(f([10,-36,3,2]))) // (91,-34)
console.log(JSON.stringify(f([8,-24,22,-8,1]))) // (-1,0,-1) Commented
a => ( // given the input array a[]
g = x => // g = recursive function checking whether x is a solution
x + k ? ( // if x != -k:
A = g(x - 1), // A[] = result of a recursive call with x - 1
h = e => // h = function evaluating the polynomial:
a.reduce((s, n, i) => // for each coefficient n at position i:
s + // add to s
n // the coefficient multiplied by
* (e || i && i--) // either 1 (if e = 1) or i (if e is undefined)
* x**i, // multiplied by x**i or x**(i-1)
0 // initial value of s
) // end of reduce()
)() ? // if h() is non-zero:
A // just return A[]
: // else:
[h(1), ...A] // prepend h(1) to A[]
: // else:
[] // stop recursion
)(k = Math.max( // initial call to g() with x = k = maximum of
...a.map(n => n * n) // the squared coefficients of the polynomial
)) // (Math.abs would be more efficient, but longer)
Java 8, 364 239 227 226 218 bytes
a->{int l=a.length,A[]=a.clone(),s=0,i,r,f=l,p;for(;f>0;A[--f]*=f);for(int n:A)s+=n<0?-n:n;for(r=~s;r++<s;){for(p=0,i=f=1;i<l;f*=r)p+=A[i++]*f;if(p==0){for(f=i=0;i<l;f+=a[i++]*Math.pow(r,p++));System.out.println(f);}}}
Uses the same functionality from this answer of mine.
-8 bytes thanks to @OlivierGrégoire by taking the array in reversed order.
Explanation:
Try it online.
a->{ // Method with integer-varargs parameter and integer return-type
int l=a.length, // The length of the input-array
A[]=a.clone(), // Copy of the input-array
s=0, // Sum-integer, starting at 0
i, // Index-integer
r, // Range-integer
f=l, // Factor-integer, starting at `l`
p; // Polynomial-integer
for(;f>0; // Loop over the copy-array
A[--f]*=f); // And multiply each value with it's index
// (i.e. [8,45,-12,1] becomes [0,45,-24,3])
for(int n:A) // Loop over this copy-array:
s+=n<0?-n:n; // And sum their absolute values
for(r=~s;r++<s;){ // Loop `r` from `-s` up to `s` (inclusive) (where `s` is the sum)
for(p=0, // Reset `p` to 0
i=f=1; // and `f` to 1
// (`i` is 1 to skip the first item in the copy-array)
i<l; // Inner loop over the input again, this time with index (`i`)
f*=r) // After every iteration: multiply `f` with the current `r`
p+= // Sum the Polynomial-integer `p` with:
A[i++] // The value of the input at index `i`,
*f;} // multiplied with the current factor `f`
if(p==0){ // If `p` is now 0:
for(f=i=0; // Use `f` as sum, and reset it to 0
i<l; // Loop over the input-array
f+=a[i++]*Math.pow(r,p++));
// Fill in `r` in the parts of the input-function
System.out.println(f);}}}
// And print the sum