The greatest common divisor or highest common factor of two numbers can be found using a very simple algorithm described since the time of Euclid, known as the Euclidean algorithm. The nice thing about it is that it can be computed visually by drawing squares in a rectangle as follows.
Let's say that you have a line segment of length 6 units and a smaller line segment of length 2 units.
We can check if the smaller line's length is a divisor of the larger line's length if we can place several of the smaller lines next to each other and reach the exact length of the larger line.
Likewise we can check if a number is a common divisor of two other numbers by checking if a square can fill exactly a rectangle.
In the above diagram, the big blue rectangle has sides of 6 units by 4 units and the small red squares have sides 2 units by 2 units. Since the red square can exactly fill the blue rectangle by placing copies of it next to each other, 2 is a common divisor of 4 and 6.
The greatest common divisor is the largest square that can exactly fill a rectangle. The largest square that can do this has its side equal to the smallest side of the rectangle (otherwise not even one square will fit in the rectangle) whilst the smallest square has its side equal to 1 unit (assuming that sides are always whole number lengths). Let's take the above rectangle as an example and use the Euclidean algorithm to find the largest square that fits a 6 by 4 rectangle.
The Euclidean algorithm takes advantage of the fact that the greatest common divisor of two numbers is also a divisor of the difference of the two numbers. If two numbers "a" and "b" have "c" as a common divisor, then they can be rewritten as "c×p" and "c×q". The difference "a-b" is then equal to "c×p - c×q" which is equal to "c×(p - q)" which is therefore a divisor of "c" since one of its factors is "c". Notice that "c" can be any divisor of "a" and "b", which means that "a-b" should also have the greatest common divisor of "a" and "b" as a divisor.
This means that the largest square to exactly fill the original 4 by 6 square will also be the largest square to exactly fill a 2 by 4 rectangle, since 2 is the difference between 4 and 6.
This piece of information allows us to substitute the difficult problem of finding the largest square that exactly fills a rectangle with an easier problem of finding the same square but on a smaller rectangle. The smaller the rectangle, the easier it is to find the largest square to exactly fill it and the Euclidean algorithm allows us to progressively chop off parts of the rectangle until all that remains is a small square which would be the square that exactly fills the original rectangle.
So the algorithm goes as follows:
- If the rectangle has both sides equal then it itself is the square that is the largest square that exactly fills the rectangle and we are done.
- Otherwise put a square inside the rectangle of length equal to the shortest side of the rectangle.
- Chop off the part of the rectangle that is covered by the square and repeat.
The 6 by 4 rectangle is trivial so let's try this algorithm on a slightly harder problem of 217 by 124. This time we'll be using exact pixels to represent the rectangle lengths.
This is a 217 by 124 rectangle.
This is the overlap it has with a square of length equal to its shortest side.
We now chop off that part of the rectangle and find the largest square which fits the remaining 93 by 124 rectangle.
This is the new square's overlap.
This is the remaining 93 by 31 rectangle.
This is the new square's overlap.
This is the remaining 62 by 31 rectangle.
This is the new square's overlap.
This is the remaining 31 by 31 rectangle.
We have finally reached a square of side 31, which means that 31 is the greatest common divisor of 217 and 124.
Of course we don't really need to visualise anything. We can do this all numerically by just repeatedly subtracting the smallest number from the biggest and replacing the biggest with the difference. Here's a Python function that does that:
def gcd(a, b):
while a != b:
if a < b:
b = b - a
else:
a = a - b
return a
We can make this shorter by using pattern matching:
def gcd(a, b):
while a != b:
(a, b) = (min(a,b), max(a,b)-min(a,b))
return a
If one of the numbers is much bigger than the other, this program will waste a lot of time repeatedly subtracting the same number until the bigger number becomes smaller than the other. Fortunately this process can be done in a single operation by dividing and getting the remainder. The remainder is what's left after you can't subtract the second number from the first any more. This speeds the algorithm up considerably. The operation is called the modulo operation. With modulo the subtractions will not stop when both numbers are equal as modulo assumes that you can do one more subtraction and make the first number zero. Instead we will now keep on looping until the remainder is zero, in which case the last number you used to get the remainder was the greatest common divisor:
def gcd(a, b):
while b > 0:
(a, b) = (min(a,b), max(a,b)%min(a,b))
return a
