# Programmatically Calculating GCD and LCM

I recently came across a really interesting technique for calculating GCD (greatest common divisor) and then found out you can use that to calculate LCM (least common multiple).

## Greatest Common Divisor

The greatest common divisor of two numbers is the largest number that divides evenly into those numbers.

For instance the GCD of 12 and 15 is 3, the GCD of 30 and 20 is 10, and the GCD of 7 and 11 is 1.

You could calculate this with brute force – starting with 1 and counting up to the smaller number, keeping track of the largest number that divides evenly into both numbers – but for larger numbers, this technique could take a long time.

Luckily Euclid came up a better way in 300 BC!

Euclid’s algorithm to find the GCD of numbers A and B:

1. If A and B are the same number, that number is the GCD
2. Otherwise, subtract the smaller number from the larger number
3. Goto 1

Pretty simple right? It’s not immediately intuitive why that works, but as an example let’s say that there’s a number that goes into A fives times, and goes into B three times. That same number must go into (A-B) two times.

Try it out on paper, think about it a bit, and check out the links at the end of this section (:

A refinement on that algorithm is to use remainder (modulus) instead of possibly having to do repeated subtraction to get the same result. For instance if you had the numbers 1015 and 2, you are going to have to subtract 2 from 1015 quite a few times before the 2 becomes the larger number.

Here’s the refined algorithm:

1. If A and B are the same number, that number is the GCD
2. Otherwise, set the larger number to be the remainder of the larger number divided by the smaller number
3. Goto 1

And here’s the C++ code:

```#include <stdio.h>
#include <algorithm>

unsigned int CalculateGCD (unsigned int smaller, unsigned int larger)
{
// make sure A <= B before starting
if (larger < smaller)
std::swap(smaller, larger);

// loop
while (1)
{
// if the remainder of larger / smaller is 0, they are the same
// so return smaller as the GCD
unsigned int remainder = larger % smaller;
if (remainder == 0)
return smaller;

// otherwise, the new larger number is the old smaller number, and
// the new smaller number is the remainder
larger = smaller;
smaller = remainder;
}
}

void WaitForEnter ()
{
printf("nPress Enter to quit");
fflush(stdin);
getchar();
}

void main (void)
{
// Get A
printf("Greatest Common Devisor Calculator, using Euclid's algorithm!n");
printf("nFirst number? ");
unsigned int A = 0;
if (scanf("%u",&A) == 0 || A == 0) {
printf("nMust input a positive integer greater than 0!");
WaitForEnter();
return;
}

// Get B
printf("Second number? ");
unsigned int B = 0;
if (scanf("%u",&B) == 0 || B == 0) {
printf("nMust input a positive integer greater than 0!");
WaitForEnter();
return;
}

// show the result
printf("nGCD(%u,%u) = %un", A, B, CalculateGCD(A,B));

// wait for user to press enter
WaitForEnter();
}
```

That book is filled with amazing treasures of knowledge and interesting stories to boot. I highly suggest flipping to a couple random chapters and reading it a bit. Very cool stuff in there (:

You might also find these links interesting or useful!
Wikipedia: Greatest Common Divisor
Wikipedia: Euclidean Algorithm

I’m sure there’s a way to extend this algorithm to work for N numbers at a time instead of only 2 numbers. I’ll leave that as a fun exercise for you if you want to play with that 😛

## Least Common Multiple

The least common multiple of two numbers is the smallest number that is evenly divisible by those numbers.

Kind of an ear full so some examples: The LCM of 3 and 4 is 12, the LCM of 1 and 7 is 7, the LCM of 20 and 35 is 140. Note that in the first two examples, the LCM is just the two numbers multiplied together, but in the 3rd example it isn’t (also an interesting thing of note is that the first 2 examples have a GCD of 1, while the 3rd example has a GCD of 5).

Well interestingly, calculating the LCM is super easy if you already know how to calculate the GCD. You just multiply the numbers together and divide by the GCD.

LCM(A,B) = (A*B) / GCD(A,B)

Interestingly though, GCD(A,B) divides evenly into both A and B and will result in an integer result. This means we can multiply by A or B after the division happens and get the exact same answer. More importantly though, it helps protect you against integer overflow in the A*B calculation. Using that knowledge the equation becomes this:

LCM(A,B) = (A / GCD(A,B))*B

Pretty neat! Here’s some C++ code that calculates LCM.

```#include <stdio.h>
#include <algorithm>

unsigned int CalculateGCD (unsigned int smaller, unsigned int larger)
{
// make sure A <= B before starting
if (larger < smaller)
std::swap(smaller, larger);

// loop
while (1)
{
// if the remainder of larger / smaller is 0, they are the same
// so return smaller as the GCD
unsigned int remainder = larger % smaller;
if (remainder == 0)
return smaller;

// otherwise, the new larger number is the old smaller number, and
// the new smaller number is the remainder
larger = smaller;
smaller = remainder;
}
}

unsigned int CalculateLCM (unsigned int A, unsigned int B)
{
// LCM(A,B) = (A/GCD(A,B))*B
return (A/CalculateGCD(A,B))*B;
}

void WaitForEnter ()
{
printf("nPress Enter to quit");
fflush(stdin);
getchar();
}

void main (void)
{
// Get A
printf("Least Common Multiple Calculator, using Euclid's algorithm for GCD!n");
printf("nFirst number? ");
unsigned int A = 0;
if (scanf("%u",&A) == 0 || A == 0) {
printf("nMust input a positive integer greater than 0!");
WaitForEnter();
return;
}

// Get B
printf("Second number? ");
unsigned int B = 0;
if (scanf("%u",&B) == 0 || B == 0) {
printf("nMust input a positive integer greater than 0!");
WaitForEnter();
return;
}

// show the result
printf("nLCM(%u,%u) = %un", A, B, CalculateLCM(A,B));

// wait for user to press enter
WaitForEnter();
}
```

Extending this to N numbers could be an interesting thing to try too (:

Here’s tasty link about LCM: Wikipedia: Least Common Multiple

## Compile Time GCD and LCM

I’ve just heard that a compile time GCD and LCM implementation has been recomended for the STL. Check out the link below, kinda neat!

Greatest Common Divisor and Least Common Multiple

TTFN.