Skip to content
Related Articles

Related Articles

Improve Article

Make two numbers equal by mutiplying with their prime factors minimum number of times

  • Difficulty Level : Hard
  • Last Updated : 08 Jul, 2021

Given two numbers X and Y, the task is to make both of them equal by repeatedly multiplying with their prime factors minimum number of times.

Examples:

Input: X = 36, Y = 48
Output: 3
Explanation: 
Operation 1: Choose 2(prime factor of X) and multiply with X. Now, X = 72, Y = 48.
Operation 2: Choose 2(prime factor of X) and multiply with X, Now, X = 144, Y = 48
Operation 3: Choose 3(prime factor of Y) and multiply with X. Now, X = 144, Y = 144

Input: X = 10, Y = 14
Output: -1

Approach: The idea is that X and Y can be made equal only if every prime factor of X is present in Y and every prime factor of Y is present in X. To count the minimum operations required to make them equal, follow the following steps:



  • Calculate the gcd of X and Y, say GCD and find newX = X / GCD and newY = Y / GCD to remove the common prime factors.
  • Find the prime factors with their frequencies of both newX and newY.
  • Check every prime factor of newX is present in Y(will divide Y) and every prime factor of newY is present in X(will divide X). If not, then return -1.  
  • Initialize a variable, say ans =0, to store the number of operations required.
  • Add all the frequencies of primes of newX and newY to the ans.
  • Return the ans.

Below is the implementation of the above approach:  

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate total number of
// prime factor with their prime factor
unordered_map<int, int> PrimeFactor(int N)
{
    unordered_map<int, int> primef;
     
    // Iterate while the number is even
    while (N % 2 == 0)
    {
        if (primef.count(2))
        {
            primef[2] += 1;
        }
        else
        {
            primef[2] = 1;
        }
         
        // Reduce to half
        N /= 2;
    }
     
    // Iterate up to sqrt(N)
    for(int i = 3; i <= sqrt(N); i++)
    {
         
        // Iterate while N has
        // factors of i
        while (N % i == 0)
        {
            if (primef.count(i))
            {
                primef[i] += 1;
            }
            else
            {
                primef[i] = 1;
            }
             
            // Removing one factor of i
            N /= 2;
        }
    }
    if (N > 2)
    {
        primef[N] = 1;
    }
    return primef;
}
 
// Function to count the number of factors
int CountToMakeEqual(int X, int Y)
{
     
    // Find the GCD
    int gcdofXY = __gcd(X, Y);
     
    // Find multiples left in X and Y
    int newX = Y / gcdofXY;
    int newY = X / gcdofXY;
     
    // Find prime factor of multiple
    // left in X and Y
    unordered_map<int, int> primeX;
    unordered_map<int, int> primeY;
    primeX = PrimeFactor(newX);
    primeY = PrimeFactor(newY);
     
    // Initialize ans
    int ans = 0;
     
    // Check if it possible
    // to obtain X or not
    for(auto c : primeX)
    {
        if (X % c.first != 0)
        {
            return -1;
        }
        ans += primeX[c.first];
    }
     
    // Check if it possible to
    // obtain Y or not
    for(auto c : primeY)
    {
        if (Y % c.first != 0)
        {
            return -1;
        }
        ans += primeY[c.first];
    }
     
    // return main ans
    return ans;
}
 
// Driver code
int main()
{
     
    // Given Input
    int X = 36;
    int Y = 48;
     
    // Function Call
    int ans = CountToMakeEqual(X, Y);
    cout << ans << endl;
    return 0;
}
 
// This code is contributed by adarshsinghk

Python3




# Python program for the above approach
import math
 
# Function to calculate total number of
# prime factor with their prime factor
 
 
def PrimeFactor(N):
    ANS = dict()
 
    # Iterate while the number is even
    while N % 2 == 0:
        if 2 in ANS:
            ANS[2] += 1
        else:
            ANS[2] = 1
 
        # Reduce to half
        N = N//2
 
    # Iterate up to sqrt(N)
    for i in range(3, int(math.sqrt(N))+1, 2):
 
        # Iterate while N has
        # factors of i
        while N % i == 0:
            if i in ANS:
                ANS[i] += 1
            else:
                ANS[i] = 1
 
            # Removing one factor of i
            N = N // i
 
    if 2 < N:
        ANS[N] = 1
 
    return ANS
 
 
# Function to count the number of factors
def CountToMakeEqual(X, Y):
 
    # Find the GCD
    GCD = math.gcd(X, Y)
 
    # Find multiples left in X and Y
    newY = X//GCD
    newX = Y//GCD
 
    # Find prime factor of multiple
    # left in X and Y
    primeX = PrimeFactor(newX)
    primeY = PrimeFactor(newY)
 
    # Initialize ans
    ans = 0
 
    # Check if it possible
    # to obtain X or not
    for factor in primeX:
 
        if X % factor != 0:
            return -1
        ans += primeX[factor]
 
    # Check if it possible to
    # obtain Y or not
    for factor in primeY:
 
        if Y % factor != 0:
            return -1
        ans += primeY[factor]
 
    # return main ans
    return ans
 
 
# Driver Code
if __name__ == "__main__":
 
    # Given Input
    X = 36
    Y = 48
 
    # Function Call
    ans = CountToMakeEqual(X, Y)
    print(ans)
Output: 
3

 

Time Complexity: O(sqrt(max(X, Y)))
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :