Una forma es quiral si ninguna cantidad de rotación puede hacer que parezca una imagen especular. En este rompecabezas escribiremos programas informáticos quirales.

Para este rompecabezas pensaremos en un programa como una matriz rectangular de caracteres. Como tal, todas las soluciones a este desafío deben ser rectangulares (es decir, todas las líneas deben tener la misma longitud). Podemos rotar estos programas en incrementos de cuarto de vuelta. Por ejemplo el programa

The quickish fish
    lept deftly  
  rightwards     

Cuando se gira un cuarto de vuelta en el sentido de las agujas del reloj parece

  T
  h
r e
i  
glq
heu
tpi
wtc
a k
rdi
des
sfh
 t 
 lf
 yi
  s
  h

También podemos reflejar estos programas. Aquí está el mismo programa reflejado sobre un eje vertical:

hsif hsikciuq ehT
  yltfed tpel    
    sdrawthgir   

Un programa quiral es un programa que cuando se rota cualquier número de veces siempre generará " left". Sin embargo, cuando se refleja produce un programa que emite " right" sin importar cuántas veces se gire.

Su tarea es escribir un programa quiral en la menor cantidad de bytes posible.

Reglas Adicionales

• La salida no distingue entre mayúsculas y minúsculas, pero debe ser coherente. (p. ej., puede mostrar " LEFT" y " rIgHt" pero esta carcasa debe ser coherente bajo rotaciones)

• Las líneas deben dividirse en una nueva línea o una nueva línea y un salto de línea.

• Su programa debe ser un rectángulo, puede rellenarlo con espacios o comentarios, pero cada línea debe tener la misma longitud.

• Si lo desea, puede tener una nueva línea final (o nueva línea y salto de línea) en todos sus programas.

Pascal (FPC) , 2161 755 349 bytes

///////bw(,,),(wb///////
///////er'''e''re///////
begin//girgtnflig//nigeb
write//itih'dteti//etirw
('le'//ne'' .''en//'ir'(
,'ft'//////////////'hg',
)end.////////////// 't',
,'t' //////////////.dne)
,'gh'//////////////'tf',
('ri'//ne''. ''en//'el'(
write//itetd'hiti//etirw
begin//gilfntgrig//nigeb
///////er''e'''re///////
///////bw(,),,(wb///////

Intenta a la izquierda

Intenta bien

@tsh me motivó a intentarlo nuevamente cuando vi su programa (en un comentario) y aquí está.

El anterior con 755 bytes:

 begin write('left')end.// 
/e .dne)'thgir'(etirw nigeb
/g                        e
.i                       .g
dn                       di
n                        nn
ew                       e 
)r                       )w
'i                       'r
tt                       ti
fe                       ht
e(                       ge
l'                       i(
'r                       r'
(i                       'l
eg                       (e
th                       ef
it                       tt
r'                       i'
w)                       r)
 e                       we
nn                        n
id                       nd
g.                       i.
e                        g/
begin write('right')end. e/
 //.dne)'tfel'(etirw nigeb 

Intenta a la izquierda

Intenta bien

Si viste mi envío anterior, solo olvídalo :)

Todas las rotaciones para los programas izquierdo y derecho son iguales.

Klein (000) , 109 87 bytes

."left"@\.
\"right"..
@"thgir">.
..@"tfel"\
\"left"@..
.>"right"@
.."thgir"\
.\@"tfel".

Pruébalo en línea!

Debería ser posible obtener una versión más corta de esta respuesta, ¡así que buena suerte!

Esta respuesta está inspirada en espirales. En particular, la idea es dos espirales entrelazadas, una para la izquierda y otra para la derecha. Tiene una simetría doble, por lo que podemos verificar los siguientes programas para saber si funciona:

Cuarto de vuelta

...\.@\.
\.>"."""
@""l@trl
"tre"hie
thiftggf
fggtfiht
eih"ert"
lrt@l""@
""".">.\
.\@.\...

Pruébalo en línea!

Reflejado

.\@.\...
""".">.\
lrt@l""@
eih"ert"
fggtfiht
thiftggf
"tre"hie
@""l@trl
\.>"."""
...\.@\.

Pruébalo en línea!

Espejo y cuarto de vuelta

.\@"tfel".
.."thgir"\
.>"right"@
\"left"@..
..@"tfel"\
@"thgir">.
\"right"..
."left"@\.

Pruébalo en línea!

Klein (000) , 27 25 bytes

\(("right"@/
\(("left"@!\

Pruébalo en línea! Rotado una vez! Giró dos veces! Giró tres veces!

Y volteado: ¡ Pruébelo en línea! Rotado una vez! Giró dos veces! ¡Giró tres veces!

El único que me dio un poco de problemas fue el volteado y girado una vez, que se ve así:

\/
!@
@"
"t
th
fg
ei
lr
""
((
((
\\

Esta es la única razón para los dos conjuntos de ((.

Klein (211) , 37 bytes

!\"left"@"thgir"\!
!/............../!

Esto tiene un programa diferente para cada rotación.

Explicación

Tenga en cuenta que cada uno de estos programas se rellena a un cuadrado sin operaciones antes de la ejecución

Ningún cambio

!\"left"@"thgir"\!
!/............../!

Pruébalo en línea!

!hace que la ejecución salte \y "left"@cargue la cadena "left"en la pila y finaliza el programa que imprime la pila

Cuarto de vuelta

!!...IP->
\/
".
r.
i.
g.
h.
t.
".
@.
".
t.
f.
e.
l.
".
\/
!!
^
|
P
I

Pruébalo en línea!

La ejecución se ejecuta en la esquina superior derecha del cuadrado, continúa en la esquina inferior izquierda y una vez más !\"left"@imprime "left.

Media vuelta

                ^
                |
                P
                I
!/............../!
!\"right"@"tfel"\!
..................
..................
..................
..................
..................
..................
..................
..................
..................
..................
..................
..................
................^.
................|.
IP->............P.
................I.

Pruébalo en línea!

Aquí, la ruta de ejecución sale del lado norte, vuelve a entrar a través del lado oeste, sale nuevamente del este antes de entrar en el sur. \rebota el camino "left"@para imprimirlo.

Giro de tres cuartos

!!..IP->
/\
."
.l
.e
.f
.t
."
.@
."
.t
.h
.g
.i
.r
."
/\
!!
^
|
I
P

Pruébalo en línea

La ejecución sale de la esquina superior derecha y luego vuelve a entrar en la esquina inferior izquierda. Una vez más, los espejos /\redirigen el camino "left"@para imprimirlo.

Reflexión

!\"right"@"tfel"\!
!/............../!

Esto es esencialmente lo mismo que para la izquierda en todas las rotaciones.

JavaScript (Node.js) , 1481 599 505 461 341 305 271 bytes

/g+///g/g"c.c"g/
g=//////=rolol=g
"left"///inone/+
console//gsgsf//
.log(g)//ho(ot//
console//tlgl"//
"right"//"e)e//g
g=//////////////
//////////////=g
g//e)e"//"thgir"
//"lglt//elosnoc
//to(oh//)g(gol.
//fsgsg//elosnoc
+/enoni///"tfel"
g=lolor=//////=g
/g"c.c"g/g///+g/

Reflejado

/g"c.c"g/g///+g/
g=lolor=//////=g
+/enoni///"tfel"
//fsgsg//elosnoc
//to(oh//)g(gol.
//"lglt//elosnoc
g//e)e"//"thgir"
//////////////=g
g=//////////////
"right"//"e)e//g
console//tlgl"//
.log(g)//ho(ot//
console//gsgsf//
"left"///inone/+
g=//////=rolol=g
/g+///g/g"c.c"g/

Pruébalo en línea!

(Consulte el enlace TIO para ver todos los casos de prueba, incluida la versión duplicada)

Aunque más golf, tamaño 22x22 -> 21x21a crédito de @JoKing!

Tamaño 38x38 24x24 22x22 21x21 18x18 17x17 16x16, simetría de 4 veces.

Aquí viene una pregunta: ¿es posible tener 15x15 o menos para JS? Parece que lo que necesito al menos es el separador de comentarios entre dos subbloques y en el borde, por lo que al menos 7 + 2 + 2 + 5 = 16 líneas.

Lienzo , 109 89 71 bytes

（tfel⁸（（
（h（right
⁸g   q（f
li    re
er    il
f（    g⁸
thgir（h（
（（⁸left（

Pruébalo aquí | ¡Intenta al revés! Esos son los dos únicos programas posibles, ya que el programa es rotacionalmente simétrico.

Hecho en esto .

Gol> <> , 23 bytes

\"thgir"H /
\"tfel"H.9\

Pruébalo en línea!

Este es el mismo formato que mi respuesta Klein , pero 2 bytes más corto. Tal vez hay otro lenguaje 2D por ahí que puede eliminar esos últimos 2 bytes ... Pero por ahora, esto es lo más corto posible.

Alice , 25 bytes

}/"regttoo {
{/"lifh""@@{

Izquierda: Normal , 1/4 de vuelta en sentido horario , 1/2 de vuelta , 1/4 de vuelta en sentido antihorario

Derecha: reflejar a través de eje horizontal , abajo a la derecha en diagonal , eje vertical , diagonal arriba-derecha

Explicación

Este programa tiene tres partes. La primera parte son los tres {sy uno }en las esquinas. El {giro de la IP a la izquierda hasta que llegue a la }, en cuyo punto se gira a la derecha. En la versión reflejada, la IP va a lo largo de la fila superior del programa original. En la versión original, girar a la derecha golpeará inmediatamente al adyacente {, apuntando la IP a lo largo de la fila inferior del programa original.

Luego están las dos barras en la segunda columna. Si el programa está orientado horizontalmente, cualquier tipo de barra simplemente cambiaría al modo ordinal, enviando la IP en la misma dirección izquierda / derecha que ya estaba yendo. Si el programa está orientado verticalmente, la IP rebota un poco más, pero al hacer ambas barras inclinadas se obtiene el mismo resultado final. (Dos barras invertidas darían el resultado opuesto, y una de cada una crearía un bucle infinito).

El resto del programa es sencillo. La IP en modo ordinal rebota diagonalmente, por lo que se ejecutará "left"o@o "right"o@se ejecutará dependiendo de cómo se ingresó esta sección.

Hexagonía , 98 bytes.

\.@.t;./r.
.)@.;...;.
ll..)gt.;$
;.i<;;;i);
e;@.)@e;.l
.;e;d.g|.|
rt/;t.;)g\
@f.#l.;..r
\.;\.;i\.i

Pruébalo en línea! El | Girado 90 ° | Girado 180 ° | Girado 270 °
invertido | Girado 90 ° e invertido | Girado 180 ° e invertido |Girado 270 ° e invertido

La hexagonía fue un poco divertida para este desafío, porque una rotación o una reversión pueden cambiar drásticamente el programa real. Cada rotación / inversión es su propio programa único. Algunas de las rutas de ejecución del programa son mucho más interesantes que otras.

Admito que llegar a esto tomó más tiempo de lo que probablemente debería haberlo hecho. Estoy bastante seguro de que se puede hacer una respuesta más corta en Hexagony, ¡así que buena suerte!

Rubí , 131 bytes

#######:$:#
:right#l>r#
$><<###e<i#
:left##f<g#
####   t#h#
#t##   ##t#
#h#t   ####
#g<f##tfel:
#i<e###<<>$
#r>l#thgir:
#:$:#######

Pruébalo en línea!

APL (dzaima / APL) , 181 bytes

El programa tiene simetría rotacional, por lo que solo se deben verificar dos casos

Izquierda

⍝⍝⍝⍝⍝⍝⍝  t⎕t⍝
t←'lef'⍝ ←←←⍝
⎕←t,     't'⍝
t←'righ'⍝r,l⍝
   ⍝     i e⍝
 ⍝ '     g f⍝
⍝' h     h '⍝
⍝f g     t ⍝ 
⍝e i     ⍝   
⍝l,r⍝'hgir'←t
⍝'t'     ,t←⎕
⍝←←← ⍝'fel'←t
⍝t⎕t  ⍝⍝⍝⍝⍝⍝⍝

Pruébalo en línea!

Derecho

⍝t⎕t  ⍝⍝⍝⍝⍝⍝⍝
⍝←←← ⍝'fel'←t
⍝'t'     ,t←⎕
⍝l,r⍝'hgir'←t
⍝e i     ⍝   
⍝f g     t ⍝ 
⍝' h     h '⍝
 ⍝ '     g f⍝
   ⍝     i e⍝
t←'righ'⍝r,l⍝
⎕←t,     't'⍝
t←'lef'⍝ ←←←⍝
⍝⍝⍝⍝⍝⍝⍝  t⎕t⍝

Pruébalo en línea!

Explicación

Este es mi primer programa APL, por lo que es bastante simple. Solo usa un truco que creo que es interesante.

Si comenzamos eliminando todos los comentarios, obtenemos los siguientes programas

Izquierda

t←'lef'
⎕←t,     't'
t←'righ'

Derecho

t←'righ'
⎕←t,     't'
t←'lef'

A partir del programa de la izquierda, hacemos tres cosas.

1. Asignar 'lef'a la variablet

2. Imprime la variable ty la letra't'

3. Asignar 'righ'a la variablet

Ahora, debido a que es el espejo, el programa correcto realiza estos tres pasos pero en el orden opuesto. Esto significa que imprimimos 'left'para el programa izquierdo y 'right'para el programa correcto.

El único truco aquí es que en 't'realidad proviene de una copia rotada del código. Si observa la tercera columna de nuestro código, verá que es así 't'. Reutilizamos esto 't'en las versiones rotadas para agregar lo tque se necesita.

Haskell , 461 379 bytes

82 bytes guardados por Ørjan Johansen

--_----------mppr--
-- ----------a  l--
rl=p  p--   niam= _
p m="left"-- n==p--
p a="right"++ "" --
main  =putStr rl --
--n +r       =iep--
-- -+t       pgf---
-- -"S       uht---
-- "tt       tt" --
---thu       S"- --
---fgp       t+- --
--pei=       r+ n--
-- lr rtStup=  niam
-- "" ++"thgir"=a p
--p==n --"tfel"=m p
_ =main   --p  p=lr
--l  a---------- --
--rppm----------_--

Pruébalo en línea!

Como este tiene una simetría cuádruple, solo necesita probar el espejo:

--rppm----------_--
--l  a---------- --
_ =main   --p  p=lr
--p==n --"tfel"=m p
-- "" ++"thgir"=a p
-- lr rtStup=  niam
--pei=       r+ n--
---fgp       t+- --
---thu       S"- --
-- "tt       tt" --
-- -"S       uht---
-- -+t       pgf---
--n +r       =iep--
main  =putStr rl --
p a="right"++ "" --
p m="left"-- n==p--
rl=p  p--   niam= _
-- ----------a  l--
--_----------mppr--

Pruébalo en línea!

Este es un comienzo. Está lejos de ser ideal, pero hay algunas cosas interesantes que suceden aquí. Haskell es sin duda un lenguaje interesante para este desafío. Espero una respuesta que supere a esta, ya sea mía o de otra persona.

Prólogo (SWI) , 649 188 bytes

Sin voltear, sin rotar

:-%    l :%r     %-:
write(%e%-(i %(etirw
left).%f.weg%.)right
%      t)rth.      %
%      )tiit)      %
%      .htr)t      %
right).%gew.f%.)left
write(% i(-%e%(etirw
:-%     r%: l    %-:

Pruébalo en línea!

Sin voltear, girado

:wr%%%lw:
-ri   er-
%ig   fi%
 th   tt 
 et   )e 
 ()   .( 
 %.   %% 
  %.)tfel
right).% 
%(etirw-:
:-write(%
 %.)thgir
left).%  
 %%   .% 
 (.   )( 
 e)   re 
 tl   it 
%ie   gi%
-rf   hr-
:wt%%%tw:

Pruébalo en línea!

Volteado, sin rotar

:-%     r%: l    %-:
write(% i(-%e%(etirw
right).%gew.f%.)left
%      .htr)t      %
%      )tiit)      %
%      t)rth.      %
left).%f.weg%.)right
write(%e%-(i %(etirw
:-%    l :%r     %-:

Pruébalo en línea!

Volteado, girado

:wl%%%rw:
-re   ir-
%if   gi%
 tt   ht 
 e)   te 
 (.   )( 
 %%   .% 
left).%  
 %.)thgir
:-write(%
%(etirw-:
right).% 
  %.)tfel
 %.   %% 
 ()   .( 
 er   )e 
 ti   lt 
%ig   ei%
-rh   fr-
:wt%%%tw:

Pruébalo en línea!

Prólogo (SWI) , 239 223 209 181 bytes

%%%%%%%  l:r%
right).% e-i%
:-write(%fwg%
left).%  trh%
  %      )it%
 %(      .t)%
%.e%     %e.%
%)t.      (%
%ti)      %
%hrt  %.)tfel
%gwf%(etirw-:
%i-e %.)thgir
%r:l  %%%%%%%

Pruébalo en línea!

Dado que el programa tiene una simetría de 4 veces, solo necesita verificar el espejo:

%r:l  %%%%%%%
%i-e %.)thgir
%gwf%(etirw-:
%hrt  %.)tfel
%ti)      %  
%)t.      (% 
%.e%     %e.%
 %(      .t)%
  %      )it%
left).%  trh%
:-write(%fwg%
right).% e-i%
%%%%%%%  l:r%

Pruébalo en línea!

Python 2 , 209 bytes (14 x 14)

Normal (izquierda):

##########sps#
s="left"##=r=#
print s###"i"#
s="right"#rnl#
####      ite#
###"      g f#
#"#t      hst#
#tsh      t#"#
#f g      "###
#eti      ####
#lnr#"thgir"=s
#"i"###s tnirp
#=r=##"tfel"=s
#sps##########

Pruébalo en línea!

Reflejado (derecha):

#sps##########
#=r=##"tfel"=s
#"i"###s tnirp
#lnr#"thgir"=s
#eti      ####
#f g      "###
#tsh      t#"#
#"#t      hst#
###"      g f#
####      ite#
s="right"#rnl#
print s###"i"#
s="left"##=r=#
##########sps#

Pruébalo en línea!

Limpio , 1331 1055 bytes

-276 bytes gracias a Ørjan Johansen

// ////////////;/;/////////// //
// ////////////S/S/////////// //
  module m////mtmt////m eludom  
//o///////////=a=a///////////o//
//d///////////"r"r///////////d//
//u///////////tttt///////////u//
//l///////////f#h#///////////l//
//e///////////emgm///////////e//
// ///////////loio/////////// //
//m///////////"drd///////////m//
//////////////=u"u//////////////
//////////////ml=l//////////////
//////////////#eme//////////////
////////////// =#=//////////////
;Start#module= 0   #m="left"=m//
//m="thgir"=m#   0=eludom#tratS;
;Start#module=0   #m="right"=m//
//m="tfel"=m#   0 =eludom#tratS;
//////////////=#= //////////////
//////////////eme#//////////////
//////////////l=lm//////////////
//////////////u"u=//////////////
//m///////////drd"///////////m//
// ///////////oiol/////////// //
//e///////////mgme///////////e//
//l///////////#h#f///////////l//
//u///////////tttt///////////u//
//d///////////r"r"///////////d//
//o///////////a=a=///////////o//
  module m////tmtm////m eludom  
// ///////////S/S//////////// //
// ///////////;/;//////////// //

Intenta "izquierda" en línea!

¡Prueba "correcto" en línea!

Esto fue difícil por muchas razones:

• Clean requiere que el encabezado del archivo module <filename>esté presente al inicio, y solo el inicio del archivo. Desafortunadamente, esto significa que para que las rotaciones del programa reflejado sean válidas, también tiene que aparecer al final del archivo. Para empeorar esto, module ..no es válido para global let .. in, where ..y with ..definiciones; y la fichamodule aparece si no se ha definido causa un error.
• Tanto los comentarios de bloque como los comentarios de línea anidan: /* /* */deja un nivel de comentario abierto, y también lo hace/* // */ (además de comentar el resto de la línea).
• La misma función se puede definir varias veces, pero solo directamente después de sí misma.

Afortunadamente, podemos definir modulecomo algo en una #..expresión (y mucho antes), que es todo lo que necesitamos. Debido a que Clean no comprueba las alternativas de verificación de tipo que nunca se usan (y una variedad de otras cosas igualmente no utilizadas), la segunda definición necesaria de Startpuede ser basura completa. Esto nos permite utilizar la segunda Startpara consumir la cabecera del módulo en la parte inferior del archivo porque trata limpias m module mcomo llamar a la función mde moduley m(que ya hemos definido moduley m, no causa un error). No importa que msea ​​una cadena y no una función, porque elStart alternativa nunca se verifica por tipo.

Esto es más fácil de ver si lo miras a través de los ojos del compilador:

module m;
Start#module=0#m="left"=m;
Start#module=0#m="right"=m module m

Brachylog , 341 bytes

Ẹw"thgir"∧"left"wẸ
w"              "w
"                "
t                t
f                h
e                g
l                i
"                r
∧                "
"                ∧
r                "
i                l
g                e
h                f
t                t
"                "
w"              "w
Ẹw"tfel"∧"right"wẸ

Pruébalo en línea!

! enilno ti yrT

Aprovecha que Brachylog toma el predicado principal como el que está en la primera línea y no se preocupa mucho por las otras líneas más allá de requerir que puedan compilarse. Sin reflejo, imprime una cadena vacía seguida de "izquierda" en la misma línea, y refleja que imprime una cadena vacía seguida de "derecha" en la misma línea. Estoy tentado a pensar que podría haber una manera de hacer una versión (útilmente) no cuadrada usando ṇ, pero eso podría ser bastante complicado sin tratar de hacer que funcione de manera diferente bajo reflexión.

Rubí , 181 bytes

#########tpt#
t=:left##=u=#
puts t###:t:#
t=:right#rsl#
####     i e#
###t     gtf#
#t#h     h#t#
#ftg     t###
#e i     ####
#lsr#thgir:=t
#:t:###t stup
#=u=##tfel:=t
#tpt#########

Pruébalo en línea!

Este es un puerto de la respuesta Python de Curtis Bechtel a Ruby, un poco más de golf.

En realidad, su programa Python es un políglota y también se ejecuta en Ruby, por lo que mi primera respuesta fue copiar y pegar, pero parecía injusto. Entonces escribí un script que genera una nueva respuesta a partir de un script base. Puedes probarlo aquí:

Construye tu propio

Lote, 438 321 bytes

:::::::::::::@@@:
@echo left&: eee:
@exit/b&:    cxc:
@echo right&:hih:
:  :         oto:
:: &          / :
:& t         rbl:
:t h         i&e:
:f:g         g:f:
:e&i         h t:
:lbr         t &:
: /          & ::
:oto         :  :
:hih:&thgir ohce@
:cxc    :&b/tixe@
:eee :&tfel ohce@
:@@@:::::::::::::

Explicación: A :se usa para indicar una etiqueta, que es tan buena como un comentario, por lo que, dado que el programa tiene simetría rotacional, la única diferencia entre las dos versiones es cuál de las @líneas es la primera, en cuyo caso se genera lefto rightsale antes del script salidas

Intenté superponer creativamente las líneas rotadas entre sí, pero mi intento realmente terminó con una cuadrícula más grande.

Editar: Guardado 117 bytes gracias a @ ØrjanJohansen.

05AB1E (heredado) , 89 55 bytes

'…¸q©ƒ'
ƒ     …
©     ¸
q     q
¸     ©
…     ƒ
'ƒ©q¸…'

Enfoque muy básico. Salidas en minúsculas completas.

Pruébelo en línea o en línea reflejado (cada rotación es la misma).

Explicación:

'…¸   '# Push the dictionary string "left" to the stack
   q   # Stop the program (and output the top of the stack implicitly)
       # Everything else after it is ignored

Invertido:

'ĩ   '# Push the dictionary string "right" to the stack
   q   # Stop the program (and output the top of the stack implicitly)
       # Everything else after it is ignored

Vea esta sugerencia mía 05AB1E (sección ¿Cómo usar el diccionario? ) Para comprender por qué '…¸es "left"y 'ĩes "right".

Stax , 131 bytes

 .Cq"tfel" 
""`KT?`qC".
lC       `C
eq       Kq
f`       T"
t?       ?t
"T       `f
qK       qe
C`       Cl
."Cq`?TK`""
 "left"qC. 

Ejecutar y depurarlo

Esta es la variante "correcta".

Encantamientos rúnicos , 116 bytes

> \ !U\L
 ...@.. 
 \.R""" 
 @""trl 
 "lrhie 
 teiggf 
 ffgiht 
 ethrt" 
 l"t""@ 
 " "R.\ 
 .\@.@. 
DR\!!/R 
     !! 

Pruébalo en línea!

Y revertido

No es exactamente un puerto, pero utilizó la respuesta Klein 000 de Post Left Garf Hunter como punto de partida, dada la compatibilidad casi típica de los dos idiomas (la mayoría de los comandos son los mismos y el ajuste del borde en Runic es idéntico al Klein 000). El único problema era que las IP de Klein siempre comienzan desde la parte superior izquierda y las Runic no. Como tal ., todos son parte del código original y Runic todavía los trata como NOP, mientras que son NOP que tuve que agregar como parte del control del flujo.

Huellas dactilares "left" en las 4 rotaciones y"right" cuando se refleja (y en todas las cuatro rotaciones de la misma). Dos columnas del medio no se utilizaron por completo después de mis modificaciones, por lo que pude eliminarlas.

En teoría, una rotación con mucho espacio en blanco al final podría usarse para un recuento de bytes más bajo (por ejemplo, esta variante ), sin embargo, los espacios son necesarios para rotar correctamente la estructura usando herramientas externas, por lo que los incluí.

Las siguientes variantes contienen los fragmentos no utilizados que se eliminaron, pero que son idénticos:

Las cuatro izquierdas . Salidas leftleftleftleft(el hecho de que los cuatro puedan ejecutarse así es una coincidencia).

Derecha 1 , Derecha 2 , Derecha 3 , Derecha 4

Gol> <> , 342 bytes

 8A_          _A8 
9       ""       9
A       LR       A
_       EI       _
        FG        
        TH        
        "T        
         "        
 "TFEL" HH"RIGHT" 
 "THGIR"HH "LEFT" 
        "         
        T"        
        HT        
        GF        
_       IE       _
A       RL       A
9       ""       9
 8A_          _A8  

¡Guauu! Eso tardó más de lo que esperaba, a mitad de camino me di cuenta de que el reflejo era vertical , ¡no horizontal como había estado codificando! Estoy bastante seguro de que esto funciona, pero si cometí un error, avíseme. Lo más probable es que esto pueda jugarse una cantidad ridícula más, simplemente tomé un método de fuerza bruta extrema para hacerlo. La forma en sí es en realidad un cuadrado, es técnicamente simétrica, excepto en el eje x, por lo que cuando se voltea, devuelve "DERECHA".

¡El personaje que hizo posible este programa es la 'A', que permite la teletransportación al comienzo de una línea determinada!

Pruébalo en línea!