Related Articles
Minimize steps required to make two values equal by repeated division by any of their prime factor which is less than M
• Difficulty Level : Medium
• Last Updated : 16 Apr, 2021

Given three positive integers M, X, and Y, the task is to find the minimum number of operations required to make X and Y equal such that in each operation divide X or Y by one of its prime factor less than M. If it is not possible to make X and Y equal, then print “-1”.

Examples:

Input: X = 20, Y =16, M = 10
Output: 3
Explanation:
Perform the operation on X and Y as illustrate below:
X: 20 -> 4 : 20/5 = 4
Y: 16 -> 8 : 16/ 2 = 8, 8 -> 4 : 8/2 = 4
Therefore, the total number of steps required to make X and Y equal is 3.

Input: X =160, Y = 180, M = 10
Output: 5

Approach: The idea to solve the given problem is based on the observation that the value at which both X and Y are equal is the GCD of X and Y. Follow the steps below to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Stores the prime factor of numbers``int` `primes;` `// Function to find GCD of a and b``int` `gcd(``int` `a, ``int` `b)``{``    ` `    ``// Base Case``    ``if` `(b == 0)``        ``return` `a;` `    ``// Otherwise, calculate GCD``    ``else``        ``return` `gcd(b, a % b);``}` `// Function to precompute the``// prime numbers till 1000000``void` `preprocess()``{``    ` `    ``// Initialize all the positions``    ``// with their respective values``    ``for``(``int` `i = 1; i <= 1000000; i++)``        ``primes[i] = i;` `    ``// Iterate over the range [2, sqrt(10^6)]``    ``for``(``int` `i = 2; i * i <= 1000000; i++)``    ``{``        ` `        ``// If i is prime number``        ``if` `(primes[i] == i)``        ``{``            ` `            ``// Mark it as the factor``            ``for``(``int` `j = 2 * i; j <= 1000000; j += i)``            ``{``                ``if` `(primes[j] == j)``                    ``primes[j] = i;``            ``}``        ``}``    ``}``}` `// Utility function to count the number``// of steps to make X and Y equal``int` `Steps(``int` `x, ``int` `m)``{``    ` `    ``// Intialise steps``    ``int` `steps = 0;` `    ``bool` `flag = ``false``;` `    ``// Iterate x is at most 1``    ``while` `(x > 1)``    ``{``        ``if` `(primes[x] > m)``        ``{``            ``flag = ``true``;``            ``break``;``        ``}` `        ``// Divide with the``        ``// smallest prime factor``        ``x /= primes[x];` `        ``steps++;``    ``}` `    ``// If X and Y can't be``    ``// made equal``    ``if` `(flag)``        ``return` `-1;` `    ``// Return steps``    ``return` `steps;``}` `// Function to find the minimum number of``// steps required to make X and Y equal``int` `minimumSteps(``int` `x, ``int` `y, ``int` `m)``{``    ` `    ``// Generate all the prime factors``    ``preprocess();` `    ``// Calculate GCD of x and y``    ``int` `g = gcd(x, y);` `    ``// Divide the numbers by their gcd``    ``x = x / g;``    ``y = y / g;` `    ``int` `x_steps = Steps(x, m);``    ``int` `y_steps = Steps(y, m);` `    ``// If not possible, then return -1;``    ``if` `(x_steps == -1 || y_steps == -1)``        ``return` `-1;` `    ``// Return the resultant number of steps``    ``return` `x_steps + y_steps;``}` `// Driver Code``int` `main()``{``    ``int` `X = 160;``    ``int` `Y = 180;``    ``int` `M = 10;` `    ``cout << (minimumSteps(X, Y, M));``}` `// This code is contributed by chitranayal`

## Java

 `// Java program for the above approach``import` `java.util.*;` `public` `class` `GFG {` `    ``// Stores the prime factor of numbers``    ``static` `int` `primes[] = ``new` `int``[``1000006``];` `    ``// Function to find GCD of a and b``    ``static` `int` `gcd(``int` `a, ``int` `b)``    ``{``        ``// Base Case``        ``if` `(b == ``0``)``            ``return` `a;` `        ``// Otherwise, calculate GCD``        ``else``            ``return` `gcd(b, a % b);``    ``}` `    ``// Function to precompute the``    ``// prime numbers till 1000000``    ``static` `void` `preprocess()``    ``{``        ``// Initialize all the positions``        ``// with their respective values``        ``for` `(``int` `i = ``1``; i <= ``1000000``; i++)``            ``primes[i] = i;` `        ``// Iterate over the range [2, sqrt(10^6)]``        ``for` `(``int` `i = ``2``; i * i <= ``1000000``; i++) {` `            ``// If i is prime number``            ``if` `(primes[i] == i) {` `                ``// Mark it as the factor``                ``for` `(``int` `j = ``2` `* i;``                     ``j <= ``1000000``; j += i) {` `                    ``if` `(primes[j] == j)``                        ``primes[j] = i;``                ``}``            ``}``        ``}``    ``}` `    ``// Utility function to count the number``    ``// of steps to make X and Y equal``    ``static` `int` `Steps(``int` `x, ``int` `m)``    ``{``        ``// Intialise steps``        ``int` `steps = ``0``;` `        ``boolean` `flag = ``false``;` `        ``// Iterate x is at most 1``        ``while` `(x > ``1``) {``            ``if` `(primes[x] > m) {``                ``flag = ``true``;``                ``break``;``            ``}` `            ``// Divide with the``            ``// smallest prime factor``            ``x /= primes[x];` `            ``steps++;``        ``}` `        ``// If X and Y can't be``        ``// made equal``        ``if` `(flag)``            ``return` `-``1``;` `        ``// Return steps``        ``return` `steps;``    ``}` `    ``// Function to find the minimum number of``    ``// steps required to make X and Y equal``    ``static` `int` `minimumSteps(``int` `x, ``int` `y, ``int` `m)``    ``{``        ``// Generate all the prime factors``        ``preprocess();` `        ``// Calculate GCD of x and y``        ``int` `g = gcd(x, y);` `        ``// Divide the numbers by their gcd``        ``x = x / g;``        ``y = y / g;` `        ``int` `x_steps = Steps(x, m);``        ``int` `y_steps = Steps(y, m);` `        ``// If not possible, then return -1;``        ``if` `(x_steps == -``1` `|| y_steps == -``1``)``            ``return` `-``1``;` `        ``// Return the resultant number of steps``        ``return` `x_steps + y_steps;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `X = ``160``;``        ``int` `Y = ``180``;``        ``int` `M = ``10``;` `        ``System.out.println(``            ``minimumSteps(X, Y, M));``    ``}``}`

## Python3

 `# Python program for the above approach` `# Stores the prime factor of numbers``primes ``=` `[``0``] ``*` `(``1000006``)` `# Function to find GCD of a and b``def` `gcd(a, b) :``    ` `    ``# Base Case``    ``if` `(b ``=``=` `0``) :``        ``return` `a` `    ``# Otherwise, calculate GCD``    ``else` `:``        ``return` `gcd(b, a ``%` `b)`  `# Function to precompute the``# prime numbers till 1000000``def` `preprocess() :``    ` `    ``# Initialize all the positions``    ``# with their respective values``    ``for` `i ``in` `range``(``1``, ``1000001``):``        ``primes[i] ``=` `i` `    ``# Iterate over the range [2, sqrt(10^6)]``    ``i ``=` `2``    ``while``(i ``*` `i <``=` `1000000``)  :``        ` `        ``# If i is prime number``        ``if` `(primes[i] ``=``=` `i) :``            ` `            ``# Mark it as the factor``            ``for` `j ``in` `range``(``2` `*` `i, ``1000001``, i):``                ``if` `(primes[j] ``=``=` `j) :``                    ``primes[j] ``=` `i     ``        ``i ``+``=` `1` `# Utility function to count the number``# of steps to make X and Y equal``def` `Steps(x, m) :``    ` `    ``# Intialise steps``    ``steps ``=` `0` `    ``flag ``=` `False` `    ``# Iterate x is at most 1``    ``while` `(x > ``1``) :``        ` `        ``if` `(primes[x] > m) :``            ``flag ``=` `True``            ``break``        `  `        ``# Divide with the``        ``# smallest prime factor``        ``x ``/``/``=` `primes[x]` `        ``steps ``+``=` `1``    `  `    ``# If X and Y can't be``    ``# made equal``    ``if` `(flag !``=` `0``) :``        ``return` `-``1` `    ``# Return steps``    ``return` `steps`  `# Function to find the minimum number of``# steps required to make X and Y equal``def` `minimumSteps(x, y, m) :``    ` `    ``# Generate all the prime factors``    ``preprocess()` `    ``# Calculate GCD of x and y``    ``g ``=` `gcd(x, y)` `    ``# Divide the numbers by their gcd``    ``x ``=` `x ``/``/` `g``    ``y ``=` `y ``/``/` `g` `    ``x_steps ``=` `Steps(x, m)``    ``y_steps ``=` `Steps(y, m)` `    ``# If not possible, then return -1``    ``if` `(x_steps ``=``=` `-``1` `or` `y_steps ``=``=` `-``1``) :``        ``return` `-``1` `    ``# Return the resultant number of steps``    ``return` `x_steps ``+` `y_steps`  `# Driver Code``X ``=` `160``Y ``=` `180``M ``=` `10` `print``(minimumSteps(X, Y, M))` `# This code is contributed by souravghosh0416.`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Stores the prime factor of numbers``static` `int``[] primes = ``new` `int``;` `// Function to find GCD of a and b``static` `int` `gcd(``int` `a, ``int` `b)``{``    ` `    ``// Base Case``    ``if` `(b == 0)``        ``return` `a;``    ` `    ``// Otherwise, calculate GCD``    ``else``        ``return` `gcd(b, a % b);``}` `// Function to precompute the``// prime numbers till 1000000``static` `void` `preprocess()``{``    ` `    ``// Initialize all the positions``    ``// with their respective values``    ``for``(``int` `i = 1; i <= 1000000; i++)``        ``primes[i] = i;``    ` `    ``// Iterate over the range [2, sqrt(10^6)]``    ``for``(``int` `i = 2; i * i <= 1000000; i++)``    ``{``        ` `        ``// If i is prime number``        ``if` `(primes[i] == i)``        ``{``            ` `            ``// Mark it as the factor``            ``for``(``int` `j = 2 * i;``                    ``j <= 1000000; j += i)``            ``{``                ``if` `(primes[j] == j)``                    ``primes[j] = i;``            ``}``        ``}``    ``}``}` `// Utility function to count the number``// of steps to make X and Y equal``static` `int` `Steps(``int` `x, ``int` `m)``{``    ` `    ``// Intialise steps``    ``int` `steps = 0;``    ` `    ``bool` `flag = ``false``;``    ` `    ``// Iterate x is at most 1``    ``while` `(x > 1)``    ``{``        ``if` `(primes[x] > m)``        ``{``            ``flag = ``true``;``            ``break``;``        ``}``        ` `        ``// Divide with the``        ``// smallest prime factor``        ``x /= primes[x];``        ` `        ``steps++;``    ``}``    ` `    ``// If X and Y can't be``    ``// made equal``    ``if` `(flag)``        ``return` `-1;``    ` `    ``// Return steps``    ``return` `steps;``}` `// Function to find the minimum number of``// steps required to make X and Y equal``static` `int` `minimumSteps(``int` `x, ``int` `y, ``int` `m)``{``    ` `    ``// Generate all the prime factors``    ``preprocess();``    ` `    ``// Calculate GCD of x and y``    ``int` `g = gcd(x, y);``    ` `    ``// Divide the numbers by their gcd``    ``x = x / g;``    ``y = y / g;``    ` `    ``int` `x_steps = Steps(x, m);``    ``int` `y_steps = Steps(y, m);``    ` `    ``// If not possible, then return -1;``    ``if` `(x_steps == -1 || y_steps == -1)``        ``return` `-1;``    ` `    ``// Return the resultant number of steps``    ``return` `x_steps + y_steps;``}` `// Driver code``static` `void` `Main()``{``    ``int` `X = 160;``    ``int` `Y = 180;``    ``int` `M = 10;``    ` `    ``Console.Write(minimumSteps(X, Y, M));``}``}` `// This code is contributed by sanjoy_62`

## Javascript

 ``
Output:
`5`

Time Complexity: O(N log N)
Auxiliary Space: O(N)

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