# Euclid’s Algorithm when % and / operations are costly

Euclid’s algorithm is used to find GCD of two numbers.

There are mainly two versions of algorithm.

**Version 1 (Using subtraction)**

`// Recursive function to return gcd of a and b ` `int` `gcd(` `int` `a, ` `int` `b) ` `{ ` ` ` `if` `(a == b) ` ` ` `return` `a; ` ` ` ` ` `return` `(a > b)? gcd(a-b, b): gcd(a, b-a); ` `} ` |

*chevron_right*

*filter_none*

**Version 2 (Using modulo operator)**

`// Function to return gcd of a and b ` `int` `gcd(` `int` `a, ` `int` `b) ` `{ ` ` ` `if` `(a == 0) ` ` ` `return` `b; ` ` ` ` ` `return` `gcd(b%a, a); ` `}` |

*chevron_right*

*filter_none*

**Which of the above two is more efficient?**

Version 1 can take linear time to find the GCD, consider the situation when one of the given numbers is much bigger than the other. Version 2 is obviously more efficient as there are less recursive calls and takes logarithmic time.

**Consider a situation where modulo operator is not allowed, can we optimize version 1 to work faster?**

Below are some important observations. The idea is to use bitwise operators. We can find x/2 using x>>1. We can check whether x is odd or even using x&1.

gcd(a, b) = 2*gcd(a/2, b/2) if both a and b are even.

gcd(a, b) = gcd(a/2, b) if a is even and b is odd.

gcd(a, b) = gcd(a, b/2) if a is odd and b is even.

Below is C++ implementation.

`// Efficient C++ program when % and / are not allowed ` `int` `gcd(` `int` `a, ` `int` `b) ` `{ ` ` ` `// Base cases ` ` ` `if` `(b == 0 || a == b) ` `return` `a; ` ` ` `if` `(a == 0) ` `return` `b; ` ` ` ` ` `// If both a and b are even, divide both a ` ` ` `// and b by 2. And multiply the result with 2 ` ` ` `if` `( (a & 1) == 0 && (b & 1) == 0 ) ` ` ` `return` `gcd(a>>1, b>>1) << 1; ` ` ` ` ` `// If a is even and b is odd, divide a by 2 ` ` ` `if` `( (a & 1) == 0 && (b & 1) != 0 ) ` ` ` `return` `gcd(a>>1, b); ` ` ` ` ` `// If a is odd and b is even, divide b by 2 ` ` ` `if` `( (a & 1) != 0 && (b & 1) == 0 ) ` ` ` `return` `gcd(a, b>>1); ` ` ` ` ` `// If both are odd, then apply normal subtraction ` ` ` `// algorithm. Note that odd-odd case always ` ` ` `// converts odd-even case after one recursion ` ` ` `return` `(a > b)? gcd(a-b, b): gcd(a, b-a); ` `}` |

*chevron_right*

*filter_none*

This article is compiled by Shivam Agrawal. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

## Recommended Posts:

- Minimize the value of N by applying the given operations
- Operations on Sparse Matrices
- Minimum bitwise operations to convert given a into b.
- Implement *, - and / operations using only + arithmetic operator
- Find maximum operations to reduce N to 1
- Minimum gcd operations to make all array elements one
- Count operations of the given type required to reduce N to 0
- Computing INT_MAX and INT_MIN with Bitwise operations
- Maximum value in an array after m range increment operations
- Minimum operations to make GCD of array a multiple of k
- Minimum operations required to change the array such that |arr[i] - M| <= 1
- Minimum number of operations required to reduce N to 1
- Online Queries for GCD of array after divide operations
- Levelwise Alternating OR and XOR operations in Segment Tree
- Minimum number operations required to convert n to m | Set-2