Introduction (may be ignored)

Putting all positive numbers in its regular order (1, 2, 3, ...) is a bit boring, isn't it? So here is a series of challenges around permutations (reshuffelings) of all positive numbers. This is the second challenge in this series. The first challenge can be found here.

In this challenge, we use Gray codes to rearrage the natural numbers. A Gray code, or "reflected binary code" is a binary encoding in such a way that two successive values differ in only one bit. A practical application of this encoding is to use it in rotary encoders, hence my reference to "Turn My Way".

Note that this encoding leaves some degree of freedom. For example, following binary 1100, there are four possible following codes: 1101, 1110, 1000 and 0100. This is why I will define $a(n)$ as the smallest, not previously used value that differs only one character in binary encoding. This sequence corresponds with A163252.

Since this is a "pure sequence" challenge, the task is to output $a(n)$ for a given $n$ as input, where $a(n)$ is A163252.

Task

Given an integer input $n$, output $a(n)$ in integer format (not in binary format).

$a(n)$ is defined as the least positive integer not occurring earlier in the sequence such that $a(n-1)$ and $a(n)$ differ in only one bit when written in binary.

Note: 1-based indexing is assumed here; you may use 0-based indexing, so $a(0) = 1; a(1) = 3$, etc. Please mention this in your answer if you choose to use this.

Test cases

Input | Output

--------------

1     | 1

5     | 4

20    | 18

50    | 48

123   | 121

1234  | 1333

3000  | 3030

9999  | 9997

Rules

• Input and output are integers (your program should at least support input and output in the range of 1 up to 32767)


• Invalid input (0, floats, strings, negative values, etc.) may lead to unpredicted output, errors or (un)defined behaviour. In A163252, $a(0)$ is defined as 0. For this challenge, we will ignore this.


• Default I/O rules apply.


• 
  Default loopholes are forbidden.


• This is code-golf, so the shortest answers in bytes wins

Final note

See the following related (but not equal) PP&CG questions:

• Finding the next Gray code (input and output in binary)


• Generate the all Gray codes of length n

JavaScript (ES6), 65 bytes

1-indexed.

n=>{for(o=p=[k=1];o[k]|~-(i=p^k)&i?k++:k=o[p=k]=!!n--;);return p}

Try it online!

Commented

n => {                  // n = index of requested term

  for(                  // for loop:

    o =                 //   o = storage object for the terms of the sequence

    p =                 //   p = last term found in the sequence

      [k = 1];          //   k = current term

    o[k] |              //   if k was already encountered

    ~-(i = p ^ k) & i ? //   or (p XOR k) has more than 1 bit set:

      k++               //     increment k

    :                   //   else:

      k = o[p = k]      //     set o[k], set p to k

        = !!n--;        //     stop if n is equal to 0 or set k to 1; decrement n

  );                    // end of for()

  return p              // return p

}                       // end

Jelly, 26 20 bytes

ṀBLŻ2*^1ị$ḟ⁸Ṃ;

0Ç⁸¡Ḣ

Try it online!

A full program that takes n as the single argument. Works for all test cases. Also note that, although not required, it handles n=0.

Explanation

Helper link: find next term and prepend

Ṁ              | maximum of list so far

 B             | convert to binary

  L            | number of binary digits

   Ż           | 0..above number

    2*         | 2 to the power of each of the above

      ^        | exclusive or with...

       1ị$     | ... the most recent term in the list so far

          ḟ⁸   | filter out anything used already

            Ṃ  | find the minimum

             ; | prepend to existing list

Main link

0              | start with zero

 Ç             | call the above link

  ⁸¡           | and repeat n times

    Ḣ          | take the last term added

Wolfram Language (Mathematica), 74 bytes

Last@Nest[#~Join~{Min[BitXor[Last@#,2^Range[0,20]]~Complement~#]}&,{0},#]&

Try it online!

Python 3.8 (pre-release), 85 bytes

1-based indexing, really inefficient

a=lambda n,x=0:((w:=x^(n and a(n-1)))&w-1or x in[a(i)for i in range(n)])and-~a(n,x+1)

Try it online!

APL (Dyalog Extended), 46 bytes

{⍵⌷2∘{(~⍺∊⍵)∧1=≢⍸≠⌿↑⌽∘⊤¨⍺,⊃⌽⍵:⍵,⍺⋄⍵∇⍨⍺+1}⍣⍵⊢1}

Try it online!

Stax, 19 bytes

±↔Φd┌û╓°╡ñ|Q5┌¿Éúb≈

Run and debug it

It's very slow, but not nearly as slow as the 17 byte solution I was working on. I think there's still some golfing potential. I will add an explanation after I get rid of the bloat.

Charcoal, 65 bytes

≔⁰θＦＮ«⊞υθ≔¹ηＷ¬‹θ⊗η≦⊗ηＷ∧›η¹∨¬＆θη№υ⁻θη≧÷²ηＷ№υ⁻｜θη＆θη≦⊗η≔⁻｜θη＆θηθ»Ｉθ

Try it online! Link is to verbose version of code. Explanation:

≔⁰θ

Initialise the result to 0.

ＦＮ«

Loop n times.

⊞υθ

Save the previous result so that we don't use it again.

≔¹ηＷ¬‹θ⊗η≦⊗η

Find the highest bit in the previous result.

Ｗ∧›η¹∨¬＆θη№υ⁻θη≧÷²η

While that bit is greater than 1, if the bit is set in the previous result, try subtracting that bit to see if the result is an unseen result. This ensures that the potential results are tried in ascending order of value.

Ｗ№υ⁻｜θη＆θη≦⊗η

Now try XORing that bit with the previous result, doubling the bit until an unseen result is found. This handles the cases when a bit needs to be set, again in ascending order of value, but also the case when the least significant bit needs to be toggled, which the previous loop doesn't bother to test (because it's golfier to test for that here). If the previous loop found an unseen result then this loop never runs; if it didn't then this loop will uselessly retest those results.

≔⁻｜θη＆θηθ

Update the result by actually XORing the bit with it.

»Ｉθ

Output the final result at the end of the loop.