Question

Let a, b, c, d be four integers (not necessarily distinct) in the set {1, 2, 3, 4, 5}. The number of polynomials x4 + ax3 + bx2 + cx + d which is divisible by x + 1 is(

a. between 55 and 65. (
b. between 66 and 85.(
c. between 86 and 105. (
d. more than 105.

Answer 1

By the polynomial remainder theorem,
`x+1` will be a factor of
`f(x)=x^4+ax^3+bx^2+cx+d` if the remainder upon division is 0, and this remainder is given by
`f(-1)`:


`f(-1)=(-1)^4+a(-1)^3+b(-1)^2+c(-1)+d`

`0=1-a+b-c+d`

`a+c=1+b+d`

Since
`a,c\in\{1,\ldots,5\}`, it follows that
`a+c\in\{2,\ldots,10\}`. But notice that if
`a+c=2`, then we have


`2=1+b+d\implies 1=b+d`

and since
`b,d\in\{1,\ldots,5\}`, the equation above requires that either
`b=0` or
`d=0`, which is impossible. So
`a+c\in\{3,\ldots,10\}`.

So we have 8 cases to check:

(1) Notice that if
`a+c=10`, we have
`b+d=9`. This is only possible for
`(b,d)\in\{(4,5),(5,4)\}`.

(2) If
`a+c=9`, then
`b+d=8`, and so we can have
`(b,d)\in\{(3,5),(4,4),(5,3)\}`.

(3) If
`a+c=8`, then
`b+d=7`, and so
`(b,d)\in\{(2,5),(3,4),(4,3),(5,2)\}`.

(4) If
`a+c=7`, then
`(b,d)\in\{(1,5),(2,4),(3,3),(4,2),(5,1)\}`.

(5) If
`a+c=6`, then
`(b,d)\in\{(1,4),(2,3),(3,2),(4,1)\}`.

(6) If
`a+c=5`, then
`(b,d)\in\{(1,3),(2,2),(3,1)\}`.

(7) If
`a+c=4`, then
`(b,d)\in\{(1,2),(2,1)\}`.

(8) If
`a+c=3`, then
`(b,d)\in\{(1,1)\}`.

At the same time, we have 8 cases to consider to find how many options there are for
`(a,c)`.

(1)
`a+c=10`. We have only one choice of
`(a,c)=(5,5)`.

(2)
`a+c=9`. This is the same as when
`b+d=9`, which we found to be 2 choices.

(3) Same as
`b+d=8`; 3 choices.

(4) Same as
`b+d=7`; 4 choices.

(5) 5.

(6) 4.

(7) 3.

(8) 2.

In total, there are


`2*1+3*2+4*3+5*4+4*5+3*4+2*3+1*2`

`=2(2*1+3*2+4*3+5*4)`

`=2\displaystyle\sum_(n=1)^4n(n+1)`

`=80`

ways to choose
`a,b,c,d` such that
`x+1` is a factor of
`x^4+ax^3+bx^2+cx+d`, so the answer is B.

Note the symmetry of the sum above. You can easily give a slightly briefer combinatorial argument for this answer, but I figured a more brute-force approach would be easier to follow.