Circular Permutation in Binary Representation

Circular Permutation in Binary Representation - Problem

Imagine you have a circular sequence of numbers where each adjacent pair differs by exactly one bit in their binary representation - this is called a Gray Code sequence. Your task is to construct such a sequence starting from a specific number!

Given two integers n and start, return any permutation of all numbers from 0 to 2ⁿ - 1 such that:

The first element equals start
Each consecutive pair of numbers differs by exactly one bit in binary
The sequence is circular - the last element also differs from the first by exactly one bit

Example: For n = 3, start = 2, one valid sequence is [2, 6, 7, 5, 4, 0, 1, 3]
Binary: [010, 110, 111, 101, 100, 000, 001, 011] - notice each pair differs by one bit!

Input & Output

example_1.py — Basic Case

$ Input: n = 2, start = 3

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

💡 Note: Binary sequence: [11, 10, 00, 01]. Each adjacent pair differs by 1 bit, and 01 ^ 11 has only 1 bit difference (circular property).

example_2.py — Larger Input

$ Input: n = 3, start = 2

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

💡 Note: Binary: [010, 110, 111, 101, 100, 000, 001, 011]. Starts with 2, each step flips exactly one bit, and 011 ^ 010 = 1 bit difference.

example_3.py — Edge Case

$ Input: n = 1, start = 0

› Output: [0, 1]

💡 Note: Smallest case: binary [0, 1]. Only one bit to flip, satisfies all conditions trivially.

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start at the given combination and mark it as the first position

Generate Pattern

Use Gray code's reflection property to systematically visit all combinations

Transform

Apply XOR transformation to rotate the entire sequence to start from desired position

Verify

Ensure the last combination differs from first by exactly one switch flip

Key Takeaway

🎯 Key Insight: Gray codes have a beautiful recursive structure that guarantees the circular property, making XOR transformation the elegant optimal solution!

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate exactly 2^n elements once and apply constant time transformations

⚠ Quadratic Growth

Space Complexity

O(2^n)

Storage for the result array containing all 2^n permutation elements

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 17
0 ≤ start < 2ⁿ
Note: The answer sequence length is exactly 2ⁿ

Asked in

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

The optimal solution uses Gray Code generation with XOR transformation. Generate the standard Gray code sequence recursively, then XOR all elements with the start value to create a circular permutation beginning at the desired position. This achieves O(2ⁿ) time complexity with elegant mathematical properties.

Common Approaches

Approach	Time	Space	Notes
✓ Gray Code with XOR Transformation (Optimal)	O(2^n)	O(2^n)	Generate standard Gray code and transform to start from desired position
Backtracking Search	O(2^n × n)	O(2^n)	Try all possible paths using recursive backtracking

Gray Code with XOR Transformation (Optimal) — Algorithm Steps

Generate the standard n-bit Gray code sequence starting from 0
Find the position of start^grayCode[0] in the Gray code sequence
Rotate the sequence so that the desired start appears first
Apply XOR transformation to align with the actual start value
Return the transformed circular permutation

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Case

Start with [0] for 0 bits

Reflect & Extend

Mirror sequence and add new bit prefix

Repeat

Continue for all n bits

Transform

XOR with start to shift sequence

Code -

solution.c — C

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

int* circularPermutation(int n, int start, int* returnSize) {
    int total = 1 << n;
    int* result = (int*)malloc(total * sizeof(int));
    *returnSize = total;
    
    // Generate standard Gray code
    result[0] = 0;
    int size = 1;
    
    for (int i = 0; i < n; i++) {
        // Add reflected sequence with new bit
        for (int j = size - 1; j >= 0; j--) {
            result[size + (size - 1 - j)] = result[j] | (1 << i);
        }
        size <<= 1;
    }
    
    // XOR all elements with start to shift the sequence
    for (int i = 0; i < total; i++) {
        result[i] ^= start;
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate exactly 2^n elements once and apply constant time transformations

⚠ Quadratic Growth

Space Complexity

O(2^n)

Storage for the result array containing all 2^n permutation elements

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 17
0 ≤ start < 2ⁿ
Note: The answer sequence length is exactly 2ⁿ

31.4K Views

Medium Frequency

~25 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Gray Code with XOR Transformation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler