Java Program to Convert Binary Code Into Equivalent Gray Code Using Recursion

Convert the Binary code of the Number into it’s equivalent Gray’s code using recursion. Binary is the default way to store numbers, but in many applications, binary numbers are not useful and a variation of binary is needed. Gray code has the property that two successive numbers differ in only one bit and used in K-maps, error correction, and communication.

Examples:

Input:    1101
Output:    1011

Input:    11010001
Output:    10111001

Approach #1: Numbers Under Integer Limit

Algorithm:

1. If n=0 then gray=0.
2. Else if the last two bits are opposite to each other then gray = 1 + (10 * binaryToGray(n/10)).
3. Else if the last two bits are same then gray = 10 * binaryToGray(n/10)

Below is the implementation of the above approach.

Java

// Java Program to Convert Binary Code
// Into Equivalent Gray Code Using Recursion
import java.io.*;
class GFG {

    // Function to change Binary Code
    // to Gray using Recursion
    public static int binaryToGray(int n)
    {
        if (n == 0) {
            return 0;
        }
        // Extracting the last digit
        int a = n % 10;
        // Extracting the second last digit
        int b = (n / 10) % 10;
        // Else If last two digits
        // are opposite bits to each other
        if ((a & ~b) == 1 || (~a & b) == 1) {
            return (1 + 10 * binaryToGray(n / 10));
        }
        // Else If the last
        // two bits are same
        return (10 * binaryToGray(n / 10));
    }
    // Driver's Function
    public static void main(String[] args)
    {
        int binaryNumber = 11010001;
        int result = binaryToGray(binaryNumber);
        System.out.println("Gray Code is " + result);
    }
}

Output

Gray Code is 10111001

Approach #2: Large Binary Numbers

Algorithm:

1. Take input in string format.
2. Pass current pointer in a recursive function.
3. Store XOR of i’th and (i-1)th bit into array.
4. Return the array at the end of recursion.

Below is the implementation of the above approach.

Java

// Java Program to Convert Binary Code
// Into Equivalent Gray Code Using Recursion
import java.io.*;
class GFG {
    // XOR two numbers
    public static char xor(char a, char b)
    {
        if (a == b)
            return '0';
        else
            return '1';
    }
    // Recursive function Gray code conversion
    public static char[] ans(char[] kp, String str, int i)
    {
        if (i == str.length())
            return kp;
        kp[i] = xor(str.charAt(i), str.charAt(i - 1));
        i++;
        return ans(kp, str, i);
    }
    // Driver Program
    public static void main(String args[])
    {
        String str = "01001";
        char[] kp = new char[str.length()];
        kp[0] = str.charAt(0);

        // Recursive function call
        ans(kp, str, 1);

        // Print Gray Code
        System.out.print("Gray Code is ");
        for (char i : kp)
            System.out.print(i + "");
    }
}

Output

Gray Code is 01101

Time Complexity: O(N), where N is the length of Binary Code.

Auxiliary Space: O(N) if char array kp is considered, otherwise O(1)