The Greatest Common Divisor (GCD) of two numbers is the largest positive integer that divides both numbers without leaving a remainder. It is also known as the greatest common factor (GCF) or highest common factor (HCF). Python provides several ways to calculate the GCD of two numbers, including using loops, recursion, and the built-in `math`

module.

## Method 1: Using the Euclidean Algorithm

The Euclidean algorithm is a well-known method for finding the GCD of two numbers. It works on the principle that the GCD of two numbers also divides their difference. The algorithm can be implemented using a loop or recursion.

### Implementation using a Loop

```
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
# Example usage:
num1 = 48
num2 = 18
result = gcd(num1, num2)
print(f"The GCD of {num1} and {num2} is {result}.")
```

### Implementation using Recursion

```
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a % b)
# Example usage:
num1 = 48
num2 = 18
result = gcd(num1, num2)
print(f"The GCD of {num1} and {num2} is {result}.")
```

## Method 2: Using Python’s `math`

Module

Python’s `math`

module provides a built-in function `gcd()`

to calculate the greatest common divisor. This is the most straightforward method to find the GCD in Python.

```
import math
# Example usage:
num1 = 48
num2 = 18
result = math.gcd(num1, num2)
print(f"The GCD of {num1} and {num2} is {result}.")
```

## Explanation of the Code

`gcd(a, b)`

function: This function takes two integers`a`

and`b`

as input and returns their GCD.`a % b`

: The modulus operation finds the remainder of the division of`a`

by`b`

. This is used to repeatedly reduce the problem until one of the numbers becomes zero.`math.gcd(a, b)`

: This is the built-in function provided by Python’s`math`

module to compute the GCD.

## Complexity Analysis

The time complexity of the Euclidean algorithm is O(log(min(a, b))) because the size of the numbers decreases rapidly with each step. The space complexity is O(1) when using the loop-based implementation and O(log(min(a, b))) when using recursion due to the call stack.

## Use Cases of GCD

**Fractions Simplification:**The GCD is used to simplify fractions by dividing both the numerator and denominator by their GCD.**Coprime Check:**Two numbers are coprime if their GCD is 1. This property is useful in cryptography and number theory.**LCM Calculation:**The Least Common Multiple (LCM) of two numbers can be calculated using their GCD with the formula:`LCM(a, b) = abs(a * b) // GCD(a, b)`

.