Definamos un lenguaje simple que opera en un solo valor de 8 bits. Define tres operaciones bit a bit (la explicación del código supone una valuevariable de 8 bits ):

• !Negar el bit menos significativo ( value ^= 1)
• <Ajuste de desplazamiento a la izquierda ( value = value << 1 | value >> 7)
• >ajuste de desplazamiento a la derecha ( value = value >> 1 | value << 7)

Entrada:

Dos números de 8 bits, a y b . Como son de 8 bits, también puedes tomarlos como personajes.

Salida:

La forma más corta de ir de a a b, con las tres operaciones definidas anteriormente. Puede devolver una cadena o una matriz de caracteres, o definir valores constantes y distintos para cada operación y devolver una matriz de esos (sí, también podría decir <medias >y >medias <), pero explique su formato de salida en su respuesta.

Si hay varias formas, igualmente largas, puede generar una o todas ellas.

Reglas:

• Puedes enviar un programa o función
• Se aplican lagunas estándar
• El envío con la menor cantidad de bytes en cada idioma gana (no se aceptará ninguna respuesta)

Las soluciones sin fuerza bruta (o al menos no solo fuerza bruta) podrían obtener mi voto positivo.

Casos de prueba:

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

Aquí hay un programa para generar algunos más.

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>

Algo lento de amplitud de búsqueda sin doble verificación. Versión de 114 bytes ligeramente más eficiente:

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 versiones codifican <!>como 012pero los fragmentos lo decodifican por usted. Editar: guardado 10 bytes completamente inútiles gracias a @RickHitchcock.

Jalea , 32 bytes

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

Pruébalo en línea!

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

Nota: Esta es una función, es por eso que el pie de página está ahí.

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

Pruébalo en línea!

JavaScript (ES6), 105 bytes

Toma los 2 bytes en la sintaxis de curry (a)(b).

Devuelve una cadena con:

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

o una matriz vacía si a es 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)

Pruébalo en línea! (con códigos traducidos de nuevo a !<>)

C (gcc) , 201 199 198 196 193 bytes

• Guardado dos bytes gracias a ceilingcat ; jugando a/2+a*128al golf (a+2*a*128)/2a a*257/2.
• Guardado un byte; golf a*2+a/128a (a*2*128+a)/128a (257*a)/128a257*a>>7 .
• Guardado dos cinco bytes gracias a ceilingcat , jugar al golf el 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);}}

Pruébalo en línea!