Gray to Binary and Binary to Gray conversion (original) (raw)

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