# Check whether it is possible to convert A into B

Given two integers **A** and **B**. The task is to check whether it is possible to convert **A** into **B** by performing below operations any number of times.

- Convert current number
**x**to**2 * x**. - Convert current number
**x**to**(10 * x) + 1**.

**Examples:**

Input:A = 2, B = 82Output:Yes

2 -> 4 -> 41 -> 82Input:A = 2, B = 5Output:No

**Approach:** Let’s solve this problem in a reverse way – try to get the number **A** from **B**.

Note, that if **B** ends with **1** the last operation was to append the digit **1** to the right of the current number. Because of that let’s delete the last digit of **B** and move to the new number.

If the last digit is **even** then the last operation was to multiply the current number by **2**. Because of that let’s divide **B** by 2 and move to the new number.

In the other cases (if B ends with an **odd digit except 1**) the answer is **No**.

We need to repeat the described algorithm after every time we get a new number. If at some point, we get a number that is equal to **A** then the answer is **Yes**, and if the new number is less than **A** then the answer is **No**.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function that returns true if A can be` `// converted to B with the given operations` `bool` `canConvert(` `int` `a, ` `int` `b)` `{` ` ` `while` `(b > a) {` ` ` `// If the current number ends with 1` ` ` `if` `(b % 10 == 1) {` ` ` `b /= 10;` ` ` `continue` `;` ` ` `}` ` ` `// If the current number is divisible by 2` ` ` `if` `(b % 2 == 0) {` ` ` `b /= 2;` ` ` `continue` `;` ` ` `}` ` ` `// If above two conditions fail` ` ` `return` `false` `;` ` ` `}` ` ` `// If it is possible to convert A to B` ` ` `if` `(b == a)` ` ` `return` `true` `;` ` ` `return` `false` `;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `A = 2, B = 82;` ` ` `if` `(canConvert(A, B))` ` ` `cout << ` `"Yes"` `;` ` ` `else` ` ` `cout << ` `"No"` `;` ` ` `return` `0;` `}` |

## Java

`// Java implementation of the approach` `class` `GFG` `{` ` ` `// Function that returns true if A can be` ` ` `// converted to B with the given operations` ` ` `static` `boolean` `canConvert(` `int` `a, ` `int` `b)` ` ` `{` ` ` `while` `(b > a)` ` ` `{` ` ` `// If the current number ends with 1` ` ` `if` `(b % ` `10` `== ` `1` `)` ` ` `{` ` ` `b /= ` `10` `;` ` ` `continue` `;` ` ` `}` ` ` `// If the current number is divisible by 2` ` ` `if` `(b % ` `2` `== ` `0` `)` ` ` `{` ` ` `b /= ` `2` `;` ` ` `continue` `;` ` ` `}` ` ` `// If above two conditions fail` ` ` `return` `false` `;` ` ` `}` ` ` `// If it is possible to convert A to B` ` ` `if` `(b == a)` ` ` `return` `true` `;` ` ` `return` `false` `;` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `int` `A = ` `2` `, B = ` `82` `;` ` ` `if` `(canConvert(A, B))` ` ` `System.out.println(` `"Yes"` `);` ` ` `else` ` ` `System.out.println(` `"No"` `);` ` ` `}` `}` `// This code contributed by Rajput-Ji` |

## Python3

`# Python3 implementation of the approach` `# Function that returns true if A can be` `# converted to B with the given operations` `def` `canConvert(a, b) :` ` ` `while` `(b > a) :` ` ` `# If the current number ends with 1` ` ` `if` `(b ` `%` `10` `=` `=` `1` `) :` ` ` `b ` `/` `/` `=` `10` `;` ` ` `continue` `;` ` ` ` ` `# If the current number is divisible by 2` ` ` `if` `(b ` `%` `2` `=` `=` `0` `) :` ` ` `b ` `/` `=` `2` `;` ` ` `continue` `;` ` ` `# If the above two conditions fail` ` ` `return` `false;` ` ` ` ` `# If it is possible to convert A to B` ` ` `if` `(b ` `=` `=` `a) :` ` ` `return` `True` `;` ` ` ` ` `return` `False` `;` `# Driver code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `A ` `=` `2` `; B ` `=` `82` `;` ` ` `if` `(canConvert(A, B)) :` ` ` `print` `(` `"Yes"` `);` ` ` `else` `:` ` ` `print` `(` `"No"` `);` ` ` `# This code is contributed by AnkitRai01` |

## C#

`// C# implementation of the approach` `using` `System;` `class` `GFG` `{` ` ` `// Function that returns true if A can be` ` ` `// converted to B with the given operations` ` ` `static` `bool` `canConvert(` `int` `a, ` `int` `b)` ` ` `{` ` ` `while` `(b > a)` ` ` `{` ` ` `// If the current number ends with 1` ` ` `if` `(b % 10 == 1)` ` ` `{` ` ` `b /= 10;` ` ` `continue` `;` ` ` `}` ` ` `// If the current number is divisible by 2` ` ` `if` `(b % 2 == 0)` ` ` `{` ` ` `b /= 2;` ` ` `continue` `;` ` ` `}` ` ` `// If above two conditions fail` ` ` `return` `false` `;` ` ` `}` ` ` `// If it is possible to convert A to B` ` ` `if` `(b == a)` ` ` `return` `true` `;` ` ` `return` `false` `;` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `int` `A = 2, B = 82;` ` ` `if` `(canConvert(A, B))` ` ` `Console.WriteLine(` `"Yes"` `);` ` ` `else` ` ` `Console.WriteLine(` `"No"` `);` ` ` `}` `}` `// This code is contributed by anuj_67..` |

## Javascript

`<script>` `// Javascript implementation of the approach` `// Function that returns true if A can be` `// converted to B with the given operations` `function` `canConvert(a, b)` `{` ` ` `while` `(b > a) {` ` ` `// If the current number ends with 1` ` ` `if` `(b % 10 == 1) {` ` ` `b = parseInt(b / 10);` ` ` `continue` `;` ` ` `}` ` ` `// If the current number is divisible by 2` ` ` `if` `(b % 2 == 0) {` ` ` `b = parseInt(b / 2);` ` ` `continue` `;` ` ` `}` ` ` `// If above two conditions fail` ` ` `return` `false` `;` ` ` `}` ` ` `// If it is possible to convert A to B` ` ` `if` `(b == a)` ` ` `return` `true` `;` ` ` `return` `false` `;` `}` `// Driver code` ` ` `let A = 2, B = 82;` ` ` `if` `(canConvert(A, B))` ` ` `document.write(` `"Yes"` `);` ` ` `else` ` ` `document.write(` `"No"` `);` ` ` `</script>` |

**Output:**

Yes

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.