Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Maximum count of common divisors of A and B such that all are co-primes to one another

  • Last Updated : 07 May, 2021

Given two integers A and B. The task is to find the count of maximum elements from the common divisors of A and B such that all selected elements are co-prime to one another.
Examples: 
 

Input: A = 12, B = 18 
Output:
Common divisors of A and B are 1, 2, 3 and 6. 
Select 1, 2, and 3. All the pairs are co primes to 
one another i.e. gcd(1, 2) = gcd(1, 3) = gcd(2, 3) = 1.
Input: A = 1, B = 3 
Output:
 

 

Approach: It can be observed that all the common factors of A and B must be a factor of their gcd. And, in order for the factors of this gcd to be co-prime to one another, one element of the pair must be either 1 or both the elements must be prime. So the answer will be 1 more than the count of prime divisors of gcd(A, B). Note that 1 is added because 1 can also be a part of the chosen divisors as its gcd with the other pairs will always be 1.
Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the count of common factors
// of a and b such that all the elements
// are co-prime to one another
int maxCommonFactors(int a, int b)
{
    // GCD of a and b
    int gcd = __gcd(a, b);
 
    // Include 1 initially
    int ans = 1;
 
    // Find all the prime factors of the gcd
    for (int i = 2; i * i <= gcd; i++) {
        if (gcd % i == 0) {
            ans++;
            while (gcd % i == 0)
                gcd /= i;
        }
    }
 
    // If gcd is prime
    if (gcd != 1)
        ans++;
 
    // Return the required answer
    return ans;
}
 
// Driver code
int main()
{
    int a = 12, b = 18;
 
    cout << maxCommonFactors(a, b);
 
    return 0;
}

Java




// Java implementation of the approach
class GFG
{
     
static int gcd(int a, int b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}
 
// Function to return the count of common factors
// of a and b such that all the elements
// are co-prime to one another
static int maxCommonFactors(int a, int b)
{
     
    // GCD of a and b
    int __gcd = gcd(a, b);
 
    // Include 1 initially
    int ans = 1;
 
    // Find all the prime factors of the gcd
    for (int i = 2; i * i <= __gcd; i++)
    {
        if (__gcd % i == 0)
        {
            ans++;
            while (__gcd % i == 0)
                __gcd /= i;
        }
    }
 
    // If gcd is prime
    if (__gcd != 1)
        ans++;
 
    // Return the required answer
    return ans;
}
 
// Driver code
public static void main (String[] args)
{
    int a = 12, b = 18;
 
    System.out.println(maxCommonFactors(a, b));
}
}
 
// This code is contributed by AnkitRai01

Python3




# Python3 implementation of the approach
import math
 
# Function to return the count of common factors
# of a and b such that all the elements
# are co-prime to one another
def maxCommonFactors(a, b):
     
    # GCD of a and b
    gcd = math.gcd(a, b)
 
    # Include 1 initially
    ans = 1;
 
    # Find all the prime factors of the gcd
    i = 2
    while (i * i <= gcd):
        if (gcd % i == 0):
            ans += 1
            while (gcd % i == 0):
                gcd = gcd // i
        i += 1   
                 
    # If gcd is prime
    if (gcd != 1):
        ans += 1
 
    # Return the required answer
    return ans
     
# Driver code
a = 12
b = 18
print(maxCommonFactors(a, b))
 
# This code is contributed by
# divyamohan123

C#




// C# implementation of the above approach
using System;        
 
class GFG
{
     
    static int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
 
    // Function to return the count of common factors
    // of a and b such that all the elements
    // are co-prime to one another
    static int maxCommonFactors(int a, int b)
    {
 
        // GCD of a and b
        int __gcd = gcd(a, b);
 
        // Include 1 initially
        int ans = 1;
 
        // Find all the prime factors of the gcd
        for (int i = 2; i * i <= __gcd; i++)
        {
            if (__gcd % i == 0)
            {
                ans++;
                while (__gcd % i == 0)
                    __gcd /= i;
            }
        }
 
        // If gcd is prime
        if (__gcd != 1)
            ans++;
 
        // Return the required answer
        return ans;
    }
 
    // Driver code
    public static void Main (String[] args)
    {
        int a = 12, b = 18;
 
        Console.WriteLine(maxCommonFactors(a, b));
    }
}
 
// This code is contributed by Rajput-Ji

Javascript




<script>
// Javascript implementation of the approach
 
function GCD(a, b)
{
  if (b == 0)
      return a;
  return GCD(b, a % b);
}
     
// Function to return the count of common factors
// of a and b such that all the elements
// are co-prime to one another
function maxCommonFactors(a, b)
{
    // GCD of a and b
    let gcd = GCD(a, b);
 
    // Include 1 initially
    let ans = 1;
 
    // Find all the prime factors of the gcd
    for (let i = 2; i * i <= gcd; i++) {
        if (gcd % i == 0) {
            ans++;
            while (gcd % i == 0)
                gcd = parseInt(gcd / i);
        }
    }
 
    // If gcd is prime
    if (gcd != 1)
        ans++;
 
    // Return the required answer
    return ans;
}
 
// Driver code
    let a = 12, b = 18;
 
    document.write(maxCommonFactors(a, b));
 
</script>
Output: 
3

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!