Polynomial Long Division

You learned long division on numbers: divide, multiply, subtract, bring down the next digit, repeat. Polynomials play the exact same game. Given a dividend $P(x)$ and a divisor $D(x)$, long division produces a quotient $Q(x)$ and a remainder $R(x)$ such that

$$P(x) = D(x)\cdot Q(x) + R(x), \qquad \deg R < \deg D.$$

At every step you look only at the leading term — the highest power of $x$ — of whatever is left over, match it against the divisor's leading term, and subtract the right multiple away. The degree of the leftover strictly drops each round, so the process cannot run forever: it stops the moment the remainder's degree is smaller than the divisor's.

It sounds mechanical because it is. There's no guessing, no search, no luck involved — just a fixed number of arithmetic steps that always lands on the unique correct answer.

Pick one of the examples below, then press Next step to watch the division unfold exactly the way you'd do it by hand: multiply the divisor by the new quotient term, subtract it from what's left, and bring the degree down by one.

<p class="hint">{{hint_para}}</p>
<div class="controls">
  <label for="example">{{example_label}}</label>
  <select id="example"></select>
  <button id="next" type="button">{{btn_next}}</button>
  <button id="reset" type="button" class="ghost">{{btn_reset}}</button>
</div>
<div class="board">
  <div class="row" id="quotientRow"><span class="rowlabel">{{quotient_label}}</span><span id="quotientPoly" class="poly"></span></div>
  <div class="row" id="workRow"><span class="rowlabel">{{step_label}}</span><span id="workPoly" class="poly"></span></div>
  <div class="row" id="remRow"><span class="rowlabel">{{remainder_label}}</span><span id="remPoly" class="poly"></span></div>
</div>
<div class="status" id="status">{{start_hint}}</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; }
.hint { font-size: .9rem; color: #444; margin: 0 0 .7rem; line-height: 1.45; }
.controls { display: flex; gap: .5rem; flex-wrap: wrap; align-items: center; margin-bottom: .8rem; }
.controls label { font-size: .85rem; font-weight: 600; color: #1d3557; }
select { font: 600 14px system-ui, sans-serif; padding: .4rem .5rem; border-radius: 8px; border: 1px solid #adb1b8; }
button { font: 600 14px system-ui, sans-serif; padding: .45rem .9rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
button:disabled { opacity: .5; cursor: default; }
.board { background: #f4f6f8; border: 1px solid #dde3e8; border-radius: 10px; padding: .8rem 1rem; margin-bottom: .6rem; }
.row { display: flex; align-items: baseline; gap: .6rem; padding: .3rem 0; font: 700 17px ui-monospace, monospace; min-height: 1.6em; }
.rowlabel { font: 600 12px system-ui, sans-serif; color: #667; width: 92px; flex: none; }
.poly { color: #1d3557; word-break: break-word; }
.poly .fade { color: #adb1b8; }
.poly .neg { color: #c92f3c; }
#workRow .poly { color: #6a4c93; }
.status { font-size: 1rem; font-weight: 600; margin: .5rem 0; min-height: 1.4em; }
.status.ok { color: #0a7d33; }

// Code not found

Every click does one round of "multiply and subtract." Once the remainder's degree is smaller than the divisor's, there is nothing left to bring down — the algorithm halts on its own, and what remains is the final remainder.

Polynomial long division is a solved problem — it's not merely fast, it's a completely determined recipe with a guaranteed answer.

• Termination is guaranteed. Each step strictly reduces the degree of the remainder by at least one, so a division that starts with a degree-$n$ dividend and a degree-$m$ divisor needs at most $n-m+1$ rounds.
• Each round is cheap. Every round multiplies the divisor (degree $m$) by a single term and subtracts, which costs $O(m)$ coefficient operations. Multiply that by the number of rounds and the whole division runs in $O\big((n-m+1)\cdot m\big)$ time — quadratic in the worst case, and nowhere near the exponential blow-ups you see elsewhere in this site.
• It's exact, not approximate. Over a field (rationals, reals, or integers mod a prime) the quotient and remainder are unique — there's only one correct pair $(Q, R)$ satisfying $\deg R < \deg D$, so there is nothing to search for.
• It's the polynomial cousin of the Euclidean algorithm. Feed the quotients back in (divide $D$ by $R$, then that remainder by the next one, and so on) and you're computing the greatest common divisor of two polynomials in the same way Euclid's algorithm finds the GCD of two integers.

Compare that to a problem like factoring: division tells you instantly whether a candidate root or factor actually divides evenly (remainder zero), but it does not tell you which candidates to try. Division is the cheap, reliable test; searching for the right divisor is where the real difficulty of factoring hides.

Because it is fast, exact and always terminates, polynomial long division shows up as a building block everywhere polynomials do:

• Factoring and root-testing: dividing by $(x - r)$ and checking for a zero remainder is exactly how you test whether $r$ is a root — the algebraic version of the factor theorem.
• Polynomial GCDs: repeated division is the Euclidean algorithm for polynomials, used to simplify rational expressions and to detect repeated roots.
• Error-correcting codes: Reed–Solomon and CRC codes encode and decode messages by dividing polynomials over finite fields — your Wi-Fi packets and QR codes lean on this every time they check for errors.
• Computer algebra systems: simplifying fractions, partial-fraction decomposition and symbolic simplification all reduce, sooner or later, to a division step.

Learn this one mechanical routine and you've picked up a tool that quietly powers factoring, coding theory and most of symbolic algebra.

Polynomial long division never surprises you: give it any dividend and divisor, and in a bounded number of multiply-and-subtract rounds it hands back the unique quotient and remainder. No search, no guessing, no exponential blow-up — just a small, reliable machine.

That reliability is exactly why it sits underneath so much of algebra. Root-testing, polynomial GCDs and error-correcting codes all lean on this one mechanical step, quietly doing the arithmetic so that the harder questions — like factoring a polynomial into irreducible pieces — have something solid to stand on.