Return to Question

for n = 2

            00
           /  \
          01  10
           \  /
            11

   n = 2                   n = 3

                             000
    00                      / | \
   /  \                    /  |  \
  01  10                100  010  001
   \  /                  | \/   \/ |
    11                   | /\   /\ |
                        110  101  011
                           \  |  /
                            \ | /
                             111

edit:

I think it can be viewed as a graph:

for n = 2

            00
           /  \
          01  10
           \  /
            11

The sequence is required to traverse each edge in both directions, but in neither direction more than once.

I have written a bit of code to brute force generate these codes. However, it starts to struggle at n = 5 (I'm assuming this is because of the complexity, but it may well be because there is a bug).

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

struct mjc_ll {
  const unsigned long int val;
  const struct mjc_ll* next;
};

// prints integer val in binary

void mjc_print_bin(const unsigned long int val, const unsigned char sf)
{
  if (sf != 0) {
    unsigned long int s = (1 << (sf - 1));
    while (s != 0) {
      printf("%c", ((val & s) != 0) ? '1' : '0');
      s >>= 1;
    }
  }
  printf("\n");
}

unsigned long int mjc_power(const unsigned long int base,
                const unsigned long int exponent)
{
  return (exponent == 0) ? 1 : (base * mjc_power(base, exponent - 1));
}

// returns 1 if transition found in ll, 0 otherwise

int mjc_search_ll(const struct mjc_ll* const ll, const unsigned long int val,
          const unsigned long int prev)
{
  if (ll->next == 0) {
    // reached end of list
    return 0;
  } else if ((val == ll->val) && (prev == ll->next->val)) {
    // change found
    return 1;
  }
  return mjc_search_ll(ll->next, val, prev);
}

// prints the solution and returns 1 if a solution found, otherwise returns 0

int mjc_next(const struct mjc_ll* const ll, const unsigned long int val,
         const unsigned char bit_len, const unsigned long int count,
         const unsigned long int limit)
{
  if (count == limit) {
    // reached the end
    mjc_print_bin(0, bit_len);
    return 1;
  } else if ((ll != 0) && (mjc_search_ll(ll, val, ll->val) != 0)) {
    // found duplicate
    return 0;
  }
  const struct mjc_ll new = {val, ll};
  unsigned char i = 0;
  while(i < bit_len) {
    if (mjc_next(&new, val ^ (1 << i), bit_len, count + 1, limit) == 1) {
      mjc_print_bin(val, bit_len);
      return 1;
    }
    ++i;
  }
  return 0;
}

void mjc(const unsigned char bit_len)
{
  (void)mjc_next(0, 0, bit_len, 0, mjc_power(2, bit_len) * bit_len);
}

int main(int argc, char* argv[])
{
  if (argc != 2) {
    printf("mjc takes 1 arg, the bit width of the pattern\n");
  } else {
    mjc(strtol(argv[1], 0, 0));
  }
  return 0;
}

I have written a bit of code to brute force generate these codes. However, it starts to struggle at n = 5 (actual code in a prev. revision of this question).

FUNCTION gen
  IF height of stack == ((2^bit_width) * bit_width)
    PRINT ZERO_PATTERN
    RETURN TRUE
  IF the change between the value at the top of stack and value does occur between other values on the stack
    RETURN FALSE

  PUSH value to stack
  WHILE shift < bit_width
    IF RECURSE with value as (value XOR (1 << shift)) returns TRUE
      PRINT value
      RETURN TRUE
    shift = shift + 1
  RETURN FALSE


SET stack to an empty list
SET bit_width to n

CALL gen with value as 0