GCD and LCM Calculator - Problem

Write two functions to calculate the Greatest Common Divisor (GCD) and Least Common Multiple (LCM) of two positive integers.

The GCD should be implemented using the Euclidean algorithm, which repeatedly applies the formula: gcd(a, b) = gcd(b, a % b) until one number becomes zero.

The LCM should be calculated using the relationship: lcm(a, b) = (a × b) / gcd(a, b)

Return both values as an array [gcd, lcm].

Input & Output

Example 1 — Basic Case

$ Input: a = 48, b = 18

› Output: [6, 144]

💡 Note: GCD(48, 18): 48 = 18×2 + 12, 18 = 12×1 + 6, 12 = 6×2 + 0. So GCD = 6. LCM = (48×18)/6 = 864/6 = 144

Example 2 — Co-prime Numbers

$ Input: a = 15, b = 28

› Output: [1, 420]

💡 Note: 15 and 28 share no common factors except 1, so GCD = 1. LCM = (15×28)/1 = 420

Example 3 — One Divides Other

$ Input: a = 20, b = 5

› Output: [5, 20]

💡 Note: Since 5 divides 20 evenly, GCD = 5 (the smaller number). LCM = 20 (the larger number)

Constraints

1 ≤ a, b ≤ 10⁶
Both numbers are positive integers

Visualization

Tap to expand

Asked in

M Microsoft 25 a Amazon 20 G Google 18

The key insight is using the Euclidean algorithm which repeatedly applies gcd(a,b) = gcd(b, a%b) until one number becomes zero. Best approach is the iterative Euclidean algorithm for optimal performance without recursion overhead. Time: O(log(min(a,b))), Space: O(1)

Common Approaches

✓ Brute Force Iteration

⏱️ Time: O(min(a,b)) Space: O(1)

Iterate through all possible divisors from 1 to min(a,b) and find the largest number that divides both. Then calculate LCM using the formula.

Euclidean Algorithm (Iterative)

⏱️ Time: O(log(min(a,b))) Space: O(1)

Apply the Euclidean algorithm iteratively: repeatedly replace the larger number with the remainder when divided by the smaller number until one becomes zero.

Recursive Euclidean Algorithm

⏱️ Time: O(log(min(a,b))) Space: O(log(min(a,b)))

Implement the Euclidean algorithm recursively with the base case when b becomes 0, making the code more elegant and mathematically intuitive.

Brute Force Iteration — Algorithm Steps

Step 1: Start with gcd = 1, iterate i from 1 to min(a,b)
Step 2: If both a and b are divisible by i, update gcd = i
Step 3: Calculate LCM using formula (a * b) / gcd

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with gcd = 1, check divisors 1 to min(48,18)=18

Check Each

For each i: if 48%i==0 AND 18%i==0, update gcd=i

Calculate

Found gcd=6, so lcm = (48×18)/6 = 144

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

void solution(int a, int b, int* result) {
    int gcd = 1;
    int minVal = (a < b) ? a : b;
    
    // Find GCD by checking all numbers from 1 to min(a,b)
    for (int i = 1; i <= minVal; i++) {
        if (a % i == 0 && b % i == 0) {
            gcd = i;
        }
    }
    
    // Calculate LCM using the relationship
    int lcm = (a * b) / gcd;
    result[0] = gcd;
    result[1] = lcm;
}

int main() {
    int a, b;
    scanf("%d", &a);
    scanf("%d", &b);
    
    int result[2];
    solution(a, b, result);
    printf("[%d,%d]\n", result[0], result[1]);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(min(a,b))

Single loop from 1 to the minimum of both numbers

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables for calculations

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

GCD and LCM Calculator - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Iteration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler