Comprobar si es posible convertir A en B

Dados dos enteros A y B . La tarea es verificar si es posible convertir A en B realizando las siguientes operaciones cualquier número de veces.  

1. Convierta el número actual x en 2 * x .
2. Convierta el número actual x a (10 * x) + 1 .

Ejemplos: 

Entrada: A = 2, B = 82 
Salida: Sí 
2 -> 4 -> 41 -> 82
Entrada: A = 2, B = 5 
Salida: No 

Enfoque: Resolvamos este problema de manera inversa: intente obtener el número A de B.
Tenga en cuenta que si B termina en 1 , la última operación fue agregar el dígito 1 a la derecha del número actual. Por eso, eliminemos el último dígito de B y pasemos al nuevo número.
Si el último dígito es par , la última operación fue multiplicar el número actual por 2 . Por eso, dividamos B por 2 y pasemos al nuevo número. En los demás casos (
si B termina en un dígito impar excepto 1 ) la respuesta es No.
Necesitamos repetir el algoritmo descrito cada vez que obtengamos un nuevo número. Si en algún momento obtenemos un número que es igual a A , entonces la respuesta es Sí , y si el nuevo número es menor que A , entonces la respuesta es No.
A continuación se muestra la implementación del enfoque anterior: 
 

// 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 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 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# 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..

<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>

Yes

Complejidad de tiempo: O (logn)

Espacio Auxiliar: O(1)