Skip to content
Related Articles

Related Articles

Improve Article

Check whether it is possible to convert A into B

  • Last Updated : 10 May, 2021

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.  

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

Examples: 

Input: A = 2, B = 82 
Output: Yes 
2 -> 4 -> 41 -> 82
Input: A = 2, B = 5 
Output: 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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :