Binary to Gray code using recursion

Given the Binary code of a number as a decimal number, we need to convert this into its equivalent Gray Code. Assume that the binary number is in the range of integers. For the larger value, we can take a binary number as string.

Note: In Gray Code, consecutive numbers differ by only one bit.

Examples: 

Input: 1001 
Output: 1101
Explanation: The Gray Code for binary 1001 is 1101

Input: 11
Output: 10
Explanation: 11 -> 10

To convert a binary number to Gray Code, check if the last two bits are the same or different. If they are the same, continue without change; otherwise, add 1 to the result. The process is recursive: if n = 0, Gray Code is 0; if the last two bits differ, append 1 and call the function on n/10; otherwise, append 0 and recurse.

binary_to_grey(n)

•  if n == 0
  •  grey = 0;
•  else if last two bits are opposite  to each other
  •  grey = 1 + 10 * binary_to_gray(n/10))
•  else if last two bits are same
  •   grey = 10 * binary_to_gray(n/10))

#include <bits/stdc++.h>
using namespace std;

int binary_to_gray(int n)
{
    if (!n)
        return 0;

    // Taking last digit
    int a = n % 10;

    // Taking second last digit
    int b = (n / 10) % 10;

    // If last digit are opposite bits
    if ((a && !b) || (!a && b))
        return (1 + 10 * binary_to_gray(n / 10));

    // If last two bits are same
    return (10 * binary_to_gray(n / 10));
}

// Driver Function
int main()
{
    int binary_number = 1011101;

    printf("%d", binary_to_gray(binary_number));
    return 0;
}

import static java.lang.StrictMath.pow;

import java.util.Scanner;
class GfG {

    int binary_to_gray(int n, int i)
    {
        int a, b;
        int result = 0;
        if (n != 0) {
            // Taking last digit
            a = n % 10;

            n = n / 10;

            // Taking second last digit
            b = n % 10;

            if ((a & ~b) == 1 || (~a & b) == 1) {
                result = (int)(result + pow(10, i));
            }

            return binary_to_gray(n, ++i) + result;
        }
        return 0;
    }

    // Driver Function
    public static void main(String[] args)
    {
        int binary_number;
        int result = 0;
        binary_number = 1011101;

        bin_gray obj = new bin_gray();
        result = obj.binary_to_gray(binary_number, 0);

        System.out.print(result);
    }
}

//

def binary_to_gray(n):
    if not (n):
        return 0

    # Taking last digit
    a = n % 10

    # Taking second last digit
    b = int(n / 10) % 10

    # If last digit are opposite bits
    if (a and not (b)) or (not (a) and b):
        return (1 + 10 * binary_to_gray(int(n / 10)))

    # If last two bits are same
    return (10 * binary_to_gray(int(n / 10)))


# Driver Code
binary_number = 1011101
print(binary_to_gray(binary_number), end='')

# This code is contributed by "Sharad_Bhardwaj".

using System;

class GfG {

    static int binary_to_gray(int n, int i)
    {
        int a, b;
        int result = 0;
        if (n != 0) {

            // Taking last digit
            a = n % 10;

            n = n / 10;

            // Taking second last digit
            b = n % 10;

            if ((a & ~b) == 1 || (~a & b) == 1) {
                result = (int)(result + Math.Pow(10, i));
            }

            return binary_to_gray(n, ++i) + result;
        }

        return 0;
    }

    // Driver Function
    public static void Main()
    {
        int binary_number;
        binary_number = 1011101;

        Console.WriteLine(binary_to_gray(binary_number, 0));
    }
}

function binary_to_gray(n, i)
{
    let a, b;
    let result = 0;
    if (n != 0) {
        // Taking last digit
        a = n % 10;

        n = n / 10;

        // Taking second last digit
        b = n % 10;

        if ((a & ~b) == 1 || (~a & b) == 1) {
            result = (result + Math.pow(10, i));
        }

        return binary_to_gray(n, ++i) + result;
    }
    return 0;
}

// Driver code
let binary_number;
let result = 0;
binary_number = 1011101;

result = binary_to_gray(binary_number, 0);

console.log(result);

1110011

Time Complexity: O(log(n)), Traverse through all the digits, as there are log(n) bits.
Auxiliary Space: O(log(n)), due to recursive function calls stored in the call stack.