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

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