灰度到二进制和二进制到灰度转换

二进制数是存储数字的默认方式，但是在许多应用中，二进制数很难使用，并且需要二进制数的变体。这是格雷码非常有用的地方。

格雷码具有两个连续的数字仅相差一比特的特性，因为该特性格雷码以最小的努力完成了各种状态之间的循环，并用于K映射，纠错，通信等。

如何生成n位格雷码?

Following is 2-bit sequence (n = 2)
  00 01 11 10
Following is 3-bit sequence (n = 3)
  000 001 011 010 110 111 101 100
And Following is 4-bit sequence (n = 4)
  0000 0001 0011 0010 0110 0111 0101 0100 1100 1101 1111 
  1110 1010 1011 1001 1000

可以使用以下步骤从(n-1)位格雷码列表中生成n位格雷码。

1. 令(n-1)位格雷码的列表为L1。创建另一个列表L2，它与L1相反。
2. 通过在L1的所有代码中添加前缀“ 0”来修改列表L1。
3. 通过在L2的所有代码中添加前缀“ 1”来修改列表L2。
4. 连接L1和L2。级联列表是n位格雷码的必需列表。

有关详细程序，请参阅生成n位格雷码。

如何将二进制转换为Gray和Vice Versa?

Binary : 0011
Gray   : 0010

Binary : 01001
Gray   : 01101

在计算机科学中，很多时候我们需要将二进制代码转换为格雷代码，反之亦然。可以通过应用以下规则来完成此转换：

二进制到灰色的转换：

1. 格雷码的最高有效位(MSB)始终等于给定二进制码的MSB。
2. 通过在该索引和先前索引处对二进制代码位进行XOR运算，可以获得输出格雷码的其他位。

灰色到二进制转换：

1. 二进制代码的最高有效位(MSB)始终等于给定格雷码的MSB。
2. 可以通过检查该索引处的格雷码位来获得输出二进制码的其他位。如果当前格雷码位为0，则复制先前的二进制码位，否则复制先前的二进制码位的反转。

下面是上述步骤的实现。

C++

// C++ program for Binary To Gray
// and Gray to Binary conversion
#include 
using namespace std;
 
// Helper function to xor two characters
char xor_c(char a, char b) { return (a == b) ? '0' : '1'; }
 
// Helper function to flip the bit
char flip(char c) { return (c == '0') ? '1' : '0'; }
 
// function to convert binary string
// to gray string
string binarytoGray(string binary)
{
    string gray = "";
 
    // MSB of gray code is same as binary code
    gray += binary[0];
 
    // Compute remaining bits, next bit is comuted 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 += xor_c(binary[i - 1], binary[i]);
    }
 
    return gray;
}
 
// function to convert gray code string
// to binary string
string graytoBinary(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;
}
 
// Driver program to test above functions
int main()
{
    string binary = "01001";
    cout << "Gray code of " << binary << " is "
         << binarytoGray(binary) << endl;
 
    string gray = "01101";
    cout << "Binary code of " << gray << " is "
         << graytoBinary(gray) << endl;
    return 0;
}

Java

// Java program for Binary To Gray
// and Gray to Binary conversion
import java.io.*;
class code_conversion
{
   
    // Helper function to xor
    // two characters
    char xor_c(char a, char b)
    {
        return (a == b) ? '0' : '1';
    }
 
    // Helper function to flip the bit
    char flip(char c)
    {
        return (c == '0') ? '1' : '0';
    }
 
    // function to convert binary
  // string to gray string
    String binarytoGray(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 += xor_c(binary.charAt(i - 1),
                          binary.charAt(i));
        }
       return gray;
    }
   
    // function to convert gray code
    // string to binary string
    String graytoBinary(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;
    }
 
    // Driver program to test above functions
    public static void main(String args[])
        throws IOException
    {
        code_conversion ob = new code_conversion();
        String binary = "01001";
        System.out.println("Gray code of " +
                           binary + " is " +
                           ob.binarytoGray(binary));
 
        String gray = "01101";
        System.out.println("Binary code of " +
                           gray + " is " +
                           ob.graytoBinary(gray));
    }
  }
 
// This code is contributed by Anshika Goyal.

Python3

# Python3 program for Binary To Gray
# and Gray to Binary conversion
 
# Helper function to xor two characters
def xor_c(a, b):
    return '0' if(a == b) else '1';
 
# Helper function to flip the bit
def flip(c):
    return '1' if(c == '0') else '0';
 
# function to convert binary string
# to gray string
def binarytoGray(binary):
    gray = "";
 
    # MSB of gray code is same as
    # binary code
    gray += binary[0];
 
    # Compute remaining bits, next bit
    # is comuted 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 += xor_c(binary[i - 1],
                      binary[i]);
 
    return gray;
 
# function to convert gray code
# string to binary string
def graytoBinary(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;
 
# Driver Code
binary = "01001";
print("Gray code of", binary, "is",
             binarytoGray(binary));
 
gray = "01101";
print("Binary code of", gray, "is",
               graytoBinary(gray));
     
# This code is contributed by mits

C#

// C# program for Binary To Gray
// and Gray to Binary conversion.
using System;
 
class GFG {
 
    // Helper function to xor
    // two characters
    static char xor_c(char a, char b)
    {
        return (a == b) ? '0' : '1';
    }
 
    // Helper function to flip the bit
    static char flip(char c)
    {
        return (c == '0') ? '1' : '0';
    }
 
    // function to convert binary
    // string to gray string
    static String binarytoGray(String binary)
    {
        String gray = "";
 
        // MSB of gray code is same
        // as binary code
        gray += binary[0];
 
        // Compute remaining bits, next
        // bit is comuted 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 += xor_c(binary[i - 1],
                          binary[i]);
        }
 
        return gray;
    }
 
    // function to convert gray code
    // string to binary string
    static String graytoBinary(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;
    }
 
    // Driver program to test above
    // functions
    public static void Main()
 
    {
        String binary = "01001";
        Console.WriteLine("Gray code of "
                          + binary + " is "
                          + binarytoGray(binary));
 
        String gray = "01101";
        Console.Write("Binary code of "
                      + gray + " is "
                      + graytoBinary(gray));
    }
}
 
// This code is contributed by nitin mittal.

输出

Gray code of 01001 is 01101
Binary code of 01101 is 01001

使用按位运算符从二进制到灰色

C++

// C++ program for above approach
#include 
using namespace std;
 
int greyConverter(int n) { return n ^ (n >> 1); }
 
int main()
{
    int n = 3;
    cout << greyConverter(n) << endl;
 
    n = 9;
    cout << greyConverter(n) << endl;
 
    return 0;
}

Java

// Java Program for above approach
public class Main {
    public static int greyConverter(int n)
    {
        return n ^ (n >> 1);
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int n = 3;
        System.out.println(greyConverter(n));
 
        n = 9;
        System.out.println(greyConverter(n));
    }
}
 
// This code is contributed by divyesh072019

Python3

# Python3 code for above approach
def greyConverter(n):
 
    return n ^ (n >> 1)
 
 
n = 3
print(greyConverter(n))
 
n = 9
print(greyConverter(n))
 
# This code is contributed by divyeshrabadiya07

C＃

// C# program for above approach
using System;
 
class GFG {
 
    static int greyConverter(int n) { return n ^ (n >> 1); }
 
    // Driver Code
    public static void Main(string[] args)
    {
        int n = 3;
        Console.WriteLine(greyConverter(n));
 
        n = 9;
        Console.WriteLine(greyConverter(n));
    }
}
 
// This code is contributed by rutvik_56

Java脚本

 
// Javascript program for above approach
function greyConverter(n)
{
    return n ^ (n >> 1);
}
 
// Driver code
let n = 3;
document.write(greyConverter(n) + "</br>");
 
n = 9;
document.write(greyConverter(n));
 
// This code is contributed by suresh07
 

输出

2
13

使用位运算符将灰度转换为二进制

C++

// C++ program for above approach
#include 
using namespace std;
 
int binaryConverter(int n)
{
    int res = n;
    while (n > 0)
    {
        n >>= 1;
        res ^= n;
    }
    return res;
}
 
// Driver Code
int main()
{
    int n = 4;
   
    // Function call
    cout << binaryConverter(n) << endl;
 
    return 0;
}
 
// This code is contributed by sshrey47

Java

// Java Program for above approach
public class Main {
    public static int binaryConverter(int n)
    {
        int res = n;
 
        while (n > 0) {
            n >>= 1;
            res ^= n;
        }
 
        return res;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int n = 4;
        System.out.println(binaryConverter(n));
    }
}
 
// This code is contributed by sshrey47

Python3

# Python3 code for above approach
def binaryConverter(n):
    res = n
 
    while n > 0:
        n >>= 1
        res ^= n
 
    return res
 
 
n = 4
print(binaryConverter(n))
 
# This code is contributed by sshrey47

C＃

using System;
 
public class GFG {
 
    static int binaryConverter(int n)
    {
        int res = n;
 
        while (n > 0) {
            n >>= 1;
            res ^= n;
        }
 
        return res;
    }
 
    static public void Main()
    {
        int n = 4;
        Console.WriteLine(binaryConverter(n));
    }
}
 
// This code is contributed by sshrey47

Java脚本

    // Javascript program for above approach
     
    function binaryConverter(n)
    {
           let res = n;
        while (n > 0)
        {
            n >>= 1;
            res ^= n;
        }
        return res;
    }
 
    let n = 4;
    
    // Function call
    document.write(binaryConverter(n));
     
    // This code is contributed by mukesh07.

输出

7