Gray Code - Practice Coding Problems

Gray Code - Problem

A Gray Code (also known as reflected binary code) is a fascinating sequence where adjacent numbers differ by exactly one bit! Think of it as a clever way to count where you change only one digit at a time.

Given an integer n, you need to generate a valid n-bit Gray Code sequence that satisfies these conditions:

Contains exactly 2ⁿ integers in the range [0, 2ⁿ - 1]
Starts with 0
Each integer appears exactly once
Adjacent integers differ by exactly one bit
The first and last integers also differ by exactly one bit (circular property)

Example: For n = 2, a valid sequence is [0, 1, 3, 2]
Binary: [00, 01, 11, 10] - notice each pair differs by one bit!

Input & Output

example_1.py — Basic case

$ Input: n = 2

› Output: [0, 1, 3, 2]

💡 Note: For n=2, we need 4 numbers (2²). The sequence [0,1,3,2] in binary is [00,01,11,10]. Each adjacent pair differs by exactly 1 bit: 00→01 (bit 0), 01→11 (bit 1), 11→10 (bit 0), and 10→00 (bit 1, circular).

example_2.py — Single bit

$ Input: n = 1

› Output: [0, 1]

💡 Note: For n=1, we need 2 numbers (2¹). The sequence [0,1] in binary is [0,1]. They differ by exactly 1 bit, and 1→0 also differs by 1 bit (circular property).

example_3.py — Edge case

$ Input: n = 3

› Output: [0, 1, 3, 2, 6, 7, 5, 4]

💡 Note: For n=3, we need 8 numbers (2³). This sequence follows the mirror construction: G(3) is built from G(2)=[0,1,3,2] by appending its reverse [2,3,1,0] with MSB set, giving [6,7,5,4].

Visualization

Tap to expand

Understanding the Visualization

Start at 00

Begin with all switches OFF

Flip rightmost

Change to 01 - only rightmost switch changes

Flip left switch

Change to 11 - only left switch changes

Flip rightmost

Change to 10 - only rightmost switch changes

Return to start

Back to 00 - only left switch changes

Key Takeaway

🎯 Key Insight: Gray Code follows a beautiful pattern where we can generate the sequence using either the mathematical formula i ⊕ (i >> 1) or the recursive mirror construction, both achieving optimal O(2^n) time complexity!

Time & Space Complexity

Time Complexity

⏱️

O((2^n)!)

We try all permutations of 2^n numbers, leading to factorial time complexity

⚠ Quadratic Growth

Space Complexity

O(2^n)

Recursion stack depth can go up to 2^n levels, plus storing the sequence

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 16
Important: The result must contain exactly 2ⁿ unique integers
All integers must be in range [0, 2ⁿ - 1]

Asked in

G Google 42 a Amazon 35 ⊞ Microsoft 28 f Meta 22

The optimal solution uses the mathematical formula G(i) = i ⊕ (i >> 1) to generate Gray Code in O(2ⁿ) time. Alternatively, the recursive mirror construction provides an intuitive approach by building G(n) from G(n-1) using the beautiful reflection property.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Backtracking)	O((2^n)!)	O(2^n)	Try all possible sequences using backtracking and validate constraints
Mathematical Formula (Optimal)	O(2^n)	O(2^n)	Use the mathematical property: G(i) = i XOR (i >> 1)
Recursive Mirror Construction	O(2^n)	O(2^n)	Build Gray Code recursively using the mirror reflection property

Brute Force (Backtracking) — Algorithm Steps

Start with [0] as the initial sequence
For each position, try all unused numbers from 0 to 2^n-1
Check if the new number differs by exactly one bit from the last number
Recursively build the sequence using backtracking
Verify the final sequence forms a valid Gray Code (including circularity)

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with 0

Begin sequence with [0] and mark as used

Try valid neighbors

For each position, try numbers that differ by 1 bit

Backtrack on failure

If path leads to dead end, backtrack and try next option

Check circularity

Verify last number differs from first by exactly 1 bit

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

bool differsByOneBit(int a, int b) {
    int xor = a ^ b;
    return xor > 0 && (xor & (xor - 1)) == 0;
}

bool backtrack(int* sequence, bool* used, int pos, int n, int total) {
    if (pos == total) {
        return differsByOneBit(sequence[pos-1], sequence[0]);
    }
    
    int last = sequence[pos-1];
    for (int num = 0; num < total; num++) {
        if (!used[num] && differsByOneBit(last, num)) {
            sequence[pos] = num;
            used[num] = true;
            if (backtrack(sequence, used, pos + 1, n, total)) {
                return true;
            }
            used[num] = false;
        }
    }
    return false;
}

int* grayCode(int n, int* returnSize) {
    int total = 1 << n;
    int* sequence = (int*)malloc(total * sizeof(int));
    bool* used = (bool*)calloc(total, sizeof(bool));
    
    sequence[0] = 0;
    used[0] = true;
    backtrack(sequence, used, 1, n, total);
    
    *returnSize = total;
    free(used);
    return sequence;
}

int main() {
    int n;
    scanf("%d", &n);
    int returnSize;
    int* result = grayCode(n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(", ");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((2^n)!)

We try all permutations of 2^n numbers, leading to factorial time complexity

⚠ Quadratic Growth

Space Complexity

O(2^n)

Recursion stack depth can go up to 2^n levels, plus storing the sequence

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 16
Important: The result must contain exactly 2ⁿ unique integers
All integers must be in range [0, 2ⁿ - 1]

52.3K Views

Medium Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Backtracking) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler