# GCD using Euclid algorithm

Posted on

Problem

Below is the problem taken from here.

# Question 10: GCD*

The greatest common divisor of two positive integers a and b is the largest integer which evenly divides both numbers (with no remainder). Euclid, a Greek mathematician in 300 B.C., realized that the greatest common divisor of a and b is one of the following:

the smaller value if it evenly divides the larger value, OR
the greatest common divisor of the smaller value and the remainder of the larger value divided by the smaller value
In other words, if a is greater than b and a is not divisible by b, then

`gcd(a, b) == gcd(b, a % b)`

Write the gcd function recursively using Euclid’s algorithm.

``````def gcd(a, b):
"""Returns the greatest common divisor of a and b.
Should be implemented using recursion.

>>> gcd(34, 19)
1
>>> gcd(39, 91)
13
>>> gcd(20, 30)
10
>>> gcd(40, 40)
40
"""
``````

# Solution:

``````def gcd(a, b):
"""Returns the greatest common divisor of a and b.
Should be implemented using recursion.

>>> gcd(34, 19)
1
>>> gcd(39, 91)
13
>>> gcd(20, 30)
10
>>> gcd(40, 40)
40
"""
if b > a:
if b % a == 0:
return a
else:
return gcd(b % a, a)
else:
if a % b == 0:
return b
else:
return gcd(b, a % b)
``````

How can I improve this nested `if` block?

Solution

One of the nice things with recursion is that you can use it for argument handling.

Where you have a conditional to handle the `b > a` condition, you could instead use recursion…..

``````def gcd(a, b):
"""Returns the greatest common divisor of a and b.
Should be implemented using recursion.

>>> gcd(34, 19)
1
>>> gcd(39, 91)
13
>>> gcd(20, 30)
10
>>> gcd(40, 40)
40
"""
if b > a:
return gcd(b, a)

if a % b == 0:
return b

return gcd(b, a % b)
``````

This is slightly irrelevent but you can improve your code quite easily by removing recursion.

``````def gcd(a, b):
while b:
a, b = b, a % b
return a
``````

Some might argue that this reduces readibility but with a name `gcd`, I find it hard to believe, especially considering the fact that Euclidean algorithm is quite popular.

Starting from Python version 3.5, we can use `math.gcd(a, b)` function from `math` module. So, instead of creating nested if we can use this function.

From documentation:

math.gcd(a, b)
Return the greatest common divisor of the integers a
and b. If either a or b is nonzero, then the value of gcd(a, b) is the
largest positive integer that divides both a and b. gcd(0, 0) returns
0.

`math.gcd(a, b)` is implemented as:

``````def gcd(a, b):
while b:
a, b = b, a % b
return a
``````