[Question]
  [
**Challenge**
The challenge is to write a program that takes the coefficients of any n-degree polynomial equation as input and returns the **integral** values of x for which the equation holds true. The coefficients will be provided as input in the order of decreasing or increasing power. You can assume all the coefficients to be **integers**.
**Input And Output**
The input will be the coefficients of the equation in decreasing or increasing order of power. The degree of the equation, i.e, maximum power of x, is always 1 less than the total no of elements in the input.
For example: 
```
[1,2,3,4,5] -> represents x^4 + 2x^3 + 3x^2 + 4x + 5 = 0 (degree = 4, as there are 5 elements)
[4,0,0,3] -> represents 4x^3 + 3 = 0 (degree = 3, as there are 3+1 = 4 elements)
```
Your output should be only the **distinct integral values** of x which satisfy the given equation. All the input coefficients are integers and the input polynomial **will not be a zero polynomial**. If there is no solution for the given equation, then the output is undefined. 
If an equation has repeated roots, display that particular root only once. You can output the values in any order. Also, assume that the input will contain at-least 2 numbers.
**Examples**
```
[1,5,6] -> (-3,-2)
[10,-42,8] -> (4)
[1,-2,0] -> (0,2)
[1, 1, -39, -121, -10, 168] -> (-4, -3, -2, 1, 7)
[1, 0, -13, 0, 36] -> (-3, -2, 2, 3)
[1,-5] -> (5)
[1,2,3] -> -
```
Note that the equation in the second example also has the root 0.2, but it is not displayed as 0.2 is not an integer.
**Scoring**
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code (in bytes) wins!
  
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~13~~ 12 bytes
```
|stE:-GyZQ~)
```
[Try it online!](https://tio.run/##y00syfn/v6a4xNVK170yKrBO8///aEMdBQMdBV1DYzBtbBYLAA)
This uses the [fact](https://en.wikipedia.org/wiki/Properties_of_polynomial_roots#Bounds_on_(complex)_polynomial_roots) that, for integer coefficients, the absolute value of any root is strictly less than the sum of absolute values of the coefficients.
### Explanation
Consider input `[1 5 6]` as an example.
```
|    % Implicit input. Absolute value
     % STACK: [1 5 6]
s    % Sum
     % STACK: 12
t    % Duplicate
     % STACK: 12, 12
E    % Multiply by 2
     % STACK: 12, 24
:    % Range
     % STACK: 12, [1 2 ... 23 24]
-    % Subtract, elemet-wise
     % STACK: [11 10 ... -11 -12]
G    % Push input again
     % STACK: [11 10 ... -11 -12], [1 5 6]
y    % Duplicate from below
     % STACK: [11 10 ... -11 -12], [1 5 6], [11 10 ... -11 -12]
ZQ   % Polyval: values of polynomial at specified inputs
     % STACK: [11 10 ... -11 -12], [182 156 ... 72 90]
~    % Logical negation: turns nonzero into zero
     % STACK: [11 10 ... -11 -12], [0 0 ... 0] (contains 1 for roots)
)    % Index: uses second input as a mask for the first. Implicit display
     % STACK: [-3 -2]
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~10~~ 9 bytes
-1 byte thanks to Zgarb
```
uSȯf¬`Bṁṡ
```
[Try it online!](https://tio.run/##yygtzv7/vzT4xPq0Q2sSnB7ubHy4c@H///@jDXVMdcxiAQ "Husk – Try It Online")
### Explanation
```
       ṁṡ   Concatenate together the symmetric ranges of each coefficient
            (It is guaranteed that the integer roots lie in the range [-n..n],
                        where n is the coefficient with the largest magnitude)
 Sȯf        Find all the values in that range which
    ¬       are zero
     `B     when plugged through the polynomial
            (Base conversion acts as polynomial evaluation)
u           De-duplicate the roots
```
[Answer]
# [Haskell](https://www.haskell.org/), 54 bytes
```
f l|t<-sum$abs<$>l=[i|i<-[-t..t],foldl1((+).(i*))l==0]
```
[Try it online!](https://tio.run/##VYxBDsIgEEX3nmIWXYACKcU2mhRv4AkIC4w2Eqe1sbjr3RG6sZ3FzPyX/Pd00@uBGGMHOIeWT9@@cLepLS6ojZ99yw0PQgTLujfeURJyoIL4PaWodWlj7/wAGno3XoGMHz8EENDRHaQxYCSDmkFjl8xSLhnwY8Xg9EeJJFCuQWbqnJas8ptbstlUskeq5apm46rXKYmVBRt/ "Haskell – Try It Online")
Brute force and synthetic division.
## Ungolfed with [UniHaskell](https://github.com/totallyhuman/unihaskell) and `-XUnicodeSyntax`
```
import UniHaskell
roots    ∷ Num a ⇒ [a] → [a]
roots xs = [r | r ← -bound … bound, foldl1 ((+) ∘ (r ×)) xs ≡ 0]
             where bound = sum $ abs § xs
```
## Alternate solution, 44 bytes
*Credit to nimi.*
```
f l=[i|i<-[minBound..],foldl1((+).(i*))l==0]
```
Good luck with [trying it online](https://tio.run/##VYwxD4IwFIR3f8WNrZaGUiFK7OLm4C9oOpAgsaEUorj532vLIrzhvXvf5e7ZvPuHcyF0cErbr71kerD@On58y7lh3ehaJwg5UE7snlKnVG7C0FgPhaGZ7iDTy/oZHB3dIY6GFgwlQ2VQ19A3P5vFYNHIGbJjwXD6o0giyNcgMXmOSxRJppSoNpHUI@RyZbXpKtdfLJYGJvwA "Haskell – Try It Online"), as this checks *every* number in an `Int`'s range.
[Answer]
# [Python 2](https://docs.python.org/2/) + numpy, ~~95~~ ~~93~~ ~~91~~ ~~103~~ ~~93~~ ~~91~~ 82 bytes
-2 bytes thanks to ovs  
thanks Luis Mendo for the upper/lower bounds of the roots  
-10 bytes thanks to Mr. Xcoder  
```
from numpy import*
def f(r):s=sum(fabs(r));q=arange(-s,s);print q[polyval(r,q)==0]
```
[Try it online!](https://tio.run/##LY7LDoMgEEX3/Qp2YjMkgtW0Gr6EsLCptCbyELCJX29Bu5lzJnMzuW6LH2vYvitvNTKrdhuatLM@Xi@vUSGFfdkFHlaN1fAMaSv7hQ9@MO8RkwCh7J2fTESLcHbevsOMPSwl55Xc4xhi4EJQaKCVIGgF5MbgnhUIg@qQpPUDCGVJUoK25z1laZ1m3Z7x5gCDWsqLsh7l52gyB0N3dsjeK5zxr1UU@w8 "Python 2 – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~50~~ ~~47~~ ~~42~~ ~~25~~ 27 bytes
```
{}⋃Select[x/.Solve[#~FromDigits~x==0],IntegerQ]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7v7r2UXdzcGpOanJJdIW@XnB@TllqtHKdW1F@rktmemZJcV2Fra1BrI5nXklqempRYKza/4CizLyS6DSHakMDHV0TIx2L2tj/AA "Wolfram Language (Mathematica) – Try It Online")
Update: using Luis Mendo's fact, golfed off another 3 bytes
```
Pick[r=Range[s=-Tr@Abs@#,-s],#~FromDigits~r,0]&
```
Getting sloppier with the bounds, we can reduce this 5 more bytes per @Not a tree's suggestion:
```
Pick[r=Range[s=-#.#,-s],#~FromDigits~r,0]&
```
After posting this, OP commented allowing "native polynomials", so here's a 25 byte solution that accepts the polynomial as input. This works because by default Mathematica factors polynomials over the integers, and any rational roots show up in a form like `m*x+b` that fails the pattern match.
```
Cases[Factor@#,b_+x:>-b]&
```
As @alephalpha pointed out this will fail for the case where zero is a root, so to fix that we can use the `Optional` symbol `:`
```
Cases[Factor@#,b_:0+x:>-b]&
```
This parses fine Mathematica 11.0.1 but fails and requires an extra set of parentheses around `b_:0` in version 11.2. This takes up back up to 27 bytes, plus two more after version 11.0.1. It looks like a "fix" was put in [here](https://mathematica.stackexchange.com/questions/124801/pattern-matching-with-list-and-optional)
[Try it Online!](https://tio.run/##y00syUjNTSzJTE78n2b73zmxOLU42i0xuSS/yEFZRyMp3spAU7vCyk43KVbtf0BRZl5JdFq0obZRhXZFnFFsLBdMyEzbFF0IyNOuiI39DwA)
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~33~~ ~~26~~ 31 bytes
Fixed an error noted by Kelly Lowder in the comments.
```
x/.{}⋃Solve[#==0,x,Integers]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7v0Jfr7r2UXdzcH5OWWq0sq2tgU6FjmdeSWp6alFxrNp/roCizLwSB600BX0HheqKOCNt0wptMx0FQwMgW9fEqELbQkcBxDSqANGm2hVxJrrGlhVxxrqGRoYgCaBKbUMzsCoTXUNjkBHGQAMqdE3BGrWBRhjDWYa1/wE "Wolfram Language (Mathematica) – Try It Online")
**Previous incorrect solutions:**
I just noticed that for no integer solution, the output is undefined instead of empty list; that allows to remove a few bytes.
```
x/.Solve[#==0,x,Integers]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7v0JfLzg/pyw1WtnW1kCnQsczryQ1PbWoOFbtP1dAUWZeiYNWmoK@g0J1RZyRtmmFtpmOgqEBkK1rYlShbaGjAGIaVYBoU@2KOBNdY8uKOGNdQyNDkARQpbahGViVia6hMcgIY6ABFbqmYI3aQCOMa/8DAA "Wolfram Language (Mathematica) – Try It Online")
Now if no integer solution exists, the function returns `x`.
**Previously:**
```
x/.Solve[#==0,x,Integers]/.x->{}&
```
[Try it online!](https://tio.run/##HYzLCsIwFET3fkVAcGFym@ZVdBHp1p3gUgwESbVgK9QgF0q/PSZdzcCcOYOPrzD42D986mxCXl0/71@4ba2tGbLzGMMzTN87rxBO87JLm8vUj7Hdd4S3ZEYnqUHaMCLq3EFLpAdGSpVY0lB0GtQRnQIhRRkySUWzUhqEKgqVBQhmPdKsUEv6Aw "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [R](https://www.r-project.org/), ~~61~~ 59 bytes
A special thanks to [@mathmandan](https://codegolf.stackexchange.com/users/36885/mathmandan) for pointing out my (incorrect) approach could be saved, and golfed!
```
function(p)(x=-(t=p[!!p][1]):t)[!outer(x,seq(p)-1,"^")%*%p]
```
[Try it online!](https://tio.run/##PYxBCsIwEEX3PcW0UpiRBIyii2JPEipImJRukpikpZ4@ZiFd/cfn8WKx8JTFrs7kxTsMhPsoMY9Bt22YtJpoyKRbv2aOuIvEn@pIJbpXR/25D1OZawCOwJcsRt7qEpzAeLexW9gZPhSwPkLmlMG8E6emmdGgEnfxIKqshhv9L3kVF6LyAw "R – Try It Online")
Takes input as a list of coefficients in *increasing* order, i.e., `c(-1,0,1)` represents `-1+0x+1x^2`.
Using the rational root theorem, the following approach very nearly works, for 47 bytes:
```
function(p)(x=-p:p)[!outer(x,seq(p)-1,"^")%*%p]
```
[Try it online!](https://tio.run/##PYtBCsIwEEX3PcVYKcxIsgiii1JPIgoyTEo3k5ikpZ4@ZtXV@zz@S9XDZKtflcsSFCPh/rBxjPQ8hbVIwt1k@TZvnenfPQ2XIb7q3CI4oh95TLI1EpyBg26iiyjLcQEfEhTJBfiTJXfdjIzO3MydqG03Xqn@AQ "R – Try It Online")
`-p:p` generates a symmetric range (with a warning) using only the first element of `p`, `a_0`. By the [Rational Root Theorem](https://en.wikipedia.org/wiki/Rational_root_theorem), all rational roots of `P` must be of the form `p/q` where `p` divides `a_0` and `q` divides `a_n` (plus or minus). Hence, using just `a_0` is sufficient for `|a_0|>0`, as for any `q`, `|p/q|<=a_0`. However, when `a_0==0`, as then *any* integer divides `0`, and thus this fails.
However, mathmandan points out that really, in this case, this means that there's a constant factor of `x^k` that can be factored out, and, assuming `k` is maximal, we see that
```
P(x) = x^k(a_k + a_{k+1}x + ... a_n x^{n-k}) = x^k * Q(x)
```
We then apply the Rational Root Theorem to `Q(x)`, and as `a_k` is guaranteed to be nonzero by the maximality of `k`, `a_k` provides a tidy bound for the integer roots of `Q`, and the roots of `P` are the roots of `Q` along with zero, so we will have all the integer roots of `P` by applying this method.
This is equivalent to finding the first nonzero coefficient of the polynomial, `t=p[!!p][1]` and using it instead of the naive `p[1]` as the bounds. Moreover, since the range `-t:t` always contains zero, applying `P` to this range would still give us zero as a root, if indeed it is.
### ungolfed:
```
function(polynom) {
 bound <- polynom[polynom != 0][1]             #first nonzero value of polynom
 range <- -bound:bound                         #generates [-bound, ..., bound]
 powers <- outer(range,seq_along(p) - 1, "^")  #matrix where each row is [n^0,n^1,n^2,...,n^deg(p)]
 polyVals <- powers %*% polynom                #value of the polynomial @ each point in range
 return(range[polyVals == 0])                  #filter for zeros and return
}
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ASŒRḅ@Ðḟ
```
**[Try it online!](https://tio.run/##y0rNyan8/98x@OikoIc7Wh0OT3i4Y/7///@jDXVMdcxiAQ "Jelly – Try It Online") or [as a test-suite!](https://tio.run/##y0rNyan8/98x@OikoIc7Wh0OT3i4Y/7/w@2Pmta4//8fHW2oY6pjFqsTbWigo2tipGMBYuroGukYgBlAprGljq6hEZABVGFoBpEHqjU0BpLGZhDlpmDKSMc4NhYA)**
## How?
```
ASŒRḅ@Ðḟ || Full program (monadic link).
AS        || Sum the absolute values.
  ŒR      || And create the symmetric inclusive range from its negative value.
       Ðḟ || And discard those that yield a truthy value...
     ḅ@   || When plugging them into the polynomial (uses base convertion).
```
Based off [Luis' answer](https://codegolf.stackexchange.com/a/154009/59487). [An alternative](https://tio.run/##y0rNyan8///opCC3wIc7Wh0OT3i4Y/7///@jDXVMdcxiAQ).
[Answer]
# [Octave](https://www.gnu.org/software/octave/), ~~59~~ 49 bytes
```
@(p)(x=-(t=p(~~p)(end)):sign(t):t)(!polyval(p,x))
```
[Try it online!](https://tio.run/##PYzNCoMwEITvfYr0tgubkJ8aWiHQ9xAP0qoIooEGsRdfPU2kCsPON8sw8ys0Sxs7J4SIT/AIq@MQnIdtS6Gd3ojlZ@gnCFgGhKufx@/SjOBpRYwdVIoKsjVeMkriN033fyKuSR7Mkrh5pKN0xtRlyp5VJvPP7G7sOVAcpMnUGH8 "Octave – Try It Online")
This is a port of my [R answer](https://codegolf.stackexchange.com/a/154013/67312). The only difference is that I have to explicitly use `sign(t)` and `end` to generate the range, and that it has `polyval` to compute the polynomial.
Takes input as a row vector of coefficients in decreasing order.
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 31 bytes
```
p->[x-a|a<-factor(p)[,1],a'==1]
```
Factors the polynomial, and picks out the factors whose derivatives are 1.
[Try it online!](https://tio.run/##LY3NCsIwEIRfZenF/iTgJm1RMH2R0MIiVAqiS@ghgu8eN42XMPNlZpYpbPrBaQUHifXko6Yv3fRK9/0dam68wlnRyTmcEzE/PzWDnoDD9tpFVtlUsEqyUeDjYqCDoY3yjgrw3GaioTcHuigoXmyWg7C49ALsVZJWBBr8d3JZ/nE8WjmEti0HrGxHAUPZ66DM27lJPw "Pari/GP – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~127~~ ~~126~~ 123 bytes
* Saved one byte thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen); golfing `l+~j++` to `l-++j`.
* Thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat) for saving three bytes.
```
x,X,j,m,p;f(A,l)int*A;{for(m=j=0;j<l;m+=abs(A[j++]));for(x=~m;X=x++<m;p||printf("%d,",x))for(p=j=0;j<l;X*=x)p+=A[l-++j]*X;}
```
[Try it online!](https://tio.run/##ddDbaoMwGADg6@0pRBgk5g@omdKR5sKeH0EQLzqHo2K60HYg2OzVXdRubJiGkASSL/@hoO9F0XUNpFCBBMVLlECND8eLl/C2/DghKSrh82pec0nE/vWMkqwiJMeY97eN@JI8FQ0hc8nV9apOhpbIfXoDFxqM@zfq94fUEw1WRCRZTQmpci/lupP7wxHh9vHBSCfJctEGEEGsHcsY0mOYq8/LGbku5qNaDMoH@hzCTNvUwqKWYywagq/tsZYWtRqVYyZlL2YJwv5oojtBPNNGrSCeqPVN@f1TNuzsT4lGrSGaqM0tw8jajF5tIJyo7ahCYPd6uLXUtftRlN3pxu6/0t03 "C (gcc) – Try It Online")
---
# Explanation
# [C (gcc)](https://gcc.gnu.org/), 517 bytes
```
x,X,j,m,p;                      // global integer variables
f(A,l)int*A;{                   // define function, takes in integer array pointer and length
 for(m=j=0;j<l;m+=abs(A[j++])); // loop through array, sum up absolute values
  for(x=~m;X=x++<m;             // loop through all values x in [-m, m], prime X
   p||printf("%d,",x))          // at loop's end, print x value if polynomial value is zero
    for(p=j=0;j<l;X*=x)         // loop through coefficients
     p+=A[l-++j]*X;}            // build polynomial
```
[Try it online!](https://tio.run/##dZLbbqMwFEWfJ19xFKkaCEZNYBJ15PJA75@AFOXBAUNMfUFgRnRS5tczBtKqaQhCgC2vdfYxjt0sjg@HBkUoRwIVGEav62vIuNoSDkxqmtES/pCSkS2n1SS1QsRtMz8L8X6cTWjKJIW0lrFmSiLQ5JVWxvWpI2VJ3qBQ3diMZAKcykzvJpCq0hJBHsxxfsuxcAKyraxwnTvOxrZxZ@dKFaB3paqz3SBCUNUC6gLMWsVrTU1cXpus0Oua4J/AUdA4zq3A37Oe2jg/otB0cdeuQCA2CIqSCQqREULx/m5GUqfW9CpBU9TY9omQ6N75swIqk56U2th6LbDUNM3fpBKM8I@5Cv7SUnXuPm7x2X00Cxr7YthY0TRlMaNSVz0MhROEa@46Tr6ZRbj91um2Zjz5Uv4gCJOWvZ/86BKG602wX6AlWrVjJwJ3v923cVHryppObTxQdz01R@4vD920Y9TdCHU/1HI9NG/Ha92PUA8DBeZ2/d/msfC6T1MdFqub1lAPaHVGPR6pebfU79/@lxYN9YiWZ9TTMeFydDM66gl5Z9TzQHnIv7SHzyN9vXxQrn9hN15OqfbwHw "C (gcc) – Try It Online")
[Answer]
# Java 8, ~~141~~ 140 bytes
```
a->{int l=a.length,s=0,i,r,f,p;for(int n:a)s+=n<0?-n:n;for(r=~s;r++<s;System.out.print(p==0?r+",":""))for(p=i=0,f=1;i<l;f*=r)p+=a[l-++i]*f;}
```
Inspired by [*@Rod*'s Python 2 answer (his 82 bytes version)](https://codegolf.stackexchange.com/a/154008/52210).
Fun challenge! I certainly learned a lot of it when investigating about polynomials and seeing how some others here have done it.
**Explanation:**
[Try it online.](https://tio.run/##dVHLbsIwELz3K1Y5JWQd5VFQi3H5gnLpEXFwQ0JNg2PZhqpC6a@nS6CXtpFsy94ZjWd29/IkWWsqvd@@92UjnYNnqfT5DkBpX9lalhWsLk@AU6u2UIZUX29ARpyKHW1azkuvSliBBgG9ZE9nIkEjZNJUeuff0IkUFVqs0fC6tRcN0HMZuVjoRbpkeq6HuhVfjts4Xjj@8ul8dUjao0@MJX5ohEiXNg4wmAdBFF3oRigSrkXG1aLh9UTYyMRCrhsWx2ozqXnX86tDc3xtyOHN6JDkQDnDF0/au/VGRteMvnI@1NUHDCnPGU5x1g1R/2IpsvscH8ZgZDmmoyDBxSOyLKcLKWWzcR36JyvoLEadYI7FuI1p98@shhYM3J95XhugkzKUN6nfI2h0eFPq@m8)
```
a->{                   // Method with integer-array parameter and no return-type
  int l=a.length,      //  The length of the input-array
      s=0,             //  Sum-integer, starting at 0
      i,               //  Index integer
      r,               //  Range-integer
      f,               //  Factor-integer
      p;               //  Polynomial-integer
  for(int n:a)         //  Loop over the input-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)
      System.out.print(p==0?r+",":""))
                       //    After every iteration: print the current `r` if `p` is 0
    for(p=i=0,         //   Reset `p` to 0
        f=1;           //   and `f` to 1
        i<l;           //   Loop over the input-array 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[l-++i]      //     The value of the input at index `l-i-1`,
                 *f;}  //     multiplied with the current factor `f`
```
[Answer]
# [Octave](https://www.gnu.org/software/octave/) with Symbolic Package, 63 bytes
```
@(p)(s=double(solve(poly2sym(p)==0)))(s==(t=real(s))&~mod(t,1))
```
[Try it online!](https://tio.run/##PYzPCsIwDIfvPkVPkkBW@scVPRR8D9lhuu7U0bHWwS6@em3FDULyJfn4hVfqV5dHyznPd5gRoh3C@@kdxOBXB3Pwm4rbVF7WCsQqWEh2cb2HiHj@TGGARBIxj/CQrGWmw1NFQc1F0fW/UaNI7MxKNfpWmlQVi8ukOVQm6k3/pjZHQLuTIt1h/gI "Octave – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
```
ÄOD(Ÿʒβ>
```
[Try it online!](https://tio.run/##MzBNTDJM/f//cIu/i8bRHacmndtk9/9/tKGOqY5ZLAA "05AB1E – Try It Online")
[Answer]
## JavaScript (ES6), 97 bytes
```
a=>[...Array((n=Math.max(...a.map(Math.abs)))-~n)].map(_=>n--).filter(i=>!a.reduce((x,y)=>x*i+y))
```
Takes coefficients in decreasing order of power and outputs results in descending order.
[Answer]
# [Clean](https://clean.cs.ru.nl), ~~110~~ 91 bytes
```
import StdEnv
?p#s=sum p
=[i\\i<-[~s..s]|i<>0&&sum[e*i^t\\t<-reverse(indexList p)&e<-p]==0]
```
[Try it online!](https://tio.run/##DcxBC4IwFADgu79iEEiFEzvUactLHQJvHrcFQ1/xwM3hm1IQ/fSW5w@@bgDrkxv7eQDmLPqELoxTZG3sr37J6rAhSbNjIZMKtUbB1ZfKkswHxbnK89UU7PEetY6CT7DARLBF38OrQYos7HIQPBgpK5PaaNdaspqpQ3EsTib9usdgn5T4rUmXt7cOO/oD "Clean – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 89 bytes
```
def f(a):s=sum(map(abs,a));return[n for n in range(-s,s)if reduce(lambda v,c:v*n+c,a)==0]
```
[Try it online!](https://tio.run/##LY5BDoIwEEXXeorZUXRICggxmHqRposRWiWRgbRA4ulRwNV7yc9L/vAZXz1ny9JYB05QXAUVpk50NAh6BKQ4vnk7Tp41g@s9MLQMnvhpRRIwxK0Db5uptuJN3aMhmLGu5hOf61@rlDTLWtFaaZ1igaVB0KnE5JLhdXNMMpS7gURI0nxjXv7XYmeGuTHV8TD4lkcgjNQ9wvXy8gU "Python 2 – Try It Online")
]