# 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                             Range of length
’                    Lowered
U          Reversed
×         Multiplied with the original list (last value is 0)
Ṗ       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, 364239227226 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