Vamos definir uma linguagem simples que opere em um único valor de 8 bits. Ele define três operações bit a bit (a explicação do código assume uma valuevariável de 8 bits ):

• !Negue o bit menos significativo ( value ^= 1)
• <Empacotando o deslocamento para a esquerda ( value = value << 1 | value >> 7)
• >quebra automática à direita ( value = value >> 1 | value << 7)

Entrada:

Dois números de 8 bits, a e b . Como são de 8 bits, você pode levá-los como caracteres.

Resultado:

A maneira mais curta de ir de a para b, com as três operações definidas acima. Você pode retornar uma string ou uma matriz de caracteres, ou definir valores constantes e distintos para cada operação e retornar uma matriz desses (sim, você também pode dizer <meios >e >meios <), mas por favor, explique seu formato de saída na sua resposta.

Se houver várias maneiras igualmente longas, você poderá gerar uma ou todas elas.

Regras:

• Você pode enviar um programa ou função
• Aplicam-se brechas padrão
• A submissão com menos bytes em cada idioma vence (nenhuma resposta será aceita)

Soluções sem força bruta (ou pelo menos não apenas força bruta) podem receber meu voto positivo.

Casos de teste:

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 '>>>>!>!'

Aqui está um programa para gerar mais alguns.

JavaScript (ES6), 100 96 86 bytes

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>

Pesquisa um pouco lenta pela primeira vez, sem verificar duas vezes. Versão um pouco mais eficiente de 114 bytes:

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>

Ambas as versões codificam <!>, 012mas os trechos decodificam isso para você. Edit: salvou 10 bytes totalmente inúteis graças a @RickHitchcock.

Gelatina , 32 bytes

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

Experimente online!

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

Nota: Essa é uma função, é por isso que o rodapé está lá.

Força bruta. :(

Python 2 , 111 bytes

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),'<>!')]

Experimente online!

JavaScript (ES6), 105 bytes

Leva os 2 bytes na sintaxe de currying (a)(b).

Retorna uma string com:

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

ou uma matriz vazia se a for igual 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)

Experimente online! (com códigos traduzidos de volta para !<>)

C (GCC) , 201 199 198 196 193 bytes

• Economizou dois bytes graças ao ceilingcat ; golfe a/2+a*128para (a+2*a*128)/2a a*257/2.
• Salva um byte; golfe a*2+a/128para (a*2*128+a)/128a (257*a)/128para 257*a>>7.
• Salvei dois cinco bytes graças ao ceilingcat , jogando o tipo de retorno.

C (gcc) , 193 bytes

*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);}}

Experimente online!