Gray Code

Gray Code - Problem

An n-bit gray code sequence is a sequence of 2^n integers where:

Every integer is in the inclusive range [0, 2^n - 1]
The first integer is 0
An integer appears no more than once in the sequence
The binary representation of every pair of adjacent integers differs by exactly one bit
The binary representation of the first and last integers differs by exactly one bit

Given an integer n, return any valid n-bit gray code sequence.

Input & Output

Example 1 — Basic Case (n=2)

$ Input: n = 2

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

💡 Note: Binary: [00,01,11,10]. Each adjacent pair differs by one bit: 00→01 (bit 0), 01→11 (bit 1), 11→10 (bit 0), 10→00 (bit 1, wraps around).

Example 2 — Minimum Case (n=1)

$ Input: n = 1

› Output: [0,1]

💡 Note: Binary: [0,1]. Only two 1-bit numbers: 0→1 differs by bit 0, and 1→0 wraps around differing by bit 0.

Example 3 — Edge Case (n=0)

$ Input: n = 0

› Output: [0]

💡 Note: Only one 0-bit number exists: 0. Single element trivially satisfies Gray code properties.

Constraints

0 ≤ n ≤ 16
Answer is guaranteed to fit in a 32-bit integer

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is that Gray codes follow a recursive pattern where G(n) = [G(n-1), reverse(G(n-1)) + 2^(n-1)]. Best approach is iterative bit manipulation to avoid recursion overhead. Time: O(2^n), Space: O(2^n)

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force Backtracking

⏱️ Time: O(2^n × n) Space: O(2^n)

Generate all possible numbers 0 to 2^n-1 and use backtracking to find a valid sequence where adjacent numbers differ by exactly one bit.

Iterative Bit Manipulation

⏱️ Time: O(2^n) Space: O(2^n)

Generate Gray code sequence iteratively by doubling the sequence at each step and setting the MSB for the second half, avoiding recursion overhead.

Mathematical Pattern (Recursive)

⏱️ Time: O(2^n) Space: O(2^n)

Gray codes have a recursive structure: G(n) = [0 + G(n-1), 2^(n-1) + reverse(G(n-1))]. This means we can build n-bit codes from (n-1)-bit codes.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

892 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