Binary to Gray code using recursion (original) (raw)

Last Updated : 17 Mar, 2025

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)) CPP `

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

}

Java

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);
}

}

//

Python

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

C#

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));
}

}

JavaScript

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

`

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