# Make two numbers equal in at most K steps dividing by their factor

• Difficulty Level : Hard
• Last Updated : 21 Jul, 2022

Given integers X, Y, and K, the task is to make X and Y equal in not more than K operations by applying the following operations:

• Choose an integer A and make X = X/A, (where A is an integer that is greater than 1 and not equal to X).
• Choose an integer A and make Y = Y/A, (where A is an integer that is greater than 1 and not equal to Y).

Examples:

Input: X = 10, Y = 20, K = 4
Output: YES
Explanation: One optimal solution to make them equal is:
First choose A = 2 and do X = X/2 so now X is equal to 5.
Now choose A = 4 and do Y = Y/4 so now Y is equal to 5.
Since we have applied only two operations here which is less than K
to make X and Y equal and also greater than one.

Input: X = 2, Y = 27, K = 1
Output: NO
Explanation: There is no possible way to make X and Y equal
in less than or equal to 1 Operation.

Approach: To solve the problem follow the below idea:

Here are only two cases possible:

• When K is equal to one and
• When K is greater than 1

If K is equal to one then it is possible to make X and Y equal only when either X is divisible by Y or Y is divisible by X

If K is greater than 1 then X and Y can be equal and greater than 1 only when their GCD is greater than 1.

Follow the steps mentioned below to implement the idea:

• Check if K = 1:
• In that case, find out if any of them is a divisor of the other.
• Otherwise, find the GCD of the numbers.
• If the GCD is 1 then it is not possible.
• Otherwise, an answer always exists.

Below is the implementation for the above approach:

## C++

 `// C++ code to implement the approach`   `#include ` `using` `namespace` `std;`   `// Function to check the possibility of the answer` `bool` `isPossible(``int` `X, ``int` `Y, ``int` `K)` `{` `    ``// Case 1: when k=1` `    ``if` `(K == 1) {` `        ``if` `(X % Y == 0 || Y % X == 0)` `            ``return` `true``;` `        ``return` `false``;` `    ``}`   `    ``// Case 2: when k>1` `    ``else` `{` `        ``if` `(__gcd(X, Y) > 1)` `            ``return` `true``;` `        ``return` `false``;` `    ``}` `    ``return` `false``;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `X = 10;` `    ``int` `Y = 20;` `    ``int` `K = 4;`   `    ``// Function call` `    ``bool` `answer = isPossible(X, Y, K);` `    ``if` `(answer)` `        ``cout << ``"YES"``;` `    ``else` `        ``cout << ``"NO"``;` `    ``return` `0;` `}`

## Java

 `// Java code to implement the approach`   `public` `class` `GFG {` `    `  `   ``// Recursive function to return gcd of a and b` `    ``static` `int` `gcd(``int` `a, ``int` `b)` `    ``{` `        ``// Everything divides 0` `        ``if` `(a == ``0``)` `          ``return` `b;` `        ``if` `(b == ``0``)` `          ``return` `a;` `      `  `        ``// base case` `        ``if` `(a == b)` `            ``return` `a;` `      `  `        ``// a is greater` `        ``if` `(a > b)` `            ``return` `gcd(a-b, b);` `        ``return` `gcd(a, b-a);` `    ``}` `    `  `    ``// Function to check the possibility of the answer` `    ``static` `boolean` `isPossible(``int` `X, ``int` `Y, ``int` `K)` `    ``{` `        ``// Case 1: when k=1` `        ``if` `(K == ``1``) {` `            ``if` `(X % Y == ``0` `|| Y % X == ``0``)` `                ``return` `true``;` `            ``return` `false``;` `        ``}` `    `  `        ``// Case 2: when k>1` `        ``else` `{` `            ``if` `(gcd(X, Y) > ``1``)` `                ``return` `true``;` `            ``return` `false``;` `        ``}` `    ``}` `    `  `    ``// Driver code` `    ``public` `static` `void` `main (String[] args)` `    ``{` `        ``int` `X = ``10``;` `        ``int` `Y = ``20``;` `        ``int` `K = ``4``;` `    `  `        ``// Function call` `        ``boolean` `answer = isPossible(X, Y, K);` `        ``if` `(answer == ``true``)` `            ``System.out.println(``"YES"``);` `        ``else` `            ``System.out.println(``"NO"``);` `    ``}` `}`   `// This code is contributed by AnkThon`

## Python3

 `# Python3 code to implement the approach` `import` `math`   `# Function to check the possibility of the answer` `def` `isPossible(X, Y, K):` `    `  `    ``# Case 1: when k=1` `    ``if` `(K ``=``=` `1``) :` `        ``return` `(X ``%` `Y ``=``=` `0` `or` `Y ``%` `X ``=``=` `0``)`   `    ``# Case 2: when k>1` `    ``else` `:` `        ``return` `(math.gcd(X, Y) > ``1``)`   `    ``return` `False`   `# Driver code` `X, Y, K ``=` `10``, ``20``, ``4`   `# Function call` `answer ``=` `isPossible(X, Y, K);`   `if` `(answer):` `    ``print``(``"YES"``)` `else``:` `    ``print``(``"NO"``)`   `# This code is contributed by phasing17`

## C#

 `// C# code to implement the approach` `using` `System;`   `public` `class` `GFG {` `    `  `   ``// Recursive function to return gcd of a and b` `    ``static` `int` `gcd(``int` `a, ``int` `b)` `    ``{` `        ``// Everything divides 0` `        ``if` `(a == 0)` `          ``return` `b;` `        ``if` `(b == 0)` `          ``return` `a;` `      `  `        ``// base case` `        ``if` `(a == b)` `            ``return` `a;` `      `  `        ``// a is greater` `        ``if` `(a > b)` `            ``return` `gcd(a-b, b);` `        ``return` `gcd(a, b-a);` `    ``}` `    `  `    ``// Function to check the possibility of the answer` `    ``static` `bool` `isPossible(``int` `X, ``int` `Y, ``int` `K)` `    ``{` `        ``// Case 1: when k=1` `        ``if` `(K == 1) {` `            ``if` `(X % Y == 0 || Y % X == 0)` `                ``return` `true``;` `            ``return` `false``;` `        ``}` `    `  `        ``// Case 2: when k>1` `        ``else` `{` `            ``if` `(gcd(X, Y) > 1)` `                ``return` `true``;` `            ``return` `false``;` `        ``}` `    ``}` `    `  `    ``// Driver code` `    ``public` `static` `void` `Main (``string``[] args)` `    ``{` `        ``int` `X = 10;` `        ``int` `Y = 20;` `        ``int` `K = 4;` `    `  `        ``// Function call` `        ``bool` `answer = isPossible(X, Y, K);` `        ``if` `(answer == ``true``)` `            ``Console.WriteLine(``"YES"``);` `        ``else` `            ``Console.WriteLine(``"NO"``);` `    ``}` `}`   `// This code is contributed by AnkThon`

## Javascript

 ``

Output

`YES`

Time Complexity: O(1)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles