Program to find LCM of two numbers

Try it on GfG Practice

Given two positive integers a and b. Find the Least Common Multiple (LCM) of a and b.
LCM of two numbers is the smallest number which can be divided by both numbers. 

Input : a = 10, b = 5
Output : 10
Explanation : 10 is the smallest number divisible by both 10 and 5

Input : a = 5, b = 11
Output : 55
Explanation : 55 is the smallest number divisible by both 5 and 11

[Naive Approach] Using Conditional Loop

This approach to calculating the Least Common Multiple (LCM) involves starting from the greater of the two numbers and checking if it's divisible by the smaller number. It iterates through multiples of the larger number, incrementing by the larger number itself in each step. The first multiple that is divisible by the smaller number is the LCM. This method is simple and intuitive, but it can be inefficient, especially for large numbers, as it checks multiple values until a match is found.

#include <iostream>
#include <algorithm>
using namespace std;

int lcm(int a, int b) {
    
    // larger value
    int g = max(a, b);
    
    // Smaller value
    int s = min(a, b);
    
    for (int i = g; i <= a * b; i += g) {
        if (i % s == 0)
            return i;
    }
}

int main() {
    int a = 10, b = 5;
    cout << lcm(a, b);
    return 0;
}

#include <iostream>

#include <algorithm>

using namespace std;

​

int lcm(int a, int b) {

    // larger value

    int g = max(a, b);

    // Smaller value

    int s = min(a, b);

    for (int i = g; i <= a * b; i += g) {

        if (i % s == 0)

            return i;

    }

}

​

int main() {

    int a = 10, b = 5;

    cout << lcm(a, b);

    return 0;

}

class GfG {

    static int lcm(int a, int b) {
        
        // Larger value
        int g = Math.max(a, b); 
        
        // Smaller value
        int s = Math.min(a, b);

        for (int i = g; i <= a * b; i += g) {
            if (i % s == 0)
                return i;
        }
        return a * b; 
    }
    
    public static void main(String[] args) {
        int a = 10, b = 5;
        System.out.println(lcm(a, b)); 
    }
}

def lcm(a, b):
    
    # Larger value
    g = max(a, b) 
    
    # Smaller value
    s = min(a, b)  

    for i in range(g, a * b + 1, g):
        if i % s == 0:
            return i
    return a * b 

if __name__ == '__main__':
    a = 10
    b = 5
    print(lcm(a, b))  

using System;

class GfG
{
    static int LCM(int a, int b)
    {
        // Larger value
        int g = Math.Max(a, b); 
    
        // Smaller value
        int s = Math.Min(a, b); 

        for (int i = g; i <= a * b; i += g)
        {
            if (i % s == 0)
                return i;
        }
        return a * b;
    }

    static void Main()
    {
        int a = 10, b = 5;
        Console.WriteLine(LCM(a, b)); 
    }
}

function lcm(a, b) {
    
    // Larger value
    let g = Math.max(a, b);
    
    // Smaller value
    let s = Math.min(a, b); 

    for (let i = g; i <= a * b; i += g) {
        if (i % s === 0)
            return i;
    }
    return a * b; 
}

// Driver code
let a = 10, b = 5;
console.log(lcm(a, b));

10

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

[Expected Approach] Using GCD LCM Formula

An efficient solution is based on the below formula for LCM of two numbers 'a' and 'b'. 

a x b = LCM(a, b) * GCD (a, b)

LCM(a, b) = (a x b) / GCD(a, b)

We have discussed function to find GCD of two numbers. Using GCD, we can find LCM. 

#include <iostream>
using namespace std;

// function for gcd
int gcd(int a, int b) {
    return (b == 0) ? a : gcd(b, a % b);
}

int lcm(int a, int b) {
    return (a / gcd(a, b)) * b;
}

int main() {
    int a = 10, b = 5;
    cout << lcm(a, b); 
    return 0;
}

#include <iostream>

using namespace std;

​

// function for gcd

int gcd(int a, int b) {

    return (b == 0) ? a : gcd(b, a % b);

}

​

int lcm(int a, int b) {

    return (a / gcd(a, b)) * b;

}

​

int main() {

    int a = 10, b = 5;

    cout << lcm(a, b); 

    return 0;

}

class GfG {
    
    // function for gcd 
    static int gcd(int a, int b) {
        return (b == 0) ? a : gcd(b, a % b);
    }

    static int lcm(int a, int b) {
        return (a / gcd(a, b)) * b;
    }

    public static void main(String[] args) {
        int a = 10, b = 5;
        System.out.println(lcm(a, b)); 
    }
}

# function for gcd
def gcd(a, b):
    return a if b == 0 else gcd(b, a % b)

def lcm(a, b):
    return (a // gcd(a, b)) * b

if __name__ == '__main__':
    a = 10
    b = 5
    print(lcm(a, b)) 

using System;

class GfG
{
    static int gcd(int a, int b)
    {
        return b == 0 ? a : gcd(b, a % b);
    }

    static int lcm(int a, int b)
    {
        return (a / gcd(a, b)) * b;
    }

    static void Main()
    {
        int a = 10, b = 5;
        Console.WriteLine(lcm(a, b)); 
    }
}

// function for gcd
function gcd(a, b) {
    return b === 0 ? a : gcd(b, a % b);
}

function lcm(a, b) {
    return (a / gcd(a, b)) * b;
}

// Driver code
let a = 10, b = 5;
console.log(lcm(a, b)); 

10

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