Given GCD G and LCM L, find number of possible pairs (a, b)

Last Updated : 23 Jul, 2025

We need to find number of possible pairs (a, b) such that GCD(a, b) is equal to given G and LCM (a, b) such that LCM(a, b) is equal to given L.
Examples: 
 

Input : G = 2, L = 12
Output : 4
Explanation : There are 4 possible pairs :
 (2, 12), (4, 6), (6, 4), (12, 2)


 

Input : G = 3, L = 6
Output : 2
Explanation : There are 2 possible pairs :
(3, 6), (6, 3)


 

Recommended Practice
Possible Pairs
Try It!


 

Solution 1 (Simple):


Since a and b both will be less than or equal to lcm(a, b) L, so we try all possible pairs that have product equal to L * G. Note that product of a and b is same as product of gcd(a, b) and lcm(a, b), a*b = G*L.
Here is our algorithm 
 

p = G*L
count = 0
for a = 1 to L
    if p%a == 0 and gcd(a, p/a) = G
        count++
    end if
end for
return count


 

Try It Yourself
redirect icon
C++ 
// C++ program to find all pairs 
// with given GCD and LCM. 
#include <iostream> 
using namespace std; 

// C++ function to calculate GCD 
// of two numbers 
int gcd(int a, int b) 
{ 
    if (a == 0) 
        return b; 
    return gcd(b%a, a); 
} 

// C++ function to count number 
// of pairs with given GCD and LCM 
int countPairs(int G, int L) 
{ 
    // To store count 
    int count = 0; 

    // To store product a*b = G*L 
    int p = G*L; 

    // p/a will be b if a divides p 
    for (int a=1; a<=L; a++) 
        if (!(p%a) && gcd(a, p/a)==G) 
            count++; 

    return count; 
} 

// Driver code to test above functions 
int main() 
{ 
    int G = 2, L = 12; 
    cout << "Total possible pair with GCD " << G; 
    cout << " & LCM " << L; 
    cout <<" = " << countPairs(G, L); 
    return 0; 
}
Java 
// Java program to find all pairs
// with given GCD and LCM.
public class GCD
{
    // Java function to calculate GCD
    // of two numbers
    static int gcd(int a, int b)
    {
        if (a == 0)
            return b;
        return gcd(b%a , a);
    }
    
    // Java function to count number 
    // of pairs with given GCD and LCM
    static int countPairs(int G, int L)
    {
        // To store count
        int count = 0;
        
        // To store product a*b = G*L
        int p = G*L;
        
        // p/a will be b if a divides p
        for (int a = 1; a<=L; a++)
            if ((p%a == 0) && gcd(a, p/a) == G)
                count++;
                
       return count;
    }
    
    public static void main (String[] args)
    {
        int G = 2, L = 12;
        System.out.print("Total possible pair with GCD " + G);
        System.out.print(" & LCM " + L);
        System.out.print(" = " + countPairs(G, L));
        
    }
    
}

// This code is contributed by Saket Kumar
Python3 
# Python3 program to find all pairs
# with given GCD and LCM.
import math

# Function to calculate GCD
# of two numbers
def gcd(a, b):

    if (a == 0):
        return b
    return math.gcd(b % a, a)

# Function to count number of 
# pairs with given GCD and LCM
def countPairs(G, L):

    # To store count
    count = 0

    # To store product a*b = G*L
    p = G * L

    # p/a will be b if a divides p
    for a in range(1, L + 1):
        if (not (p % a) and 
            math.gcd(a, p // a) == G):
            count += 1

    return count

# Driver Code
if __name__ == "__main__":

    G = 2
    L = 12
    print ("Total possible pair with GCD ", 
                               G, end = "")
    print (" & LCM ", L, end = "")
    print (" = ", countPairs(G, L))

# This code is contributed by ita_c
C# 
// C# program to find all pairs
// with given GCD and LCM.
using System;

class GCD
{
    
    // function to calculate 
    // GCD of two numbers
    static int gcd(int a, int b)
    {
        if (a == 0)
            return b;
        return gcd(b % a , a);
    }
    
    // Function to count number of  
    // pairs with given GCD and LCM
    static int countPairs(int G, int L)
    {
        
        // To store count
        int count = 0;
        
        // To store product a * 
        // b = G * L
        int p = G * L;
        
        // p / a will be b if 
        // a divides p
        for (int a = 1; a <= L; a++)
            if ((p % a == 0) && 
                 gcd(a, p / a) == G)
                count++;
                
    return count;
    }
    
    // Driver Code
    public static void Main ()
    {
        int G = 2, L = 12;
        Console.Write("Total possible pair with GCD " + G);
        Console.Write(" & LCM " + L);
        Console.Write(" = " + countPairs(G, L));
        
    }
    
}

// This code is contributed by Nitin Mittal.
PHP 
<?php
// PHP program to find all pairs
// with given GCD and LCM.

// function to calculate GCD
// of two numbers
function gcd($a, $b)
{
    if ($a == 0)
        return $b;
    return gcd($b % $a, $a);
}

// function to count number
// of pairs with given GCD and LCM
function countPairs( $G, $L)
{
    
    // To store count
    $count = 0;

    // To store product a*b = G*L
    $p = $G * $L;

    // p/a will be b if a divides p
    for ($a = 1; $a <= $L; $a++)
        if (!($p % $a) and 
           gcd($a, $p / $a) == $G)
            $count++;

    return $count;
}

    // Driver Code
    $G = 2; 
    $L = 12;
    echo "Total possible pair with GCD " , $G;
    echo " & LCM " , $L;
    echo " = " , countPairs($G, $L);

// This code is contributed by anuj_67.
?>
JavaScript 
<script>
// javascript program to find all pairs
// with given GCD and LCM.

// javascript function to calculate GCD
    // of two numbers
    function gcd(a , b) {
        if (a == 0)
            return b;
        return gcd(b % a, a);
    }

// javascript function to count number
    // of pairs with given GCD and LCM
    function countPairs(G , L) {
        // To store count
        var count = 0;

        // To store product a*b = G*L
        var p = G * L;

        // p/a will be b if a divides p
        for (let a = 1; a <= L; a++)
            if ((p % a == 0) && gcd(a, p / a) == G)
                count++;

        return count;
    }

        var G = 2, L = 12;
        document.write("Total possible pair with GCD " + G);
        document.write(" & LCM " + L);
        document.write(" = " + countPairs(G, L));

// This code is contributed by todaysgaurav 
</script>

Output
Total possible pair with GCD 2 & LCM 12 = 4


Auxiliary Space : O(1) 
Time Complexity: O( L * log(L) ). We have one for loop which iterates L times and in each iteration in the worst case, gcd will be called so O(log L) in the worst case for that call.
 

Solution 2 (Efficient):

We know that G * L = a * b
Since G is gcd(a, b), both a and b will have G as its factor
Let A = a/G
Let B = b/G

From above definitions of A and B, GCD of A and B must be 1.
We can write, a = G * A, b = G * B

G * L = G * A * G * B
A * B = L / G
Now, we need to find all possible pairs of (A, B)
such that gcd(A, B) = 1 and A*B = L/G
Let say p1, p2, ..., pk are prime factors of L/G.
Then if p1 is present in prime factorization of A then p1
can't be present in prime factorization of B because 
gcd(A, B) = 1.
Therefore each prime factor pi will be present in either
A or B. Hence total possible ways to divide all prime 
factors among A and B is 2^k, where L/G has k distinct 
prime factors.


Below is implementation of above steps.
 

C++ 
// Efficient C++ program to count all          
// pairs with GCD and LCM.          
#include <iostream>          
using namespace std;          
// A function to find number of distinct          
// prime factors of a given number n          
int totalPrimeFactors(int n)          
{          
 // To keep track of count          
 int count = 0;          
 // 2s that divide n          
 if (!(n%2))          
 {          
 count++;          
 while (!(n%2))          
 n /= 2;          
 }          
 // n must be odd at this point. So we can skip          
 // one element (Note i = i +2)          
 for (int i = 3; i*i <= n; i = i+2)          
 {          
 // i divides n          
 if (!(n%i))          
 {          
 count++;          
 while (!(n%i))          
 n /= i;          
 }          
 }          
 // This condition is to handle the case when n          
 // is a prime number greater than 2          
 if (n>2)          
 count++;          
 return count;          
}          
// C++ function to count number          
// of pair with given GCD and LCM          
int countPairs(int G, int L)          
{          
 if (L % G != 0)          
 return 0;          
 int div = L/G;          
 // answer is 2^totalPrimeFactors(L/G)          
 return (1<<totalPrimeFactors(div));          
}          
// Driver code to test above functions          
int main()          
{          
 int G = 2, L = 12;          
 cout << "Total possible pair with GCD" << G;          
 cout << " &LCM " << L;          
 cout << " = " << countPairs(G, L);          
 return 0;          
}
Java 
// Efficient Java program to count all
// pairs with GCD and LCM.
public class GCD
{
    // A function to find number of distinct
    // prime factors of a given number n
    static int totalPrimeFactors(int n)
    {
        // To keep track of count
        int count = 0;
        
        // 2s that divide n
        if ((n%2 == 0))
        {
            count++;
            while ((n%2 == 0))
               n /= 2;
        }
        // n must be odd at this point. So we can skip
        // one element (Note i = i +2)
        for (int i = 3; i*i <= n; i = i+2)
        {
            // i divides n
            if ((n%i == 0))
                count++;
                while ((n%i == 0))
                    n /= 2;
        }
        // This condition is to handle the case when n
        // is a prime number greater than 2
        if (n > 2)
            count++;
       
       return count; 
    }
    // Java function to count number
    // of pair with given GCD and LCM
    static int countPairs(int G, int L)
    {
        if (L % G != 0)
            return 0;
        
        int div = L/G;
        
        // answer is 2^totalPrimeFactors(L/G)
        return (1 << totalPrimeFactors(div));
    }
    
    // Driver function
    public static void main (String[] args)
    {
        int G = 2, L = 12;
        System.out.print("Total possible pair with GCD " + G);
        System.out.print(" & LCM " + L);
        System.out.print(" = " + countPairs(G, L));
    }
}

// This code is contributed by Saket Kumar
Python3 
# Efficient python3 program to count 
# all pairs with GCD and LCM. 

# A function to find number of distinct 
# prime factors of a given number n 
def totalPrimeFactors(n): 
    
    # To keep track of count 
    count = 0; 

    # 2s that divide n 
    if ((n % 2) == 0): 
        count += 1; 
        while ((n % 2) == 0): 
            n //= 2; 

    # n must be odd at this point. 
    # So we can skip one element 
    # (Note i = i +2)
    i = 3;
    while (i * i <= n): 
        
        # i divides n 
        if ((n % i) == 0): 
            count += 1; 
            while ((n % i) == 0): 
                n //= i; 
        i += 2;

    # This condition is to handle the 
    # case when n is a prime number 
    # greater than 2 
    if (n > 2): 
        count += 1; 

    return count; 

# function to count number 
# of pair with given GCD and LCM 
def countPairs(G, L): 

    if (L % G != 0): 
        return 0; 

    div = int(L / G); 

    # answer is 2^totalPrimeFactors(L/G) 
    return (1 << totalPrimeFactors(div)); 

# Driver Code 
G = 2; 
L = 12; 
print("Total possible pair with GCD", 
           G, "& LCM", L, end = ""); 
print(" =", countPairs(G, L)); 

# This code is contributed by mits
C# 
// Efficient C# program to count all
// pairs with GCD and LCM.
using System;

class GFG {
    
    // A function to find number
    // of distinct prime factors
    // of a given number n
    static int totalPrimeFactors(int n)
    {
        
        // To keep track of count
        int count = 0;
        
        // 2s that divide n
        if ((n % 2 == 0))
        {
            count++;
            while ((n % 2 == 0))
            n /= 2;
        }
        
        // n must be odd at this 
        // point. So we can skip
        // one element (Note i = i+2)
        for (int i = 3; i * i <= n; 
                        i = i + 2)
        {
            
            // i divides n
            if ((n % i == 0))
                count++;
                while ((n % i == 0))
                    n /= 2;
        }
        
        // This condition is to 
        // handle the case when n
        // is a prime number 
        // greater than 2
        if (n > 2)
            count++;
        
    return count; 
    }
    
    // function to count number
    // of pair with given GCD and LCM
    static int countPairs(int G, int L)
    {
        if (L % G != 0)
            return 0;
        
        int div = L/G;
        
        // answer is 2^totalPrimeFactors(L/G)
        return (1 << totalPrimeFactors(div));
    }
    
    // Driver Code
    public static void Main (String[] args)
    {
        int G = 2, L = 12;
        Console.Write("Total possible pair with GCD " + G);
        Console.Write(" & LCM " + L);
        Console.Write(" = " + countPairs(G, L));
    }
}

// This code is contributed by Anshul Aggarwal.
PHP 
<?php
// Efficient php program to count all
// pairs with GCD and LCM.

// A function to find number of distinct
// prime factors of a given number n
function totalPrimeFactors($n)
{
    
    // To keep track of count
    $count = 0;

    // 2s that divide n
    if (!($n % 2))
    {
        $count++;
        while (!($n % 2))
            $n /= 2;
    }

    // n must be odd at this point.
    // So we can skip one element 
    // (Note i = i +2)
    for ($i = 3; $i * $i <= $n; $i = $i + 2)
    {
        
        // i divides n
        if (!($n % $i))
        {
            $count++;
            while (!($n % $i))
                $n /= $i;
        }
    }

    // This condition is to
    // handle the case when n
    // is a prime number greater
    // than 2
    if ($n > 2)
        $count++;

    return $count;
}

// function to count number
// of pair with given GCD and LCM
function countPairs($G, $L)
{
    if ($L % $G != 0)
    return 0;

    $div = $L/$G;

    // answer is 2^totalPrimeFactors(L/G)
    return (1 << totalPrimeFactors($div));
}

    // Driver Code
    $G = 2; 
    $L = 12;
    echo "Total possible pair with GCD " , $G;
    echo " & LCM " , $L;
    echo " = " ,countPairs($G, $L);
    return 0;

// This code is contributed by nitin mittal.
?>
JavaScript 
<script>

// Efficient javascript program to count all
// pairs with GCD and LCM.

    // A function to find number of distinct
    // prime factors of a given number n
    function totalPrimeFactors(n) {
        // To keep track of count
        var count = 0;

        // 2s that divide n
        if ((n % 2 == 0)) {
            count++;
            while ((n % 2 == 0))
                n = parseInt(n/2);
        }
        // n must be odd at this point. So we can skip
        // one element (Note i = i +2)
        for (i = 3; i * i <= n; i = i + 2) {
            // i divides n
            if ((n % i == 0))
                count++;
            while ((n % i == 0))
                n = parseInt(n/2);
        }
        // This condition is to handle the case when n
        // is a prime number greater than 2
        if (n > 2)
            count++;

        return count;
    }

// javascript function to count number
    // of pair with given GCD and LCM
    function countPairs(G , L) {
        if (L % G != 0)
            return 0;

        var div = L / G;

        // answer is 2^totalPrimeFactors(L/G)
        return (1 << totalPrimeFactors(div));
    }

    // Driver function
    
        var G = 2, L = 12;
        document.write("Total possible pair with GCD " + G);
        document.write(" & LCM " + L);
        document.write(" = " + countPairs(G, L));

// This code is contributed by aashish1995 

</script>

Output: 

Total possible pair with GCD 2 & LCM 12 = 4


Analysis of above algorithm 
Auxiliary Space: O(1) 
Time Complexity : O(sqrt(L/G) * log(L/G)). For time complexity to find number of distinct prime factors we need O(sqrt(L/G) * log (L/G)) time, Here sqrt(L) iterations are there in the worst case and in each iteration O(log L/G) iterations again.
 

Comment
Article Tags:
Mathematical
DSA
GCD-LCM

Explore