Definiamo un linguaggio semplice che opera su un singolo valore a 8 bit. Definisce tre operazioni bit a bit (la spiegazione del codice presuppone una valuevariabile a 8 bit ):

• !Annulla il bit meno significativo ( value ^= 1)
• <Spostamento con spostamento a sinistra ( value = value << 1 | value >> 7)
• >spostamento a destra ( value = value >> 1 | value << 7)

Ingresso:

Due numeri a 8 bit, a e b . Dato che sono a 8 bit, puoi alternativamente prenderli come personaggi.

Produzione:

Il modo più breve per andare da a a b, con le tre operazioni sopra definite. È possibile restituire una stringa o una matrice di caratteri o definire valori costanti e distinti per ciascuna operazione e restituire una matrice di quelli (sì, si potrebbe anche dire <mezzi >e >mezzi <), ma si prega di spiegare il formato di output nella risposta.

Se ci sono più modi, ugualmente lunghi, è possibile emetterne uno o tutti.

Regole:

• È possibile inviare un programma o una funzione
• Si applicano scappatoie standard
• Vince l'invio con il minor numero di byte in ciascuna lingua (nessuna risposta verrà accettata)

Le soluzioni senza la forza bruta (o almeno non solo la forza bruta) potrebbero ottenere il mio voto.

Casi test:

12, 13 => '!'
1, 2 => '<'
254, 253 => '<'
5, 5 => ''
98, 226 -> '<!>'
64, 154 -> '!>!>>>!>'
177, 164 -> '!>>!>>>!'
109, 11 -> '>>!>!>>'
126, 92 -> '!>!>!>!<' or '!>!>>!<!'
26, 85 -> '<!<<!<!<' or '<!<<!<!>' or '<!<<<!>!'
123, 241 -> '!>!<<!' or '>!<!<!'
236, 50 -> '<<!<!>' or '<<<!>!'
59, 246 -> '<<!>'
132, 95 -> '!<<!<!<!'
74, 53 -> '!>>>!>!'
171, 127 -> '<<!<<!<'
109, 141 -> '!>>>'
185, 92 -> '!>'
166, 201 -> '!<!>>>' or '<!>!>>'
77, 155 -> '<!'
124, 181 -> '!<<<<!>>' or '!>>>>!>>'
108, 85 -> '!<<<!<!<!<' or '!<<<!<!<!>' or '!<<<!<<!>!' or '!>>>!>!>!<' or '!>>>!>!>!>' or '!>>>!>>!<!'
185, 144 -> '<!<<!<!'
70, 179 -> '<<<!<!>' or '<<<<!>!' or '>>>>!>!'

Ecco un programma per generarne altri.

JavaScript (ES6), 100 96 86 byte

f=(a,b,[c,d,...e]=[a,''])=>c-b?f(a,b,[...e,c^1,d+1,c/2|c%2<<7,d+2,c%128*2|c>>7,d+0]):d

<div oninput=o.textContent=f(a.value,b.value).replace(/./g,c=&gt;`&lt;!&gt;`[c])>a: <input type=number min=0 max=255 value=0 id=a> b: <input type=number min=0 max=255 value=0 id=b><pre id=o>

Ricerca un po 'lenta al primo tentativo senza doppio controllo. Versione a 114 byte leggermente più efficiente:

f=(a,b,c=[],[d,e,...g]=[a,''])=>c[d]?f(a,b,c,g):d-b?f(a,b,c,[...g,d^1,c[d]=e+1,d/2|d%2<<7,e+2,d%128*2|d>>7,e+0]):e

<div oninput=o.textContent=f(a.value,b.value).replace(/./g,c=&gt;`&lt;!&gt;`[c])>a: <input type=number min=0 max=255 value=0 id=a> b: <input type=number min=0 max=255 value=0 id=b><pre id=o>

Entrambe le versioni codificano <!>come 012ma i frammenti lo decodificano per te. Modifica: salvato 10 byte completamente inutili grazie a @RickHitchcock.

Gelatina , 32 byte

ṃ“ṙ1“ṙ-“¬8¦”
+⁹BḊ€0ÇẎv¥⁼ƭƒ@¥1#ḢÇ

Provalo online!

< : ['ṙ', '1']
> : ['ṙ', '-']
! :['¬', '8', '¦']

Nota: questa è una funzione, ecco perché c'è il piè di pagina.

Forza bruta. :(

Python 2 , 111 byte

l=[input()+('',)]
for(a,b,i)in l:a==b>exit(i);l+=[(x,b,i+y)for x,y in zip((a*2%256|a>>7,a/2|a%2<<7,a^1),'<>!')]

Provalo online!

JavaScript (ES6), 105 byte

Accetta i 2 byte nella sintassi del curry (a)(b) .

Restituisce una stringa con:

• 0 = !
• 1 = >
• 2 = <

o un array vuoto se a è uguale a b .

a=>g=(b,m=1)=>(h=(n,s=[])=>n^b?s[m]?0:h(n^1,s+0)+h(n/2|n%2<<7,s+1)+h(n%128*2|n>>7,s+2):r=s)(a)?r:g(b,m+1)

Provalo online! (con i codici tradotti di nuovo in !<>)

C (gcc) , 201 199 198 196 193 byte

• Salvato due byte grazie a ceilingcat ; golf a/2+a*128a (a+2*a*128)/2a a*257/2.
• Salvato un byte; golf a*2+a/128a (a*2*128+a)/128per (257*a)/128a257*a>>7 .
• Risparmiato due cinque byte grazie a ceilingcat , giocando a golf il tipo di ritorno.

C (gcc) , 193 byte

*P,D,Q,j;f(a,b,d){if(a&=255,Q&&a==b)for(Q=j=0;++j<D;printf("%d",j[P]));Q&&++d<D&&f(a^1,b,d,P[d]=1)&f(257*a>>7,b,d,P[d]=2)&f(a*257/2,b,d,P[d]=3);}F(a,b){for(D=Q=1;Q;D++){int p[D];f(a,b,0,P=p);}}

Provalo online!