Generate n-bit Gray Codes
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.
- Let the list of (n-1)-bit Gray codes be L1. Create another list L2 which is reverse of L1.
- Modify the list L1 by prefixing a ‘0’ in all codes of L1.
- Modify the list L2 by prefixing a ‘1’ in all codes of L2.
- 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++
#include <iostream>
#include <string>
#include <vector>
using namespace std;
void generateGrayarr( int n)
{
if (n <= 0)
return ;
vector<string> arr;
arr.push_back( "0" );
arr.push_back( "1" );
int i, j;
for (i = 2; i < (1<<n); i = i<<1)
{
for (j = i-1 ; j >= 0 ; j--)
arr.push_back(arr[j]);
for (j = 0 ; j < i ; j++)
arr[j] = "0" + arr[j];
for (j = i ; j < 2*i ; j++)
arr[j] = "1" + arr[j];
}
for (i = 0 ; i < arr.size() ; i++ )
cout << arr[i] << endl;
}
int main()
{
generateGrayarr(3);
return 0;
}
|
Java
import java.util.*;
class GfG {
static void generateGrayarr( int n)
{
if (n <= 0 )
return ;
ArrayList<String> arr = new ArrayList<String> ();
arr.add( "0" );
arr.add( "1" );
int i, j;
for (i = 2 ; i < ( 1 <<n); i = i<< 1 )
{
for (j = i- 1 ; j >= 0 ; j--)
arr.add(arr.get(j));
for (j = 0 ; j < i ; j++)
arr.set(j, "0" + arr.get(j));
for (j = i ; j < 2 *i ; j++)
arr.set(j, "1" + arr.get(j));
}
for (i = 0 ; i < arr.size() ; i++ )
System.out.println(arr.get(i));
}
public static void main(String[] args)
{
generateGrayarr( 3 );
}
}
|
Python3
import math as mt
def generateGrayarr(n):
if (n < = 0 ):
return
arr = list ()
arr.append( "0" )
arr.append( "1" )
i = 2
j = 0
while ( True ):
if i > = 1 << n:
break
for j in range (i - 1 , - 1 , - 1 ):
arr.append(arr[j])
for j in range (i):
arr[j] = "0" + arr[j]
for j in range (i, 2 * i):
arr[j] = "1" + arr[j]
i = i << 1
for i in range ( len (arr)):
print (arr[i])
generateGrayarr( 3 )
|
C#
using System;
using System.Collections.Generic;
public class GfG
{
public static void generateGrayarr( int n)
{
if (n <= 0)
{
return ;
}
List< string > arr = new List< string > ();
arr.Add( "0" );
arr.Add( "1" );
int i, j;
for (i = 2; i < (1 << n); i = i << 1)
{
for (j = i - 1 ; j >= 0 ; j--)
{
arr.Add(arr[j]);
}
for (j = 0 ; j < i ; j++)
{
arr[j] = "0" + arr[j];
}
for (j = i ; j < 2 * i ; j++)
{
arr[j] = "1" + arr[j];
}
}
for (i = 0 ; i < arr.Count ; i++)
{
Console.WriteLine(arr[i]);
}
}
public static void Main( string [] args)
{
generateGrayarr(3);
}
}
|
Javascript
<script>
function generateGrayarr(n)
{
if (n <= 0)
return ;
let arr = [];
arr.push( "0" );
arr.push( "1" );
let i, j;
for (i = 2; i < (1<<n); i = i<<1)
{
for (j = i-1 ; j >= 0 ; j--)
arr.push(arr[j]);
for (j = 0 ; j < i ; j++)
arr[j]= "0" + arr[j];
for (j = i ; j < 2*i ; j++)
arr[j]= "1" + arr[j];
}
for (i = 0 ; i < arr.length ; i++ )
document.write(arr[i]+ "<br>" );
}
generateGrayarr(3);
</script>
|
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++
#include <bits/stdc++.h>
using namespace std;
vector<string> generateGray( int n)
{
if (n <= 0)
return { "0" };
if (n == 1)
{
return { "0" , "1" };
}
vector<string> recAns=
generateGray(n-1);
vector<string> mainAns;
for ( int i=0;i<recAns.size();i++)
{
string s=recAns[i];
mainAns.push_back( "0" +s);
}
for ( int i=recAns.size()-1;i>=0;i--)
{
string s=recAns[i];
mainAns.push_back( "1" +s);
}
return mainAns;
}
void generateGrayarr( int n)
{
vector<string> arr;
arr=generateGray(n);
for ( int i = 0 ; i < arr.size();
i++ )
cout << arr[i] << endl;
}
int main()
{
generateGrayarr(3);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG
{
static ArrayList<String> generateGray( int n)
{
if (n <= 0 )
{
ArrayList<String> temp =
new ArrayList<String>(){{add( "0" );}};
return temp;
}
if (n == 1 )
{
ArrayList<String> temp =
new ArrayList<String>(){{add( "0" );add( "1" );}};
return temp;
}
ArrayList<String> recAns = generateGray(n - 1 );
ArrayList<String> mainAns = new ArrayList<String>();
for ( int i = 0 ; i < recAns.size(); i++)
{
String s = recAns.get(i);
mainAns.add( "0" + s);
}
for ( int i = recAns.size() - 1 ; i >= 0 ; i--)
{
String s = recAns.get(i);
mainAns.add( "1" + s);
}
return mainAns;
}
static void generateGrayarr( int n)
{
ArrayList<String> arr = new ArrayList<String>();
arr = generateGray(n);
for ( int i = 0 ; i < arr.size(); i++)
{
System.out.println(arr.get(i));
}
}
public static void main (String[] args)
{
generateGrayarr( 3 );
}
}
|
Python3
def generateGray(n):
if (n < = 0 ):
return [ "0" ]
if (n = = 1 ):
return [ "0" , "1" ]
recAns = generateGray(n - 1 )
mainAns = []
for i in range ( len (recAns)):
s = recAns[i]
mainAns.append( "0" + s)
for i in range ( len (recAns) - 1 , - 1 , - 1 ):
s = recAns[i]
mainAns.append( "1" + s)
return mainAns
def generateGrayarr(n):
arr = generateGray(n)
print ( * arr, sep = "\n" )
generateGrayarr( 3 )
|
C#
using System;
using System.Collections.Generic;
class GFG {
static List<String> generateGray( int n)
{
if (n <= 0) {
List<String> temp = new List<String>();
temp.Add( "0" );
return temp;
}
if (n == 1) {
List<String> temp = new List<String>();
temp.Add( "0" );
temp.Add( "1" );
return temp;
}
List<String> recAns = generateGray(n - 1);
List<String> mainAns = new List<String>();
for ( int i = 0; i < recAns.Count; i++) {
String s = recAns[i];
mainAns.Add( "0" + s);
}
for ( int i = recAns.Count - 1; i >= 0; i--) {
String s = recAns[i];
mainAns.Add( "1" + s);
}
return mainAns;
}
static void generateGrayarr( int n)
{
List<String> arr = new List<String>();
arr = generateGray(n);
for ( int i = 0; i < arr.Count; i++)
{
Console.WriteLine(arr[i]);
}
}
public static void Main(String[] args)
{
generateGrayarr(3);
}
}
|
Javascript
<script>
function generateGray(n)
{
if (n <= 0)
{
let temp =[ "0" ];
return temp;
}
if (n == 1)
{
let temp =[ "0" , "1" ];
return temp;
}
let recAns = generateGray(n - 1);
let mainAns = [];
for (let i = 0; i < recAns.length; i++)
{
let s = recAns[i];
mainAns.push( "0" + s);
}
for (let i = recAns.length - 1; i >= 0; i--)
{
let s = recAns[i];
mainAns.push( "1" + s);
}
return mainAns;
}
function generateGrayarr(n)
{
let arr = [];
arr = generateGray(n);
for (let i = 0 ; i < arr.length; i++)
{
document.write(arr[i]+ "<br>" );
}
}
generateGrayarr(3);
</script>
|
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++
#include <bits/stdc++.h>
using namespace std;
void GreyCode( int n)
{
for ( int i = 0; i < (1 << n); i++)
{
int val = (i ^ (i >> 1));
bitset<32> r(val);
string s = r.to_string();
cout << s.substr(32 - n) << " " ;
}
}
int main()
{
int n;
n = 4;
GreyCode(n);
return 0;
}
|
Java
import java.lang.Math;
class GFG {
static void GreyCode( int n)
{
for ( int i = 0 ; i < ( 1 << n); i++)
{
int val = (i ^ (i >> 1 ));
String s = Integer.toBinaryString(val);
System.out.print(
String.format( "%1$" + n + "s" , s)
.replace( ' ' , '0' )
+ " " );
}
}
public static void main(String[] args)
{
int n = 4 ;
GreyCode(n);
}
}
|
Python3
def GreyCode(n):
for i in range ( 1 << n):
val = (i ^ (i >> 1 ))
s = bin (val)[ 2 ::]
print (s.zfill(n), end = " " )
n = 4
GreyCode(n)
|
Javascript
function GreyCode(n)
{
for ( var i = 0; i < (1 << n); i++)
{
var val = (i ^ (i >> 1));
s = val.toString(2);
process.stdout.write(s.padStart(4, '0' ) + " " );
}
}
let n = 4;
GreyCode(n);
|
C#
using System;
class GFG {
static void GreyCode( int n)
{
for ( int i = 0; i < (1 << n); i++) {
int val = (i ^ (i >> 1));
string s = Convert.ToString(val, 2);
Console.Write(s.PadLeft(4, '0' ) + " " );
}
}
public static void Main( string [] args)
{
int n = 4;
GreyCode(n);
}
}
|
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)
Share your thoughts in the comments
Please Login to comment...