 Open in App
Not now

# 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