Lcm of Two Numbers in C

In computer science and mathematics, understanding and implementing the concept of finding the Least Common Multiple (LCM) of two numbers is fundamental. It plays a critical role in various computations and algorithms, making it a commonly addressed problem in coding interviews. This article elaborates on the concept of LCM and how to write an algorithm to find LCM of two numbers in C programming language.

What is LCM?

The Least Common Multiple (LCM) of two or more integers is the smallest non-zero number that is a multiple of each of these integers. In other terms, it's the smallest common multiple of the integers. For instance, consider the numbers 4 and 5. The multiples of 4 are 4, 8, 12, 16, 20, 24, 28, 32, etc., and the multiples of 5 are 5, 10, 15, 20, 25, 30, 35, etc. The smallest number that appears in both lists of multiples is 20. Therefore, the LCM of 4 and 5 is 20.

To provide another example, consider the numbers 6 and 8. The multiples of 6 are 6, 12, 18, 24, 30, 36, 42, 48, etc., and the multiples of 8 are 8, 16, 24, 32, 40, 48, etc. The smallest common multiple of both is 24, so the LCM of 6 and 8 is 24.

Purpose of finding LCM of two numbers

The purpose of finding the LCM of two numbers is to determine the smallest positive integer that is divisible by both numbers without leaving a remainder. It is often used in various mathematical computations, such as simplifying fractions, solving equations involving fractions, and working with repeating patterns or cycles. In computer science and programming, the LCM is used in tasks like scheduling, time synchronisation, and optimisation problems.

Ways for Writing LCM Program in C

There are multiple approaches to writing a program in the C programming language to calculate the LCM of two numbers. In this article, we will explore two commonly used methods:

1. Using GCD (Greatest Common Divisor)
2. Using Prime Factorization

Both methods have their advantages and can be implemented based on the specific requirements and constraints of the problem.

Algorithm to Find LCM

The algorithm to obtain the LCM of two numbers is as follows:

1. Read the two numbers, let's say num1 and num2.
2. Calculate the Greatest Common Divisor (GCD) of the two numbers using the Euclidean algorithm and store it in gcd.
3. Use the formula: LCM = (num1 * num2) / GCD
4. Output the calculated LCM as a result.

By calculating and using the GCD in the formula, the algorithm ensures that the LCM is obtained efficiently and accurately. The LCM is a useful value in various mathematical computations and can be applied in fields such as number theory, abstract algebra, and computer science.

Pseudo code to find LCM

Here's the pseudo-code representing the algorithm to find the LCM of two numbers:

1. Read num1, num2 from the user.

2. Calculate the GCD of num1 and num2 using the Euclidean algorithm and store it in gcd.

3. Calculate LCM using the formula: lcm = (num1 * num2) / gcd.

4. Print lcm as the LCM of num1 and num2.

Method 1: Using GCD to find LCM

This method utilises the concept of the Greatest Common Divisor (GCD) to find the LCM. The steps involved in this method are:

1. Find the GCD of the two numbers using the Euclidean algorithm or its recursive implementation.
2. Calculate the LCM using the formula: LCM = (num1 * num2) / GCD.

Example program to find LCM of two numbers using GCD

Given below is the program to find LCM of two numbers in C by using the Greatest Common Divisor (GCD) method:

#include <stdio.h>

// Function to calculate GCD
int calculateGCD(int num1, int num2) {
    if (num2 == 0)
        return num1;
    else
        return calculateGCD(num2, num1 % num2);
}

// Function to calculate LCM using GCD
int calculateLCM(int num1, int num2) {
    int gcd = calculateGCD(num1, num2);
    int lcm = (num1 * num2) / gcd;
    return lcm;
}

// Main function
int main() {
    int num1, num2;
    printf("Enter two numbers: ");
    scanf("%d %d", &num1, &num2);
    int lcm = calculateLCM(num1, num2);
    printf("LCM of %d and %d is %d\n", num1, num2, lcm);
    return 0;
}

Time complexity of this method

The time complexity of this method is dependent on the time complexity of the GCD calculation algorithm. The Euclidean algorithm comprises a time complexity of O(log(min(num1, num2))), where num1 and num2 are the given numbers. Therefore, the overall time complexity of finding the LCM using GCD is also O(log(min(num1, num2))).

Method 2: Using Prime Factorization to find LCM

This method involves finding the prime factors of the two numbers and then computing the LCM by considering the highest power of each prime factor present in both numbers. The steps involved in this method are:

1. Find the prime factors of both numbers.
2. Determine the highest power for each prime factor that displays in either number.
3. Multiply the acquired highest powers to get the LCM.

Example program to find LCM of two numbers using prime factorization

Given below is the program to find lcm of two numbers in C by using the prime factorization method:

#include <stdio.h>

// Function to calculate LCM using prime factorization
int calculateLCM(int num1, int num2) {
    int lcm = 1;
    int factor = 2; // Start with the smallest prime factor

    while (num1 > 1 || num2 > 1) {
        // Check whether the current factor divides either number
        if (num1 % factor == 0 || num2 % factor == 0) {
            lcm *= factor; // Multiply the factor to the LCM
            // Divide both numbers by the factor as many times as possible
            if (num1 % factor == 0)
                num1 /= factor;
            if (num2 % factor == 0)
                num2 /= factor;
        } else {
            factor++; // Move to the next prime factor
        }
    }

    return lcm;
}

// Main function
int main() {
    int num1, num2;
    printf("Enter two numbers: ");
    scanf("%d %d", &num1, &num2);
    int lcm = calculateLCM(num1, num2);
    printf("LCM of %d and %d is %d\n", num1, num2, lcm);
    return 0;
}

Time complexity of this method

The time complexity of finding the LCM using prime factorization is determined by the prime factorization algorithm. Assuming the numbers are not very large, the algorithm typically has a time complexity of O(sqrt(N)), where N is the maximum of the two numbers. Therefore, the overall time complexity of this method is O(sqrt(N)).

Comparison of Methods

When it comes to a program to find lcm of two numbers in C, there are two commonly used methods: using the Greatest Common Divisor (GCD) and employing prime factorization. Let's compare these methods in terms of time complexity, applicability, and other factors:

The GCD method has a time complexity of O(log(min(num1, num2))), making it efficient for most cases. It is relatively simple to implement and suitable for small and large numbers. However, it requires an additional calculation of the GCD.

On the other hand, the prime factorization method has a time complexity of O(sqrt(N)), where N is the maximum of the two numbers. This method provides the prime factorization of the numbers as a byproduct, which can be useful in certain situations. However, it becomes inefficient when dealing with extremely large numbers.

Overall, the choice of method depends on the specific requirements and constraints of the problem at hand. In most cases, the GCD method is a popular and efficient choice. However, if prime factorization is needed or deals with small to moderate numbers, the prime factorization method may be preferred.

It's important to analyse the problem and consider factors like time complexity, number size, and other requirements before selecting the appropriate method for finding the LCM of two numbers.

Conclusion

Calculating the LCM of two numbers is an essential skill in programming and mathematics. In this article, we explored two popular methods, namely using the Greatest Common Divisor (GCD) and prime factorization, to find the LCM in the C programming language. Both methods offer efficient solutions for different scenarios.

By understanding these methods, you can confidently handle LCM calculations in your programs. To further enhance your programming skills and expand your knowledge, consider checking out Full Stack Software Development Bootcamp by upGrad. With guidance from industry veterans and immersive learning experiences, upGrad nurtures your development skills with the right programming knowledge, helping you bag exciting opportunities.

Mastering LCM calculations is just one step toward becoming a proficient programmer. Continuous learning and practice are key to unlocking your full potential!

FAQs

Q: What is the LCM of three or more numbers?

The LCM of three or more numbers is the smallest positive integer divisible by each given number without leaving a remainder. It can be calculated by finding the LCM of two numbers at a time iteratively.

Q: Is the LCM of two numbers always greater than or equal to the numbers themselves?

Yes, the LCM of two numbers is always greater than or equal to the numbers themselves. This is because the LCM must be a multiple of both numbers and should be divisible by each of them.

Q: Can the LCM of two numbers be zero?

No, the LCM of the two figures cannot be zero. The LCM is defined as the smallest positive integer that should be divisible by both numbers. Therefore, it will always be greater than zero.

Q: Is it possible to find the LCM of negative numbers?

Yes, the concept of LCM can be applied to negative numbers as well. The absolute values of the numbers are used to calculate the LCM, and the signs of the input numbers determine the sign of the result.

Q: Can the LCM of two numbers be equal to one of the numbers?

Yes, the LCM of two numbers can be equal to one of the numbers. This occurs when one number is a multiple of the other, making the larger number itself the LCM.

Q: Are there any built-in functions in C to calculate the LCM?

No, C does not have a built-in function specifically for calculating the LCM. However, you can implement your own functions or use external libraries that provide LCM calculations.