Circular Permutation in Binary Representation

Circular Permutation in Binary Representation - Problem

Given two integers n and start, your task is to return any permutation p of (0, 1, 2, ..., 2^n - 1) such that:

p[0] = start
p[i] and p[i+1] differ by only one bit in their binary representation
p[0] and p[2^n - 1] must also differ by only one bit in their binary representation

This creates a circular Gray code sequence starting from the given number.

Input & Output

Example 1 — Small Case

$ Input: n = 2, start = 3

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

💡 Note: For n=2, we need permutation of [0,1,2,3]. Starting with 3 (binary 11), we can go to 2 (10), then 0 (00), then 1 (01), and back to 3 (11). Each adjacent pair differs by exactly one bit.

Example 2 — Start from Zero

$ Input: n = 3, start = 0

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

💡 Note: Standard Gray code sequence for n=3 starting from 0. Binary sequence: 000→001→011→010→110→111→101→100, each differing by one bit.

Example 3 — Minimum Case

$ Input: n = 1, start = 1

› Output: [1,0]

💡 Note: For n=1, only two numbers [0,1]. Starting with 1 (binary 1), go to 0 (binary 0). They differ by one bit and 0→1 also differs by one bit, completing the circle.

Constraints

1 ≤ n ≤ 16
0 ≤ start < 2ⁿ

Visualization

Tap to expand

Understanding the Visualization

Input

Given n=2, start=3, need permutation of [0,1,2,3]

Process

Each adjacent pair must differ by exactly one bit

Output

Valid circular sequence starting and ending near start

Key Takeaway

🎯 Key Insight: Gray code ensures each step changes exactly one bit, and XOR with start rotates the sequence to begin from any position

Asked in

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

The key insight is that any circular Gray code can be generated by XORing a standard Gray code with the starting position. The mathematical approach generates standard Gray code [0,1,3,2,...] then XORs each element with 'start' to create a rotated sequence. Time: O(2^n), Space: O(2^n)

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking with Pruning	O(2^n)	O(2^n)	Build sequence step by step, backtrack when hitting dead ends
Brute Force - Generate All Permutations	O((2^n)!)	O(2^n)	Generate all permutations and check which one satisfies the Gray code property
Mathematical Gray Code Generation	O(2^n)	O(2^n)	Generate standard Gray code, then use XOR to rotate to start position

Backtracking with Pruning — Algorithm Steps

Start with 'start' number
For each step, try all unused numbers that differ by 1 bit
If we reach a dead end, backtrack and try different path
Check final circular property when sequence is complete

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with start value, mark as used

Explore

Try each valid next number (differs by 1 bit)

Backtrack

If dead end reached, undo and try different path

Code -

solution.c — C

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

int popCount(int x) {
    int count = 0;
    while (x) {
        x &= x - 1;
        count++;
    }
    return count;
}

bool differsByOneBit(int a, int b) {
    return popCount(a ^ b) == 1;
}

bool backtrack(int current, int* path, bool* used, int pathLen, int total, int start) {
    if (pathLen == total) {
        return differsByOneBit(current, start);
    }
    
    for (int nextNum = 0; nextNum < total; nextNum++) {
        if (!used[nextNum] && differsByOneBit(current, nextNum)) {
            used[nextNum] = true;
            path[pathLen] = nextNum;
            
            if (backtrack(nextNum, path, used, pathLen + 1, total, start)) {
                return true;
            }
            
            used[nextNum] = false;
        }
    }
    
    return false;
}

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

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, explores all possible paths but with pruning

⚠ Quadratic Growth

Space Complexity

O(2^n)

Recursion stack depth plus visited array

⚠ Quadratic Space

18.5K Views

Medium Frequency

~25 min Avg. Time

324 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

Constraints

Visualization

Related Problems

Common Approaches

Backtracking with Pruning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler