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

Last Updated : 29 Mar, 2024

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

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```

C++

 `// C++ program to find all pairs  ` `// with given GCD and LCM.  ` `#include   ` `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

 ` `

Javascript

 ` `

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            ` `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<

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

 ` 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

 ` `

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.

Previous
Next