Open in App
Not now

# Generate n-bit Gray Codes

• Difficulty Level : Medium
• Last Updated : 03 Feb, 2023

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 previously 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`   `    ``# print contents 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 previously 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`

## Javascript

 ``

Output

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

Time Complexity: O(2N)
Auxiliary Space: O(2N)

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

## Java

 `// Java program to generate` `// n-bit Gray codes` `import` `java.io.*;` `import` `java.util.*;` `class` `GFG` `{`   `  ``// This function generates all n ` `  ``// bit Gray codes and prints the` `  ``// generated codes` `  ``static` `ArrayList generateGray(``int` `n)` `  ``{`   `    ``// Base case` `    ``if` `(n <= ``0``)` `    ``{` `      ``ArrayList temp =` `        ``new` `ArrayList(){{add(``"0"``);}};` `      ``return` `temp;` `    ``}` `    ``if``(n == ``1``)` `    ``{` `      ``ArrayList temp = ` `        ``new` `ArrayList(){{add(``"0"``);add(``"1"``);}};` `      ``return` `temp;` `    ``}`   `    ``// Recursive case` `    ``ArrayList recAns = generateGray(n - ``1``);` `    ``ArrayList mainAns = ``new` `ArrayList();`   `    ``// Append 0 to the first half` `    ``for``(``int` `i = ``0``; i < recAns.size(); i++)` `    ``{` `      ``String s = recAns.get(i);` `      ``mainAns.add(``"0"` `+ s);`   `    ``}`   `    ``// Append 1 to the second half` `    ``for``(``int` `i = recAns.size() - ``1``; i >= ``0``; i--)` `    ``{` `      ``String s = recAns.get(i);` `      ``mainAns.add(``"1"` `+ s);` `    ``}` `    ``return` `mainAns;` `  ``}`   `  ``// Function to generate the ` `  ``// Gray code of N bits` `  ``static` `void` `generateGrayarr(``int` `n)` `  ``{` `    ``ArrayList arr = ``new` `ArrayList();` `    ``arr = generateGray(n);`   `    ``// print contents of arr ` `    ``for` `(``int` `i = ``0` `; i < arr.size(); i++)` `    ``{` `      ``System.out.println(arr.get(i));    ` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main (String[] args)` `  ``{` `    ``generateGrayarr(``3``);` `  ``}` `}`   `// This code is contributed by rag2127.`

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

## C#

 `// Java program to generate` `// n-bit Gray codes` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG {`   `  ``// This function generates all n` `  ``// bit Gray codes and prints the` `  ``// generated codes` `  ``static` `List generateGray(``int` `n)` `  ``{`   `    ``// Base case` `    ``if` `(n <= 0) {` `      ``List temp = ``new` `List();` `      ``temp.Add(``"0"``);` `      ``return` `temp;` `    ``}` `    ``if` `(n == 1) {` `      ``List temp = ``new` `List();` `      ``temp.Add(``"0"``);` `      ``temp.Add(``"1"``);` `      ``return` `temp;` `    ``}`   `    ``// Recursive case` `    ``List recAns = generateGray(n - 1);` `    ``List mainAns = ``new` `List();`   `    ``// Append 0 to the first half` `    ``for` `(``int` `i = 0; i < recAns.Count; i++) {` `      ``String s = recAns[i];` `      ``mainAns.Add(``"0"` `+ s);` `    ``}`   `    ``// Append 1 to the second half` `    ``for` `(``int` `i = recAns.Count - 1; i >= 0; i--) {` `      ``String s = recAns[i];` `      ``mainAns.Add(``"1"` `+ s);` `    ``}` `    ``return` `mainAns;` `  ``}`   `  ``// Function to generate the` `  ``// Gray code of N bits` `  ``static` `void` `generateGrayarr(``int` `n)` `  ``{` `    ``List arr = ``new` `List();` `    ``arr = generateGray(n);`   `    ``// print contents of arr` `    ``for` `(``int` `i = 0; i < arr.Count; i++) ` `    ``{` `      ``Console.WriteLine(arr[i]);` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(String[] args)` `  ``{` `    ``generateGrayarr(3);` `  ``}` `}`   `// This code is contributed by grand_master.`

## Javascript

 ``

Output

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

Time Complexity: O(2N)
Auxiliary Space: O(2N)

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

## Java

 `// Java implementation of the above approach` `import` `java.lang.Math;`   `class` `GFG {`   `  ``static` `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``));`   `      ``// Converting to binary string` `      ``String s = Integer.toBinaryString(val);` `      ``System.out.print(` `        ``String.format(``"%1\$"` `+ n + ``"s"``, s)` `        ``.replace(``' '``, ``'0'``)` `        ``+ ``" "``);` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `n = ``4``;`   `    ``// Function call` `    ``GreyCode(n);` `  ``}` `}`   `// This code is contributed by phasing17`

## Python3

 `# Python3 implementation of the above approach` `def` `GreyCode(n):`   `    ``# power of 2` `    ``for` `i ``in` `range``(``1` `<< n):` `      `  `        ``# Generating the decimal ` `        ``# values of gray code then using ` `        ``# bitset to convert them to binary form` `        ``val ``=` `(i ^ (i >> ``1``))` `        `  `        ``# Converting to binary string` `        ``s ``=` `bin``(val)[``2``::]` `        ``print``(s.zfill(n), end ``=` `" "``)`   `# Driver Code` `n ``=` `4` `  `  `# Function call` `GreyCode(n)`   `# This code is contributed by phasing17`

## Javascript

 `// JavaScript implementation of the above approach` `function` `GreyCode(n)` `{`   `    ``// power of 2` `    ``for` `(``var` `i = 0; i < (1 << n); i++)` `    ``{` `        ``// Generating the decimal ` `        ``// values of gray code then using ` `        ``// bitset to convert them to binary form` `        ``var` `val = (i ^ (i >> 1));` `        `  `        ``// Converting to binary string` `        ``s = val.toString(2);` `        ``process.stdout.write(s.padStart(4, ``'0'``) + ``" "``);` `    ``}` `}`   `// Driver Code` `let n = 4;` `  `  `// Function call` `GreyCode(n);`   `// This code is contributed by phasing17`

## C#

 `// C# implementation of the above approach`   `using` `System;`   `class` `GFG {`   `    ``static` `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));`   `            ``// Converting to binary string` `            ``string` `s = Convert.ToString(val, 2);` `            ``Console.Write(s.PadLeft(4, ``'0'``) + ``" "``);` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``int` `n = 4;` `        ``// Function call` `        ``GreyCode(n);` `    ``}` `}`   `// This code is contributed by phasing17`

Output

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

Time Complexity: O(2N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Related Articles