Related Articles

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

• Difficulty Level : Hard
• Last Updated : 08 Sep, 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 ``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`

## Java

 `// Java program for the above approach``import` `java.util.*;``public` `class` `Main``{``     ` `    ``static` `int` `gcd(``int` `a, ``int` `b)``    ``{``          ` `        ``// Everything divides 0``        ``if` `(b == ``0``)``        ``{``            ``return` `a;``        ``}``        ``return` `gcd(b, a % b);``    ``}``      ` `    ``// Function to calculate total number of``    ``// prime factor with their prime factor``    ``static` `HashMap PrimeFactor(``int` `N)``    ``{``        ``HashMap primef = ``new` `HashMap();``          ` `        ``// Iterate while the number is even``        ``while` `(N % ``2` `== ``0``)``        ``{``            ``if` `(primef.containsKey(``2``))``            ``{``                ``primef.put(``2``, primef.get(``2``) + ``1``);``            ``}``            ``else``            ``{``                ``primef.put(``2``, ``1``);``            ``}``              ` `            ``// Reduce to half``            ``N = N / ``2``;``        ``}``          ` `        ``// Iterate up to sqrt(N)``        ``for``(``int` `i = ``3``; i <= Math.sqrt(N); i++)``        ``{``          ` `            ``// Iterate while N has``            ``// factors of i``            ``while` `(N % i == ``0``)``            ``{``                ``if` `(primef.containsKey(i))``                ``{``                    ``primef.put(i, primef.get(i) + ``1``);``                ``}``                ``else``                ``{``                    ``primef.put(i, ``1``);``                ``}``                  ` `                ``// Removing one factor of i``                ``N = N / ``2``;``            ``}``        ``}``        ``if` `(N > ``2``)``        ``{``            ``primef.put(N, ``1``);``        ``}``        ``return` `primef;``    ``}``      ` `    ``// Function to count the number of factors``    ``static` `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``        ``HashMap primeX = PrimeFactor(newX);``        ``HashMap primeY = PrimeFactor(newY);``          ` `        ``// Initialize ans``        ``int` `ans = ``0``;``          ` `        ``// Check if it possible``        ``// to obtain X or not``        ``for` `(Map.Entry keys : primeX.entrySet()) {``            ``if` `(X % (``int``)keys.getKey() != ``0``)``            ``{``                ``return` `-``1``;``            ``}``            ``ans += primeX.get(keys.getKey());``        ``}``          ` `        ``// Check if it possible to``        ``// obtain Y or not``        ``for` `(Map.Entry keys : primeY.entrySet()) {``            ``if` `(Y % (``int``)keys.getKey() != ``0``)``            ``{``                ``return` `-``1``;``            ``}``            ``ans += primeY.get(keys.getKey());``        ``}``          ` `        ``// Return main ans``        ``return` `ans;``    ``}`` ` `    ``public` `static` `void` `main(String[] args) {``        ``// Given Input``        ``int` `X = ``36``;``        ``int` `Y = ``48``;``          ` `        ``// Function Call``        ``int` `ans = CountToMakeEqual(X, Y);``        ``System.out.println(ans);``    ``}``}`` ` `// This code is contributed by mukesh07.`

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

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;`` ` `class` `GFG{``     ` `static` `int` `gcd(``int` `a, ``int` `b)``{``     ` `    ``// Everything divides 0``    ``if` `(b == 0)``    ``{``        ``return` `a;``    ``}``    ``return` `gcd(b, a % b);``}`` ` `// Function to calculate total number of``// prime factor with their prime factor``static` `Dictionary<``int``, ``int``> PrimeFactor(``int` `N)``{``    ``Dictionary<``int``, ``               ``int``> primef = ``new` `Dictionary<``int``, ``                                            ``int``>(); ``     ` `    ``// Iterate while the number is even``    ``while` `(N % 2 == 0)``    ``{``        ``if` `(primef.ContainsKey(2))``        ``{``            ``primef[2]++;``        ``}``        ``else``        ``{``            ``primef[2] = 1;``        ``}``         ` `        ``// Reduce to half``        ``N = N / 2;``    ``}``     ` `    ``// Iterate up to sqrt(N)``    ``for``(``int` `i = 3; i <= Math.Sqrt(N); i++)``    ``{``     ` `        ``// Iterate while N has``        ``// factors of i``        ``while` `(N % i == 0)``        ``{``            ``if` `(primef.ContainsKey(i))``            ``{``                ``primef[i]++;``            ``}``            ``else``            ``{``                ``primef[i] = 1;``            ``}``             ` `            ``// Removing one factor of i``            ``N = N / 2;``        ``}``    ``}``    ``if` `(N > 2)``    ``{``        ``primef[N] = 1;``    ``}``    ``return` `primef;``}`` ` `// Function to count the number of factors``static` `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``    ``Dictionary<``int``, ``int``> primeX = PrimeFactor(newX);``    ``Dictionary<``int``, ``int``> primeY = PrimeFactor(newY);``     ` `    ``// Initialize ans``    ``int` `ans = 0;``     ` `    ``// Check if it possible``    ``// to obtain X or not``    ``foreach``(KeyValuePair<``int``, ``int``> keys ``in` `primeX)``    ``{``        ``if` `(X % keys.Key != 0)``        ``{``            ``return` `-1;``        ``}``        ``ans += primeX[keys.Key];``    ``}``     ` `    ``// Check if it possible to``    ``// obtain Y or not``    ``foreach``(KeyValuePair<``int``, ``int``> keys ``in` `primeY)``    ``{``        ``if` `(Y % keys.Key != 0)``        ``{``            ``return` `-1;``        ``}``        ``ans += primeY[keys.Key];``    ``}``     ` `    ``// Return main ans``    ``return` `ans;``}`` ` `// Driver Code``static` `void` `Main() ``{``     ` `    ``// Given Input``    ``int` `X = 36;``    ``int` `Y = 48;``     ` `    ``// Function Call``    ``int` `ans = CountToMakeEqual(X, Y);``    ``Console.Write(ans);``}``}`` ` `// This code is contributed by rameshtravel07`

## Javascript

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