# Generate n-bit Gray Codes

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)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next