Introduzione (potrebbe essere ignorata)

Mettere tutti i numeri positivi nel suo ordine regolare (1, 2, 3, ...) è un po 'noioso, no? Quindi ecco una serie di sfide intorno alle permutazioni (rimpasto) di tutti i numeri positivi. Questa è la seconda sfida di questa serie. La prima sfida può essere trovata qui .

In questa sfida, utilizziamo i codici Gray per riordinare i numeri naturali. Un codice Gray, o "codice binario riflesso" è una codifica binaria in modo tale che due valori successivi differiscano in un solo bit. Un'applicazione pratica di questa codifica è usarla negli encoder rotativi , da cui il mio riferimento a "Turn My Way" .

Nota che questa codifica lascia un certo grado di libertà. Ad esempio, seguendo il binario 1100, ci sono quattro possibili codici seguenti: 1101, 1110, 1000 e 0100. Per questo definirò come valore più piccolo, non utilizzato in precedenza, che differisce solo un carattere nella codifica binaria. Questa sequenza corrisponde a A163252 .$a(n)$

Poiché si tratta di una sfida "sequenza pura", il compito è quello di produrre per un dato n come input, dove a (n) è A163252 .$a(n)$$n$$a(n)$

Compito

Dato un input intero $n$ , output $a(n)$ in formato intero ( non in formato binario).

$a(n)$ è definito come il numero intero meno positivo che non si verifica in precedenza nella sequenza in modo tale che e differiscano in un solo bit quando scritto in binario.$a(n-1)$$a(n)$

Nota: qui si assume l'indicizzazione basata su 1; puoi utilizzare l'indicizzazione basata su 0, quindi , ecc. Indicare questo nella risposta se si sceglie di utilizzarlo.$a(0) = 1; a(1) = 3$

Casi test

Input | Output
--------------
1     | 1
5     | 4
20    | 18
50    | 48
123   | 121
1234  | 1333
3000  | 3030
9999  | 9997

Regole

• Input e output sono numeri interi (il tuo programma dovrebbe almeno supportare input e output nell'intervallo da 1 a 32767)
• Input non validi (0, float, stringhe, valori negativi, ecc.) Possono causare output non previsti, errori o comportamenti (non) definiti. In A163252 , è definito come 0. Per questa sfida, lo ignoreremo.$a(0)$
• Si applicano le regole I / O predefinite .
• Sono vietate le scappatoie predefinite .
• Questo è code-golf , quindi vince la risposta più breve in byte

Nota finale

Vedi le seguenti domande relative (ma non uguali) ai PP&CG:

• Trovare il prossimo codice Gray (input e output in binario)
• Genera tutti i codici Gray di lunghezza n

Stax , 19 17 byte

êÑ{╚α8è╙mc┼σ▀»É▲ü

Esegui ed esegui il debug

Smette di funzionare a un certo punto dopo il dominio specificato a causa dell'iterazione dell'indice di bit codificato. (32767)

Disimballato, non golfato e commentato, sembra così.

z0,         push an empty array, literal zero, and the input, in that order
             - the zero represents the last calculated value in the sequence
             - the array contains all the previous ones
D           repeat the rest of the program n times (from input)
  +         append the last calculated value to the array
  17r       [0 .. 16] (these are the bit indices necessary to cover the input range)
  {|2nH|^m  calculate candidate values; previous value with each of these bits toggled 
  n-        remove all values previously calculated
  |m        keep the minimum candidate remaining

Esegui questo

JavaScript (ES6), 65 byte

1-indicizzati.

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

Provalo online!

Commentate

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

Gelatina , 26 20 byte

ṀBLŻ2*^1ị$ḟ⁸Ṃ;
0Ç⁸¡Ḣ

Provalo online!

Un programma completo che accetta n come unico argomento. Funziona con tutti i casi di test. Si noti inoltre che, sebbene non richiesto, gestisce n = 0.

Spiegazione

Link di aiuto: trova il prossimo termine e anteponi

Ṁ              | 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

Collegamento principale

0              | start with zero
 Ç             | call the above link
  ⁸¡           | and repeat n times
    Ḣ          | take the last term added

Java (JDK) , 142 138 124 123 132 130 98 byte

• aumentato per tenere conto dell'importazione, salvato un byte grazie a @ kevin-cruijssen
• passato la raccolta in int array grazie a @ olivier-grégoire

n->{int s[]=new int[9*n],j,k=0;for(;n-->0;s[k=j]++)for(j=0;s[++j]>0|n.bitCount(j^k)>1;);return k;}

Provalo online!

Python 2 , 81 byte

Indicizzazione basata su 1

l=[0];p=0
exec"n=0\nwhile(p^n)&(p^n)-1or n in l:n+=1\np=n;l+=p,;"*input()
print p

Provalo online!

Python 2 , 79 byte

Questo richiede molto tempo (9999 non è stato completato dopo l'esecuzione in locale per 7 minuti)

l={0};p=0;n=input()
exec'p=min({p^2**k for k in range(n)}-l);l|={p};'*n
print p

Provalo online!

Wolfram Language (Mathematica) , 74 byte

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

Provalo online!

APL (Dyalog Extended) , 46 byte

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

Provalo online!

Carbone , 65 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

≔⁰θ

Inizializza il risultato su 0.

ＦＮ«

nTempi di ciclo .

⊞υθ

Salvare il risultato precedente in modo che non lo riutilizziamo.

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

Trova il bit più alto nel risultato precedente.

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

Mentre quel bit è maggiore di 1, se il bit è impostato nel risultato precedente, prova a sottrarre quel bit per vedere se il risultato è un risultato non visto. Ciò garantisce che i risultati potenziali vengano provati in ordine crescente di valore.

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

Ora prova XORing quel bit con il risultato precedente, raddoppiando il bit fino a quando non viene trovato un risultato invisibile. Questo gestisce i casi in cui è necessario impostare un bit, sempre in ordine crescente di valore, ma anche il caso in cui il bit meno significativo deve essere attivato, che il loop precedente non si preoccupa di testare (perché è più golfista da testare per quello qui). Se il ciclo precedente ha trovato un risultato invisibile, questo ciclo non funziona mai; in caso contrario, questo ciclo ripeterà inutilmente quei risultati.

≔⁻｜θη＆θηθ

Aggiorna il risultato effettivamente XORing il bit con esso.

»Ｉθ

Emette il risultato finale alla fine del loop.

05AB1E , 21 20 18 byte

ÎFˆ∞.Δ¯θy^bSO¯yå_*

Abbastanza inefficiente, quindi maggiore è l'input, maggiore è il tempo necessario per ottenere il risultato. Funziona anche per l'input 0, però.

$n$

Spiegazione:

Î                # Push 0 and the input
 F               # Loop the input amount of times:
  ˆ              #  Pop the current number and add it to the global_array
  ∞.Δ            #  Inner loop starting at 1 to find the first number which is truthy for:
     ¯θy^        #   XOR the last number of the global_array with the loop-number `y`
         b       #   Convert it to binary
          SO     #   Sum it's binary digits
     ¯yå_        #   Check if the loop-number `y` is NOT in the global_array yet
            *    #   Multiply both (only if this is 1 (truthy), the inner loop will stop)
                 # (after the loops, output the top of the stack implicitly)

Haskell , 101 byte

import Data.Bits
(u!n)0=n
(u!n)m|q<-minimum[x|r<-[0..62],x<-[xor(2^r)n],notElem x u]=(n:u)!q$m-1
[]!0

Provalo online!

Sembra un peccato incorrere in un'importazione solo per xor, ma non ho ancora trovato una buona soluzione. Mi chiedo anche se esiste un modo migliore per esprimere il ciclo.

R , 90 byte

function(n){A=1
while(sum(A|1)<n)A=c(min((x=bitwXor(A[1],2^(0:30)))[x>0&!x%in%A]),A)
A[1]}

Provalo online!