Extended Euclidean Algorithm
The Euclidean algorithm works by successively dividing one number (we
assume for convenience they are both positive) into another and computing
the integer quotient and remainder at each stage. This produces a strictly
decreasing sequence of remainders, which terminates at zero, and the last
nonzero remainder in the sequence is the gcd. This works because if a=bq+r
then gcd(a, b) = gcd(b, r) so we are continually trading in the gcd of a pair for
the gcd of a smaller pair. At the last step, we have gcd(r, r) = gcd(r, 0) = r
where ris the final nonzero remainder and ris the remainder preceding it in
the sequence.
Here is a simple iterative implementation of the algorithm in Python:
def gcd(a,b):
while b:
a,b = b, a % b
return a
Note that this works even if a < b, since then its first step will be to inter-
change aand b, after which the reductions will take place as usual. Here is
a recursive implementation of the same algorithm, also in Python:
def gcd(a,b):
if b == 0:
return a
else:
return gcd(b, a % b)
and again if a < b this first interchanges aand band then proceeds as usual,
so as in the preceding example the order of the arguments does not matter.
Now by working backwards with all the quotients and remainders, one can
easily find integers x,ysuch that g=ax +by where g= gcd(a, b). We’d
like to modify the first program above to return xand yas well as g. In
fact, not only does the algorithm produce a sequence of remainders, but for
each remainder it produces integers xand yso that r=ax +by. Thus
we obtain sequences of x’s and y’s. Supposing that the previous remainder
r=ax +by, at the next stage of the algorithm we would divide rinto the
1
