Related Articles
Generate n-bit Gray Codes
• Difficulty Level : Medium
• Last Updated : 20 Jan, 2021

Given a number N, generate bit patterns from 0 to 2^N-1 such that successive patterns differ by one bit.

Examples:

```Input: N = 2
Output: 00 01 11 10

Input: N = 3
Output: 000 001 011 010 110 111 101 100```

Method-1

The above sequences are Gray Codes of different widths. Following is an interesting pattern in Gray Codes.
n-bit Gray Codes can be generated from list of (n-1)-bit Gray codes using following steps.

1. Let the list of (n-1)-bit Gray codes be L1. Create another list L2 which is reverse of L1.
2. Modify the list L1 by prefixing a ‘0’ in all codes of L1.
3. Modify the list L2 by prefixing a ‘1’ in all codes of L2.
4. Concatenate L1 and L2. The concatenated list is required list of n-bit Gray codes

For example, following are steps for generating the 3-bit Gray code list from the list of 2-bit Gray code list.
L1 = {00, 01, 11, 10} (List of 2-bit Gray Codes)
L2 = {10, 11, 01, 00} (Reverse of L1)
Prefix all entries of L1 with ‘0’, L1 becomes {000, 001, 011, 010}
Prefix all entries of L2 with ‘1’, L2 becomes {110, 111, 101, 100}
Concatenate L1 and L2, we get {000, 001, 011, 010, 110, 111, 101, 100}
To generate n-bit Gray codes, we start from list of 1 bit Gray codes. The list of 1 bit Gray code is {0, 1}. We repeat above steps to generate 2 bit Gray codes from 1 bit Gray codes, then 3-bit Gray codes from 2-bit Gray codes till the number of bits becomes equal to n.

Below is the implementation of the above approach:

## C++

 `// C++ program to generate n-bit Gray codes` `#include ` `#include ` `#include ` `using` `namespace` `std;`   `// This function generates all n bit Gray codes and prints the` `// generated codes` `void` `generateGrayarr(``int` `n)` `{` `    ``// base case` `    ``if` `(n <= 0)` `        ``return``;`   `    ``// 'arr' will store all generated codes` `    ``vector arr;`   `    ``// start with one-bit pattern` `    ``arr.push_back(``"0"``);` `    ``arr.push_back(``"1"``);`   `    ``// Every iteration of this loop generates 2*i codes from previously` `    ``// generated i codes.` `    ``int` `i, j;` `    ``for` `(i = 2; i < (1<= 0 ; j--)` `            ``arr.push_back(arr[j]);`   `        ``// append 0 to the first half` `        ``for` `(j = 0 ; j < i ; j++)` `            ``arr[j] = ``"0"` `+ arr[j];`   `        ``// append 1 to the second half` `        ``for` `(j = i ; j < 2*i ; j++)` `            ``arr[j] = ``"1"` `+ arr[j];` `    ``}`   `    ``// print contents of arr[]` `    ``for` `(i = 0 ; i < arr.size() ; i++ )` `        ``cout << arr[i] << endl;` `}`   `// Driver program to test above function` `int` `main()` `{` `    ``generateGrayarr(3);` `    ``return` `0;` `}`

## Java

 `// Java program to generate n-bit Gray codes ` `import` `java.util.*;` `class` `GfG { `   `// This function generates all n bit Gray codes and prints the ` `// generated codes ` `static` `void` `generateGrayarr(``int` `n) ` `{ ` `    ``// base case ` `    ``if` `(n <= ``0``) ` `        ``return``; `   `    ``// 'arr' will store all generated codes ` `    ``ArrayList arr = ``new` `ArrayList (); `   `    ``// start with one-bit pattern ` `    ``arr.add(``"0"``); ` `    ``arr.add(``"1"``); `   `    ``// Every iteration of this loop generates 2*i codes from previously ` `    ``// generated i codes. ` `    ``int` `i, j; ` `    ``for` `(i = ``2``; i < (``1``<= ``0` `; j--) ` `            ``arr.add(arr.get(j)); `   `        ``// append 0 to the first half ` `        ``for` `(j = ``0` `; j < i ; j++) ` `            ``arr.set(j, ``"0"` `+ arr.get(j)); `   `        ``// append 1 to the second half ` `        ``for` `(j = i ; j < ``2``*i ; j++) ` `            ``arr.set(j, ``"1"` `+ arr.get(j)); ` `    ``} `   `    ``// print contents of arr[] ` `    ``for` `(i = ``0` `; i < arr.size() ; i++ ) ` `        ``System.out.println(arr.get(i)); ` `} `   `// Driver program to test above function ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``generateGrayarr(``3``); ` `}` `} `

## Python3

 `# Python3 program to generate n-bit Gray codes` `import` `math as mt`   `# This function generates all n bit Gray ` `# codes and prints the generated codes` `def` `generateGrayarr(n):`   `    ``# base case` `    ``if` `(n <``=` `0``):` `        ``return`   `    ``# 'arr' will store all generated codes` `    ``arr ``=` `list``()`   `    ``# start with one-bit pattern` `    ``arr.append(``"0"``)` `    ``arr.append(``"1"``)`   `    ``# Every iteration of this loop generates ` `    ``# 2*i codes from previously generated i codes.` `    ``i ``=` `2` `    ``j ``=` `0` `    ``while``(``True``):`   `        ``if` `i >``=` `1` `<< n:` `            ``break` `    `  `        ``# Enter the prviously generated codes ` `        ``# again in arr[] in reverse order. ` `        ``# Nor arr[] has double number of codes.` `        ``for` `j ``in` `range``(i ``-` `1``, ``-``1``, ``-``1``):` `            ``arr.append(arr[j])`   `        ``# append 0 to the first half` `        ``for` `j ``in` `range``(i):` `            ``arr[j] ``=` `"0"` `+` `arr[j]`   `        ``# append 1 to the second half` `        ``for` `j ``in` `range``(i, ``2` `*` `i):` `            ``arr[j] ``=` `"1"` `+` `arr[j]` `        ``i ``=` `i << ``1`   `    ``# prcontents of arr[]` `    ``for` `i ``in` `range``(``len``(arr)):` `        ``print``(arr[i])`   `# Driver Code` `generateGrayarr(``3``)`   `# This code is contributed ` `# by Mohit kumar 29`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `// C# program to generate n-bit Gray codes  ` `public` `class` `GfG` `{`   `// This function generates all n bit Gray codes and prints the  ` `// generated codes  ` `public` `static` `void` `generateGrayarr(``int` `n)` `{` `    ``// base case  ` `    ``if` `(n <= 0)` `    ``{` `        ``return``;` `    ``}`   `    ``// 'arr' will store all generated codes  ` `    ``List<``string``> arr = ``new` `List<``string``> ();`   `    ``// start with one-bit pattern  ` `    ``arr.Add(``"0"``);` `    ``arr.Add(``"1"``);`   `    ``// Every iteration of this loop generates 2*i codes from previously  ` `    ``// generated i codes.  ` `    ``int` `i, j;` `    ``for` `(i = 2; i < (1 << n); i = i << 1)` `    ``{` `        ``// Enter the prviously generated codes again in arr[] in reverse  ` `        ``// order. Nor arr[] has double number of codes.  ` `        ``for` `(j = i - 1 ; j >= 0 ; j--)` `        ``{` `            ``arr.Add(arr[j]);` `        ``}`   `        ``// append 0 to the first half  ` `        ``for` `(j = 0 ; j < i ; j++)` `        ``{` `            ``arr[j] = ``"0"` `+ arr[j];` `        ``}`   `        ``// append 1 to the second half  ` `        ``for` `(j = i ; j < 2 * i ; j++)` `        ``{` `            ``arr[j] = ``"1"` `+ arr[j];` `        ``}` `    ``}`   `    ``// print contents of arr[]  ` `    ``for` `(i = 0 ; i < arr.Count ; i++)` `    ``{` `        ``Console.WriteLine(arr[i]);` `    ``}` `}`   `// Driver program to test above function  ` `public` `static` `void` `Main(``string``[] args)` `{` `    ``generateGrayarr(3);` `}` `}`   `  ``// This code is contributed by Shrikant13`

Output

```000
001
011
010
110
111
101
100```

Method 2: Recursive Approach

The idea is to recursively append the bit 0 and 1 each time until the number of bits is not equal to N.

Base Condition: The base case for this problem will be when the value of N = 0 or 1.

If (N == 0)
return {“0”}
if (N == 1)
return {“0”, “1”}

Recursive Condition: Otherwise, for any value greater than 1, recursively generate the gray codes of the N – 1 bits and then for each of the gray code generated add the prefix 0 and 1.

Below is the implementation of the above approach:

## C++

 `// C++ program to generate` `// n-bit Gray codes`   `#include ` `using` `namespace` `std;`   `// This function generates all n ` `// bit Gray codes and prints the` `// generated codes` `vector generateGray(``int` `n)` `{` `    ``// Base case` `    ``if` `(n <= 0)` `        ``return` `{``"0"``};`   `    ``if` `(n == 1)` `    ``{` `      ``return` `{``"0"``,``"1"``};` `    ``}`   `    ``//Recursive case` `    ``vector recAns=` `          ``generateGray(n-1);` `    ``vector mainAns;` `    `  `    ``// Append 0 to the first half` `    ``for``(``int` `i=0;i=0;i--)` `    ``{` `       ``string s=recAns[i];` `       ``mainAns.push_back(``"1"``+s);` `    ``}` `    ``return` `mainAns;` `}`   `// Function to generate the ` `// Gray code of N bits` `void` `generateGrayarr(``int` `n)` `{` `    ``vector arr;` `    ``arr=generateGray(n);` `    ``// print contents of arr ` `    ``for` `(``int` `i = 0 ; i < arr.size();` `         ``i++ )` `        ``cout << arr[i] << endl;` `}`   `// Driver Code` `int` `main()` `{` `    ``generateGrayarr(3);` `    ``return` `0;` `}`

## Python3

 `# Python3 program to generate` `# n-bit Gray codes`   `# This function generates all n ` `# bit Gray codes and prints the` `# generated codes` `def` `generateGray(n):` `    `  `    ``# Base case` `    ``if` `(n <``=` `0``):` `        ``return` `[``"0"``]` `    ``if` `(n ``=``=` `1``):` `        ``return` `[ ``"0"``, ``"1"` `]`   `    ``# Recursive case` `    ``recAns ``=` `generateGray(n ``-` `1``)`   `    ``mainAns ``=` `[]` `    `  `    ``# Append 0 to the first half` `    ``for` `i ``in` `range``(``len``(recAns)):` `        ``s ``=` `recAns[i]` `        ``mainAns.append(``"0"` `+` `s)`   `    ``# Append 1 to the second half` `    ``for` `i ``in` `range``(``len``(recAns) ``-` `1``, ``-``1``, ``-``1``):` `        ``s ``=` `recAns[i]` `        ``mainAns.append(``"1"` `+` `s)`   `    ``return` `mainAns`   `# Function to generate the ` `# Gray code of N bits` `def` `generateGrayarr(n):` `    `  `    ``arr ``=` `generateGray(n)`   `    ``# Print contents of arr ` `    ``print``(``*``arr, sep ``=` `"\n"``)`   `# Driver Code` `generateGrayarr(``3``)`   `# This code is contributed by avanitrachhadiya2155`

Output

```000
001
011
010
110
111
101
100```

Method3: (Using bitset)

We should first find binary no from 1 to n and then convert it into string and then print it using substring function of string.

Below is the implementation of the above idea:

## C++

 `// C++ implementation of the above approach` `#include ` `using` `namespace` `std;`   `void` `GreyCode(``int` `n)` `{` `     ``// power of 2` `    ``for` `(``int` `i = 0; i < (1 << n); i++) ` `    ``{` `        ``// Generating the decimal ` `        ``// values of gray code then using ` `        ``// bitset to convert them to binary form` `        ``int` `val = (i ^ (i >> 1));` `        `  `        ``// Using bitset` `        ``bitset<32> r(val);` `        `  `        ``// Converting to string` `        ``string s = r.to_string();` `        ``cout << s.substr(32 - n) << ``" "``;` `    ``}` `}`     `// Driver Code` `int` `main()` `{` `    ``int` `n;` `    ``n = 4;` `  `  `    ``// Function call` `    ``GreyCode(n);` `   `  `    ``return` `0;` `}`

Output

`0000 0001 0011 0010 0110 0111 0101 0100 1100 1101 1111 1110 1010 1011 1001 1000 `

Time Complexity: O(2n)