Related Articles

# Java Program to Compute GCD

• Last Updated : 26 Nov, 2020

GCD (Greatest Common Divisor) of two given numbers A and B is the highest number that can divide both A and B completely, i.e., leaving remainder 0 in each case. GCD is also called HCF(Highest Common Factor). There are various approaches to find the GCD of two given numbers.

Approaches:

The GCD of the given two numbers A and B can be calculated using different approaches.

1. General method
2. Euclidean algorithm (by repeated subtraction)
3. Euclidean algorithm (by repeated division)

Examples:

```Input: 20, 30
Output: GCD(20, 30) = 10
Explanation: 10 is the highest integer which divides both 20 and 30 leaving 0 remainder

Input: 36, 37
Output: GCD(36, 37) = 1
Explanation: 36 and 37 don't have any factors in common except 1. So, 1 is the gcd of 36 and 37```

Note: gcd(A, B) = 1 if A, B are co-primes.

General Approach:

In the general approach of computing GCD, we actually implement the definition of GCD.

• First, find out all the factors of A and B individually.
• Then list out those factors which are common for both A and B.
• The highest of those common factors is the GCD of A and B.

Example:

```A = 20, B = 30
Factors of A : (1, 2, 4, 5, 10, 20)
Factors of B : (1, 2, 3, 5, 6, 10, 15, 30)
Common factors of A and B : (1, 2, 5, 10)
Highest of the Common factors (GCD) = 10```

It is clear that the GCD of 20 and 30 can’t be greater than 20. So we have to check for the numbers within the range 1 and 20. Also, we need the greatest of the divisors. So, iterate from backward to reduce computation time.

## Java

 `// Java program to compute GCD of``// two numbers using general``// approach``import` `java.io.*;` `class` `GFG {` `    ``// gcd() method, returns the GCD of a and b``    ``static` `int` `gcd(``int` `a, ``int` `b)``    ``{``        ``// stores minimum(a, b)``        ``int` `i;``        ``if` `(a < b)``            ``i = a;``        ``else``            ``i = b;` `        ``// take a loop iterating through smaller number to 1``        ``for` `(i = i; i > ``1``; i--) {` `            ``// check if the current value of i divides both``            ``// numbers with remainder 0 if yes, then i is``            ``// the GCD of a and b``            ``if` `(a % i == ``0` `&& b % i == ``0``)``                ``return` `i;``        ``}` `        ``// if there are no common factors for a and b other``        ``// than 1, then GCD of a and b is 1``        ``return` `1``;``    ``}``    ``// Driver method``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `a = ``30``, b = ``20``;` `        ``// calling gcd() method over``        ``// the integers 30 and 20``        ``System.out.println(``"GCD = "` `+ gcd(b, a));``    ``}``}`
Output
`GCD = 10`

Euclidean algorithm (repeated subtraction):

This approach is based on the principle that the GCD of two numbers A and B will be the same even if we replace the larger number with the difference between A and B. In this approach, we perform GCD operation on A and B repeatedly by replacing A with B and B with the difference(A, B) as long as the difference is greater than 0.

Example

```A = 30, B = 20
gcd(30, 20) -> gcd(A, B)
gcd(20, 30 - 20) = gcd(20,10) -> gcd(B,B-A)
gcd(30 - 20, 20 - (30 - 20)) = gcd(10, 10) -> gcd(B - A, B - (B - A))
gcd(10, 10 - 10) = gcd(10, 0)
here, the difference is 0
So stop the procedure. And 10 is the GCD of 30 and 20```

## Java

 `// Java program to compute GCD``// of two numbers using Euclid's``// repeated subtraction approach``import` `java.io.*;` `class` `GFG {` `    ``// gcd method returns the GCD of a and b``    ``static` `int` `gcd(``int` `a, ``int` `b)``    ``{``        ``// if b=0, a is the GCD``        ``if` `(b == ``0``)``            ``return` `a;` `        ``// call the gcd() method recursively by``        ``// replacing a with b and b with``        ``// difference(a,b) as long as b != 0``        ``else``            ``return` `gcd(b, Math.abs(a - b));``    ``}` `    ``// Driver method``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `a = ``30``, b = ``20``;` `        ``// calling gcd() over``        ``// integers 30 and 20``        ``System.out.println(``"GCD = "` `+ gcd(a, b));``    ``}``}`
Output
`GCD = 10`

Euclidean algorithm (repeated division):

This approach is similar to the repeated subtraction approach. But, in this approach, we replace B with the modulus of A and B instead of the difference.

Example :

```A = 30, B = 20
gcd(30, 20) -> gcd(A, B)
gcd(20, 30 % 20) = gcd(20, 10) -> gcd(B, A % B)
gcd(10, 20 % 10) = gcd(10, 10) -> gcd(A % B, B % (A % B))
gcd(10, 10 % 10) = gcd(10, 0)
here, the modulus became 0
So, stop the procedure. And 10 is the GCD of 30 and 20```

## Java

 `// Java program to compute GCD``// of two numbers using Euclid's``// repeated division approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG {` `    ``// gcd method returns the GCD of a and b``    ``static` `int` `gcd(``int` `a, ``int` `b)``    ``{``        ``// if b=0, a is the GCD``        ``if` `(b == ``0``)``            ``return` `a;` `        ``// call the gcd() method recursively by``        ``// replacing a with b and b with``        ``// modulus(a,b) as long as b != 0``        ``else``            ``return` `gcd(b, a % b);``    ``}``    ``// Driver method``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `a = ``20``, b = ``30``;` `        ``// calling gcd() over``        ``// integers 30 and 20``        ``System.out.println(``"GCD = "` `+ gcd(a, b));``    ``}``}`
Output
`GCD = 10`

Euclid’s repeated division approach is most commonly used among all the approaches.

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up