# Euclidean algorithms (Basic and Extended)

GCD of two numbers is the largest number that divides both of them. A simple way to find GCD is to factorize both numbers and multiply common factors. Basic Euclidean Algorithm for GCD
The algorithm is based on below facts.

• If we subtract smaller number from larger (we reduce larger number), GCD doesn’t change. So if we keep subtracting repeatedly the larger of two, we end up with GCD.
• Now instead of subtraction, if we divide smaller number, the algorithm stops when we find remainder 0.

Below is a recursive function to evaluate gcd using Euclid’s algorithm.

## CPP

 `// C++ program to demonstrate ` `// Basic Euclidean Algorithm ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return  ` `// gcd of a and b ` `int` `gcd(``int` `a, ``int` `b) ` `{ ` `    ``if` `(a == 0) ` `        ``return` `b; ` `    ``return` `gcd(b % a, a); ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `a = 10, b = 15; ` `    ``cout << ``"GCD("` `<< a << ``", "`  `         ``<< b << ``") = "` `<< gcd(a, b)  ` `                        ``<< endl; ` `    ``a = 35, b = 10; ` `    ``cout << ``"GCD("` `<< a << ``", "`  `         ``<< b << ``") = "` `<< gcd(a, b)  ` `                        ``<< endl; ` `    ``a = 31, b = 2; ` `    ``cout << ``"GCD("` `<< a << ``", "`  `         ``<< b << ``") = "` `<< gcd(a, b)  ` `                        ``<< endl; ` `    ``return` `0; ` `} ` ` `  `// This code is contributed  ` `// by Nimit Garg `

## C

 `// C program to demonstrate Basic Euclidean Algorithm ` `#include ` ` `  `// Function to return gcd of a and b ` `int` `gcd(``int` `a, ``int` `b) ` `{ ` `    ``if` `(a == 0) ` `        ``return` `b; ` `    ``return` `gcd(b%a, a); ` `} ` ` `  `// Driver program to test above function ` `int` `main() ` `{ ` `    ``int` `a = 10, b = 15; ` `    ``printf``(``"GCD(%d, %d) = %dn"``, a, b, gcd(a, b)); ` `    ``a = 35, b = 10; ` `    ``printf``(``"GCD(%d, %d) = %dn"``, a, b, gcd(a, b)); ` `    ``a = 31, b = 2; ` `    ``printf``(``"GCD(%d, %d) = %dn"``, a, b, gcd(a, b)); ` `    ``return` `0; ` `} `

## Java

 `// Java program to demonstrate working of extended ` `// Euclidean Algorithm ` ` `  `import` `java.util.*; ` `import` `java.lang.*; ` ` `  `class` `GFG ` `{ ` `    ``// extended Euclidean Algorithm ` `    ``public` `static` `int` `gcd(``int` `a, ``int` `b) ` `    ``{ ` `        ``if` `(a == ``0``) ` `            ``return` `b; ` `         `  `        ``return` `gcd(b%a, a); ` `    ``} ` ` `  `// Driver Program ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `a = ``10``, b = ``15``, g; ` `        ``g = gcd(a, b); ` `        ``System.out.println(``"GCD("` `+ a +  ``" , "` `+ b+ ``") = "` `+ g); ` `         `  `        ``a = ``35``; b = ``10``; ` `        ``g = gcd(a, b); ` `        ``System.out.println(``"GCD("` `+ a +  ``" , "` `+ b+ ``") = "` `+ g); ` `         `  `        ``a = ``31``; b = ``2``; ` `        ``g = gcd(a, b); ` `        ``System.out.println(``"GCD("` `+ a +  ``" , "` `+ b+ ``") = "` `+ g); ` ` `  `    ``} ` `} ` `// Code Contributed by Mohit Gupta_OMG <(0_o)> `

## Python3

 `# Python program to demonstrate Basic Euclidean Algorithm ` ` `  ` `  `# Function to return gcd of a and b ` `def` `gcd(a, b):  ` `    ``if` `a ``=``=` `0` `: ` `        ``return` `b  ` `     `  `    ``return` `gcd(b``%``a, a) ` ` `  `a ``=` `10` `b ``=` `15` `print``(``"gcd("``, a , ``","` `, b, ``") = "``, gcd(a, b)) ` ` `  `a ``=` `35` `b ``=` `10` `print``(``"gcd("``, a , ``","` `, b, ``") = "``, gcd(a, b)) ` ` `  `a ``=` `31` `b ``=` `2` `print``(``"gcd("``, a , ``","` `, b, ``") = "``, gcd(a, b)) ` ` `  `# Code Contributed By Mohit Gupta_OMG <(0_o)> `

## C#

 `using` `System; ` ` `  `class` `GFG ` `{ ` `    ``public` `static` `int` `gcd(``int` `a, ``int` `b) ` `    ``{ ` `        ``if` `(a == 0) ` `            ``return` `b; ` `         `  `        ``return` `gcd(b % a, a); ` `    ``} ` `     `  `    ``// Driver Code ` `    ``static` `public` `void` `Main () ` `    ``{ ` `        ``int` `a = 10, b = 15, g; ` `        ``g = gcd(a, b); ` `        ``Console.WriteLine(``"GCD("` `+ a +  ` `              ``" , "` `+ b + ``") = "` `+ g); ` `         `  `        ``a = 35; b = 10; ` `        ``g = gcd(a, b); ` `        ``Console.WriteLine(``"GCD("` `+ a +  ` `              ``" , "` `+ b + ``") = "` `+ g); ` `         `  `        ``a = 31; b = 2; ` `        ``g = gcd(a, b); ` `        ``Console.WriteLine(``"GCD("` `+ a +  ` `              ``" , "` `+ b + ``") = "` `+ g); ` `    ``} ` `} ` ` `  `// This code is contributed by ajit `

## PHP

 ` `

Output :

```GCD(10, 15) = 5
GCD(35, 10) = 5
GCD(31, 2) = 1```

Time Complexity: O(Log min(a, b))

Extended Euclidean Algorithm:
Extended Euclidean algorithm also finds integer coefficients x and y such that:

`  ax + by = gcd(a, b) `

Examples:

```Input: a = 30, b = 20
Output: gcd = 10
x = 1, y = -1
(Note that 30*1 + 20*(-1) = 10)

Input: a = 35, b = 15
Output: gcd = 5
x = 1, y = -2
(Note that 35*1 + 15*(-2) = 5)```

The extended Euclidean algorithm updates results of gcd(a, b) using the results calculated by recursive call gcd(b%a, a). Let values of x and y calculated by the recursive call be x1 and y1. x and y are updated using the below expressions.

```
x = y1 - ⌊b/a⌋ * x1
y = x1

```

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Below is implementation based on above formulas.

## C++

 `// C++ program to demonstrate working of  ` `// extended Euclidean Algorithm  ` `#include   ` `using` `namespace` `std; ` ` `  `// Function for extended Euclidean Algorithm  ` `int` `gcdExtended(``int` `a, ``int` `b, ``int` `*x, ``int` `*y)  ` `{  ` `    ``// Base Case  ` `    ``if` `(a == 0)  ` `    ``{  ` `        ``*x = 0;  ` `        ``*y = 1;  ` `        ``return` `b;  ` `    ``}  ` ` `  `    ``int` `x1, y1; ``// To store results of recursive call  ` `    ``int` `gcd = gcdExtended(b%a, a, &x1, &y1);  ` ` `  `    ``// Update x and y using results of  ` `    ``// recursive call  ` `    ``*x = y1 - (b/a) * x1;  ` `    ``*y = x1;  ` ` `  `    ``return` `gcd;  ` `}  ` ` `  `// Driver Code ` `int` `main()  ` `{  ` `    ``int` `x, y, a = 35, b = 15;  ` `    ``int` `g = gcdExtended(a, b, &x, &y);  ` `    ``cout << ``"GCD("` `<< a << ``", "` `<< b  ` `         ``<< ``") = "` `<< g << endl; ` `    ``return` `0;  ` `}  ` ` `  `// This code is contributed by TusharSabhani `

## C

 `// C program to demonstrate working of extended ` `// Euclidean Algorithm ` `#include ` ` `  `// C function for extended Euclidean Algorithm ` `int` `gcdExtended(``int` `a, ``int` `b, ``int` `*x, ``int` `*y) ` `{ ` `    ``// Base Case ` `    ``if` `(a == 0) ` `    ``{ ` `        ``*x = 0; ` `        ``*y = 1; ` `        ``return` `b; ` `    ``} ` ` `  `    ``int` `x1, y1; ``// To store results of recursive call ` `    ``int` `gcd = gcdExtended(b%a, a, &x1, &y1); ` ` `  `    ``// Update x and y using results of recursive ` `    ``// call ` `    ``*x = y1 - (b/a) * x1; ` `    ``*y = x1; ` ` `  `    ``return` `gcd; ` `} ` ` `  `// Driver Program ` `int` `main() ` `{ ` `    ``int` `x, y; ` `    ``int` `a = 35, b = 15; ` `    ``int` `g = gcdExtended(a, b, &x, &y); ` `    ``printf``(``"gcd(%d, %d) = %d"``, a, b, g); ` `    ``return` `0; ` `} `

## Java

 `// Java program to demonstrate working of extended ` `// Euclidean Algorithm ` ` `  `import` `java.util.*; ` `import` `java.lang.*; ` ` `  `class` `GFG ` `{ ` `    ``// extended Euclidean Algorithm ` `    ``public` `static` `int` `gcdExtended(``int` `a, ``int` `b, ``int` `x, ``int` `y) ` `    ``{ ` `        ``// Base Case ` `        ``if` `(a == ``0``) ` `        ``{ ` `            ``x = ``0``; ` `            ``y = ``1``; ` `            ``return` `b; ` `        ``} ` ` `  `        ``int` `x1=``1``, y1=``1``; ``// To store results of recursive call ` `        ``int` `gcd = gcdExtended(b%a, a, x1, y1); ` ` `  `        ``// Update x and y using results of recursive ` `        ``// call ` `        ``x = y1 - (b/a) * x1; ` `        ``y = x1; ` ` `  `        ``return` `gcd; ` `    ``} ` ` `  `// Driver Program ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `x=``1``, y=``1``; ` `        ``int` `a = ``35``, b = ``15``; ` `        ``int` `g = gcdExtended(a, b, x, y); ` `        ``System.out.print(``"gcd("` `+ a +  ``" , "` `+ b+ ``") = "` `+ g); ` ` `  `    ``} ` `} ` `// Code Contributed by Mohit Gupta_OMG <(0-o)> `

## Python3

 `# Python program to demonstrate working of extended  ` `# Euclidean Algorithm  ` `    `  `# function for extended Euclidean Algorithm  ` `def` `gcdExtended(a, b):  ` ` `  `    ``# Base Case  ` `    ``if` `a ``=``=` `0` `:   ` `        ``return` `b, ``0``, ``1` `            `  `    ``gcd, x1, y1 ``=` `gcdExtended(b``%``a, a)  ` `    `  `    ``# Update x and y using results of recursive  ` `    ``# call  ` `    ``x ``=` `y1 ``-` `(b``/``/``a) ``*` `x1  ` `    ``y ``=` `x1  ` `    `  `    ``return` `gcd, x, y ` `     `  ` `  `# Driver code ` `a, b ``=` `35``,``15` `g, x, y ``=` `gcdExtended(a, b)  ` `print``(``"gcd("``, a , ``","` `, b, ``") = "``, g)  `

## C#

 `// C# program to demonstrate working  ` `// of extended Euclidean Algorithm ` `using` `System; ` ` `  `class` `GFG ` `{ ` `     `  `    ``// extended Euclidean Algorithm ` `    ``public` `static` `int` `gcdExtended(``int` `a, ``int` `b,  ` `                                  ``int` `x, ``int` `y) ` `    ``{ ` `        ``// Base Case ` `        ``if` `(a == 0) ` `        ``{ ` `            ``x = 0; ` `            ``y = 1; ` `            ``return` `b; ` `        ``} ` ` `  `        ``// To store results of ` `        ``// recursive call ` `        ``int` `x1 = 1, y1 = 1;  ` `        ``int` `gcd = gcdExtended(b % a, a, x1, y1); ` ` `  `        ``// Update x and y using  ` `        ``// results of recursive call ` `        ``x = y1 - (b / a) * x1; ` `        ``y = x1; ` ` `  `        ``return` `gcd; ` `    ``} ` `     `  `    ``// Driver Code ` `    ``static` `public` `void` `Main () ` `    ``{ ` `        ``int` `x = 1, y = 1; ` `        ``int` `a = 35, b = 15; ` `        ``int` `g = gcdExtended(a, b, x, y); ` `        ``Console.WriteLine(``"gcd("` `+ a + ``" , "` `+  ` `                              ``b + ``") = "` `+ g); ` `    ``} ` `} ` ` `  `// This code is contributed by m_kit `

## PHP

 ` `

Output :

`gcd(35, 15) = 5`

How does Extended Algorithm Work?

```As seen above, x and y are results for inputs a and b,
a.x + b.y = gcd                      ----(1)

And x1 and y1 are results for inputs b%a and a
(b%a).x1 + a.y1 = gcd

When we put b%a = (b - (⌊b/a⌋).a) in above,
we get following. Note that ⌊b/a⌋ is floor(b/a)

(b - (⌊b/a⌋).a).x1 + a.y1  = gcd

Above equation can also be written as below
b.x1 + a.(y1 - (⌊b/a⌋).x1) = gcd      ---(2)

After comparing coefficients of 'a' and 'b' in (1) and
(2), we get following
x = y1 - ⌊b/a⌋ * x1
y = x1
```

How is Extended Algorithm Useful?
The extended Euclidean algorithm is particularly useful when a and b are coprime (or gcd is 1). Since x is the modular multiplicative inverse of “a modulo b”, and y is the modular multiplicative inverse of “b modulo a”. In particular, the computation of the modular multiplicative inverse is an essential step in RSA public-key encryption method.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

54

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.