Gray to Binary and Binary to Gray conversion

Last Updated : 3 Oct, 2025

Given a number n, convert it from binary to Gray code and also convert n into Gray code to binary.

Input : n = 5
Output: Binary to Gray : 7
Gray to Binary : 6
Explanation: Binary to Gray gives 7 (binary 101 → gray 111), and gray to binary converts gray code 5 (binary 101) to binary 6 (110)

Try It Yourself

Binary to Gray conversion :

The Most Significant Bit (MSB) of the gray code is always equal to the MSB of the given binary code.
Other bits of the output gray code can be obtained by XORing binary code bit at that index and previous index.

Binary code to gray code conversion

Gray to binary conversion :

The Most Significant Bit (MSB) of the binary code is always equal to the MSB of the given gray code.
Other bits of the output binary code can be obtained by checking the gray code bit at that index. If the current gray code bit is 0, then copy the previous binary code bit, else copy the invert of the previous binary code bit.

Gray code to binary code conversion

Table of Content

When n is given in binary
When n is given in interger

When n is given in binary

C++

#include <iostream>
using namespace std;

// Function to find xor of two 
// bits represented as character.
char xorChar(char a, char b) { 
    return (a == b) ? '0' : '1'; 
}

// Function to flip a bit
// represented as character.
char flip(char c) { 
    return (c == '0') ? '1' : '0'; 
}

// function to convert binary string
// to gray string
string binToGrey(string binary) {
    string gray = "";

    // MSB of gray code is same as binary code
    gray += binary[0];

    // Compute remaining bits, next bit is computed by
    // doing XOR of previous and current in Binary
    for (int i = 1; i < binary.length(); i++) {
        
        // Concatenate XOR of previous bit
        // with current bit
        gray += xorChar(binary[i - 1], binary[i]);
    }

    return gray;
}

// function to convert gray code string
// to binary string
string greyToBin(string gray) {
    string binary = "";

    // MSB of binary code is same as gray code
    binary += gray[0];

    // Compute remaining bits
    for (int i = 1; i < gray.length(); i++) {
        
        // If current bit is 0, concatenate
        // previous bit
        if (gray[i] == '0')
            binary += binary[i - 1];

        // Else, concatenate invert of
        // previous bit
        else
            binary += flip(binary[i - 1]);
    }

    return binary;
}

int main() {
    string binary = "01001";
    cout <<"Binary to Gray: " <<  binToGrey(binary) << endl;

    string gray = "01101";
    cout <<"Gray to Binary: "  <<greyToBin(gray) << endl;
    return 0;
}

Java

class GfG {

    // Function to find xor of two 
    // bits represented as character.
    static char xorChar(char a, char b) { 
        return (a == b) ? '0' : '1'; 
    }

    // Function to flip a bit
    // represented as character.
    static char flip(char c) { 
        return (c == '0') ? '1' : '0'; 
    }

    // function to convert binary string
    // to gray string
    static String binToGrey(String binary) {
        String gray = "";

        // MSB of gray code is same as binary code
        gray += binary.charAt(0);

        // Compute remaining bits, next bit is computed by
        // doing XOR of previous and current in Binary
        for (int i = 1; i < binary.length(); i++) {
            
            // Concatenate XOR of previous bit
            // with current bit
            gray += xorChar(binary.charAt(i - 1), binary.charAt(i));
        }

        return gray;
    }

    // function to convert gray code string
    // to binary string
    static String greyToBin(String gray) {
        String binary = "";

        // MSB of binary code is same as gray code
        binary += gray.charAt(0);

        // Compute remaining bits
        for (int i = 1; i < gray.length(); i++) {
            
            // If current bit is 0, concatenate
            // previous bit
            if (gray.charAt(i) == '0')
                binary += binary.charAt(i - 1);

            // Else, concatenate invert of
            // previous bit
            else
                binary += flip(binary.charAt(i - 1));
        }

        return binary;
    }

    public static void main(String[] args) {
        String binary = "01001";
        System.out.println("Binary to Gray: " + binToGrey(binary));

        String gray = "01101";
        System.out.println("Gray to Binary: " + greyToBin(gray));
    }
}

Python

# Function to find xor of two 
# bits represented as character.
def xorChar(a, b): 
    return '0' if a == b else '1'

# Function to flip a bit
# represented as character.
def flip(c): 
    return '1' if c == '0' else '0'

# function to convert binary string
# to gray string
def binToGrey(binary):
    gray = ""

    # MSB of gray code is same as binary code
    gray += binary[0]

    # Compute remaining bits, next bit is computed by
    # doing XOR of previous and current in Binary
    for i in range(1, len(binary)):
        
        # Concatenate XOR of previous bit
        # with current bit
        gray += xorChar(binary[i - 1], binary[i])

    return gray

# function to convert gray code string
# to binary string
def greyToBin(gray):
    binary = ""

    # MSB of binary code is same as gray code
    binary += gray[0]

    # Compute remaining bits
    for i in range(1, len(gray)):
        
        # If current bit is 0, concatenate
        # previous bit
        if gray[i] == '0':
            binary += binary[i - 1]

        # Else, concatenate invert of
        # previous bit
        else:
            binary += flip(binary[i - 1])

    return binary

if __name__ == "__main__":
    
    binary = "01001"
    print("Binary to Gray: " +binToGrey(binary))

    gray = "01101"
    print("Gray to Binary: " + greyToBin(gray))

C#

using System;
using System.Text;

class GfG {

    // Function to find XOR of two 
    // bits represented as characters
    static char xorChar(char a, char b) { 
        return (a == b) ? '0' : '1'; 
    }

    // Function to flip a bit 
    // represented as a character
    static char flip(char c) { 
        return (c == '0') ? '1' : '0'; 
    }

    // Function to convert binary 
    // string to gray string
    static string binToGrey(string binary) {
        StringBuilder gray = new StringBuilder();

        // MSB of gray code is 
        // same as binary code
        gray.Append(binary[0]);

        // Compute remaining bits
        for (int i = 1; i < binary.Length; i++) {
            gray.Append(xorChar(binary[i - 1], binary[i]));
        }

        return gray.ToString();
    }

    // Function to convert gray code 
    // string to binary string
    static string greyToBin(string gray) {
        StringBuilder binary = new StringBuilder();

        // MSB of binary code is same as gray code
        binary.Append(gray[0]);

        // Compute remaining bits
        for (int i = 1; i < gray.Length; i++) {
            if (gray[i] == '0')
                binary.Append(binary[i - 1]); 
            else
                binary.Append(flip(binary[i - 1])); 
        }

        return binary.ToString();
    }

    static void Main() {
        string binary = "01001";
        Console.WriteLine("Binary to Gray: " + binToGrey(binary));

        string gray = "01101";
        Console.WriteLine("Gray to Binary: " + greyToBin(gray));
    }
}

JavaScript

// JavaScript program for Binary To Gray
// and Gray to Binary conversion

// Function to find xor of two 
// bits represented as character.
function xorChar(a, b) { 
    return (a === b) ? '0' : '1'; 
}

// Function to flip a bit
// represented as character.
function flip(c) { 
    return (c === '0') ? '1' : '0'; 
}

// function to convert binary string
// to gray string
function binToGrey(binary) {
    let gray = "";

    // MSB of gray code is same as binary code
    gray += binary[0];

    // Compute remaining bits, next bit is computed by
    // doing XOR of previous and current in Binary
    for (let i = 1; i < binary.length; i++) {
        
        // Concatenate XOR of previous bit
        // with current bit
        gray += xorChar(binary[i - 1], binary[i]);
    }

    return gray;
}

// function to convert gray code string
// to binary string
function greyToBin(gray) {
    let binary = "";

    // MSB of binary code is same as gray code
    binary += gray[0];

    // Compute remaining bits
    for (let i = 1; i < gray.length; i++) {
        
        // If current bit is 0, concatenate
        // previous bit
        if (gray[i] === '0')
            binary += binary[i - 1];

        // Else, concatenate invert of
        // previous bit
        else
            binary += flip(binary[i - 1]);
    }

    return binary;
}

// Driver Code 
let binary = "01001";
console.log("Binary to Gray: "+ binToGrey(binary));

let gray = "01101";
console.log("Gray to Binary: " + greyToBin(gray));

Output

Binary to Gray: 01101
Gray to Binary: 01001

Time Complexity: O(n), where n is length of the binary string.
Auxiliary Space: O(n)

When n is given in interger

C++

#include <iostream>
using namespace std;

int binToGrey(int n) { 
    return n ^ (n >> 1); 
}

int greyToBin(int n) {
    int res = n;
    while (n > 0) {
        n >>= 1;
        res ^= n;
    }
    return res;
}

int main() {
    int n = 5;
    cout << "Binary to Gray: " <<binToGrey(n) << endl;
  	cout << "Gray to Binary: " <<greyToBin(n) << endl;
    return 0;
}

Java

// Java program for Binary To Gray
// and Gray to Binary conversion

class GfG {

    // Function to convert binary to gray
    static int binToGrey(int n) { 
        return n ^ (n >> 1); 
    }

    // Function to convert gray to binary
    static int greyToBin(int n) {
        int res = n;
        while (n > 0) {
            n >>= 1;
            res ^= n;
        }
        return res;
    }

    public static void main(String[] args) {
        int n = 5;
        System.out.println("Binary to Gray: " + binToGrey(n));
        System.out.println("Gray to Binary: " + greyToBin(n));
    }
}

Python

def binToGrey(n): 
    return n ^ (n >> 1)

# Function to convert gray to binary
def greyToBin(n):
    res = n
    while n > 0:
        n >>= 1
        res ^= n
    return res

if __name__ == "__main__":
    n = 5
    print("Binary to Gray:",binToGrey(n))
    print("Gray to Binary:",greyToBin(n))

C#

// C# program for Binary To Gray
// and Gray to Binary conversion

using System;

class GfG {

    // Function to convert binary to gray
    static int binToGrey(int n) { 
        return n ^ (n >> 1); 
    }

    // Function to convert gray to binary
    static int greyToBin(int n) {
        int res = n;
        while (n > 0) {
            n >>= 1;
            res ^= n;
        }
        return res;
    }

    static void Main() {
        int n = 5;
        Console.WriteLine("Binary to Gray: " + binToGrey(n));
        Console.WriteLine("Gray to Binary: "+ greyToBin(n));
    }
}

JavaScript

// JavaScript program for Binary To Gray
// and Gray to Binary conversion

// Function to convert binary to gray
function binToGrey(n) { 
    return n ^ (n >> 1); 
}

// Function to convert gray to binary
function greyToBin(n) {
    let res = n;
    while (n > 0) {
        n >>= 1;
        res ^= n;
    }
    return res;
}

// Driver Code 
let binary = 5;
console.log("Binary to Gray: " + binToGrey(n));
console.log("Gray to Binary: " + greyToBin(n));

Output

Binary to Gray: 7
Gray to Binary: 6

Time Complexity:

For binary to gray conversion: O(1)
For gray to binary conversion: O(log(n)), as n is a decimal number and number of bits is approximately log(n).

Auxiliary Space: O(1)

Related Article:

Generate n-bit Gray Codes

Comment

Article Tags:

binary-representation

Explore