Euclidean algorithms (Basic and Extended)

Try it on GfG Practice

The Euclidean algorithm is a way to find the greatest common divisor of two positive integers. 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 prime factors.

Examples:

input: a = 12, b = 20
Output: 4
Explanation: The Common factors of (12, 20) are 1, 2, and 4 and greatest is 4.

input: a = 18, b = 33
Output: 3
Explanation: The Common factors of (18, 33) are 1 and 3 and greatest is 3.

Basic Euclidean Algorithm for GCD

The algorithm is based on the below facts. 

• If we subtract a smaller number from a larger one (we reduce a 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 the larger number, the algorithm stops when we find the remainder 0.

// C++ program to demonstrate working of 
// extended Euclidean Algorithm 
#include <bits/stdc++.h> 
using namespace std;

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

int main()  { 
    int a = 35, b = 15;
    int g = findGCD(a, b); 
    cout << g << endl;
    return 0; 
}

// C++ program to demonstrate working of 

// extended Euclidean Algorithm 

#include <bits/stdc++.h> 

using namespace std;

​

// Function to return

// gcd of a and b

int findGCD(int a, int b) {

    if (a == 0)

        return b;

    return findGCD(b % a, a);

}

​

int main()  { 

    int a = 35, b = 15;

    int g = findGCD(a, b); 

    cout << g << endl;

    return 0; 

}

// C program to demonstrate working of 
// extended Euclidean Algorithm 
#include <stdio.h>

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

int main() { 
    int a = 35, b = 15;
    int g = findGCD(a, b); 
    printf("%d\n", g);
    return 0; 
}

// Java program to demonstrate working of 
// extended Euclidean Algorithm 
class GFG {

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

    public static void main(String[] args) { 
        int a = 35, b = 15;
        int g = findGCD(a, b); 
        System.out.println(g);
    }
}

# Python program to demonstrate working of 
# extended Euclidean Algorithm 

# Function to return
# gcd of a and b
def findGCD(a, b):
    if a == 0:
        return b
    return findGCD(b % a, a)

# Main function
def main():
    a, b = 35, 15
    g = findGCD(a, b)
    print(g)

if __name__ == "__main__":
    main()

// C# program to demonstrate working of 
// extended Euclidean Algorithm 
using System;

class GFG {

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

    public static void Main() { 
        int a = 35, b = 15;
        int g = FindGCD(a, b); 
        Console.WriteLine(g);
    }
}

// JavaScript program to demonstrate working of 
// extended Euclidean Algorithm 

// Function to return
// gcd of a and b
function findGCD(a, b) {
    if (a === 0)
        return b;
    return findGCD(b % a, a);
}

function main() { 
    let a = 35, b = 15;
    let g = findGCD(a, b);
    console.log(g);
}

// Run the main function
main();

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

Time Complexity: O(log min(a, b))
Auxiliary Space: 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
Explanation: 30*1 + 20*(-1) = 10

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

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

ax + by = gcd(a, b)
gcd(a, b) = gcd(b%a, a)
gcd(b%a, a) = (b%a)x₁ + ay₁
ax + by = (b%a)x₁ + ay₁
ax + by = (b - [b/a] * a)x₁ + ay₁
ax + by = a(y₁ - [b/a] * x₁) + bx₁

Comparing LHS and RHS,
x = y₁ - [Tex]\lfloor b/a \rfloor[/Tex]* x₁
 y = x₁

// C++ program to demonstrate working of 
// extended Euclidean Algorithm 
#include <bits/stdc++.h> 
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; 
    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; 
} 

int findGCD(int a, int b) {

    int x = 1, y = 1;
    return gcdExtended(a, b, x, y);
}

int main()  { 
    int a = 35, b = 15;
    int g = findGCD(a, b); 
    cout << g << endl;
    return 0; 
} 

// C++ program to demonstrate working of 

// extended Euclidean Algorithm 

#include <bits/stdc++.h> 

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; 

    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; 

} 

​

int findGCD(int a, int b) {

​

    int x = 1, y = 1;

    return gcdExtended(a, b, x, y);

}

​

int main()  { 

    int a = 35, b = 15;

    int g = findGCD(a, b); 

    cout << g << endl;

    return 0; 

}

// C program to demonstrate working of 
// extended Euclidean Algorithm 
#include <stdio.h>

// 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; 
    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; 
} 

int findGCD(int a, int b) {

    int x = 1, y = 1;
    return gcdExtended(a, b, &x, &y);
}

int main() { 
    int a = 35, b = 15;
    int g = findGCD(a, b); 
    printf("%d\n", g);
    return 0; 
}

// Java program to demonstrate working of 
// extended Euclidean Algorithm 
class GFG {

    // Function for extended Euclidean Algorithm 
    static int gcdExtended(int a, int b, int[] x, int[] y) {

        // Base Case 
        if (a == 0) { 
            x[0] = 0; 
            y[0] = 1; 
            return b; 
        } 

        int[] x1 = {0}, y1 = {0}; 
        int gcd = gcdExtended(b % a, a, x1, y1); 

        // Update x and y using results of 
        // recursive call 
        x[0] = y1[0] - (b / a) * x1[0]; 
        y[0] = x1[0]; 
        return gcd; 
    } 

    static int findGCD(int a, int b) {
        int[] x = {1}, y = {1};
        return gcdExtended(a, b, x, y);
    }

    public static void main(String[] args) { 
        int a = 35, b = 15;
        int g = findGCD(a, b); 
        System.out.println(g);
    }
}

# Python program to demonstrate working of 
# extended Euclidean Algorithm 

# Function for extended Euclidean Algorithm 
def gcdExtended(a, b, x, y):

    # Base Case 
    if a == 0: 
        x[0] = 0
        y[0] = 1
        return b 

    x1, y1 = [0], [0]
    gcd = gcdExtended(b % a, a, x1, y1)

    # Update x and y using results of 
    # recursive call 
    x[0] = y1[0] - (b // a) * x1[0] 
    y[0] = x1[0] 
    return gcd 

def findGCD(a, b):
    x, y = [1], [1]
    return gcdExtended(a, b, x, y)

# Main function
def main():
    a, b = 35, 15
    g = findGCD(a, b)
    print(g)

if __name__ == "__main__":
    main()

// C# program to demonstrate working of 
// extended Euclidean Algorithm 
using System;

class GFG {

    // Function for extended Euclidean Algorithm 
    static int GcdExtended(int a, int b, ref int x, ref int y) {

        // Base Case 
        if (a == 0) { 
            x = 0; 
            y = 1; 
            return b; 
        } 

        int x1 = 0, y1 = 0; 
        int gcd = GcdExtended(b % a, a, ref x1, ref y1); 

        // Update x and y using results of 
        // recursive call 
        x = y1 - (b / a) * x1; 
        y = x1; 
        return gcd; 
    } 

    static int FindGCD(int a, int b) {
        int x = 1, y = 1;
        return GcdExtended(a, b, ref x, ref y);
    }

    public static void Main() { 
        int a = 35, b = 15;
        int g = FindGCD(a, b); 
        Console.WriteLine(g);
    }
}

// JavaScript program to demonstrate working of 
// extended Euclidean Algorithm 

// Function for extended Euclidean Algorithm 
function gcdExtended(a, b, x, y) {

    // Base Case 
    if (a === 0) { 
        x[0] = 0; 
        y[0] = 1; 
        return b; 
    } 

    let x1 = [0], y1 = [0]; 
    let gcd = gcdExtended(b % a, a, x1, y1); 

    // Update x and y using results of 
    // recursive call 
    x[0] = y1[0] - Math.floor(b / a) * x1[0]; 
    y[0] = x1[0]; 
    return gcd; 
} 

function findGCD(a, b) {
    let x = [1], y = [1];
    return gcdExtended(a, b, x, y);
}

// Main function
function main() {
    let a = 35, b = 15;
    let g = findGCD(a, b);
    console.log(g);
}

// Run the main function
main();

5

Time Complexity: O(log min(a, b))
Auxiliary Space: O(log (min(a,b)))

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 x₁ and y₁ are results for inputs b%a and a

(b%a).x₁ + a.y₁ = gcd   

When we put b%a = [Tex](b - (\lfloor b/a \rfloor).a)[/Tex] in above, 
we get following. Note that [Tex]\lfloor b/a\rfloor[/Tex] is floor(b/a)

[Tex](b - (\lfloor b/a \rfloor).a).x1 + a.y1  = gcd[/Tex]

Above equation can also be written as below

[Tex]b.x1 + a.(y1 - (\lfloor b/a \rfloor).x1) = gcd [/Tex]     ---(2)

After comparing coefficients of 'a' and 'b' in (1) and 
(2), we get following, 
[Tex]x = y1 - \lfloor b/a \rfloor * x1[/Tex]
y = x₁

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.