Uma forma é quiral se nenhuma quantidade de rotação puder parecer com a imagem no espelho. Neste quebra-cabeça, estaremos escrevendo programas de computador quirais.

Para este quebra-cabeça, pensaremos em um programa como uma matriz retangular de caracteres. Como tal, todas as soluções para esse desafio devem ser retangulares (ou seja, todas as linhas devem ter o mesmo comprimento). Podemos rotacionar esses programas em incrementos de um quarto de volta. Por exemplo, o programa

The quickish fish
    lept deftly  
  rightwards     

Quando girado um quarto de volta no sentido horário, parece

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

Também podemos refletir esses programas. Aqui está o mesmo programa refletido em um eixo vertical:

hsif hsikciuq ehT
  yltfed tpel    
    sdrawthgir   

Um programa quiral é um programa que, quando girado qualquer número de vezes, sempre gera " left". No entanto, quando refletido, produz um programa que " right" produz, não importa quantas vezes ele é rotacionado.

Sua tarefa é escrever um programa quiral no menor número de bytes possível.

Regras adicionais

• A saída não diferencia maiúsculas de minúsculas, mas deve ser consistente. (por exemplo, você pode imprimir " LEFT" e " rIgHt", mas esta caixa deve ser consistente em rotações)

• As linhas devem ser divididas em uma nova linha ou em uma nova linha e em um avanço de linha.

• Seu programa deve ser um retângulo, você pode preenchê-lo com espaços ou comentários, mas cada linha deve ter o mesmo comprimento.

• Opcionalmente, você pode ter uma nova linha à direita (ou nova linha e avanço de linha) em todos os seus programas, se desejar.

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

Tente à esquerda

Tente direito

@tsh me motivou a tentar novamente quando vi seu programa (no comentário) e aqui está ele!

Anterior com 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 

Tente à esquerda

Tente direito

Se você viu meu envio anterior, esqueça: :)

Todas as rotações para os programas esquerdo e direito são iguais.

Klein (000) , 109 87 bytes

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

Experimente online!

Deve ser possível obter uma versão mais curta desta resposta, então boa sorte!

Esta resposta é inspirada em espirais. Em particular, a ideia são duas espirais entrelaçadas, uma para a esquerda e outra para a direita. Tem simetria dupla, para que possamos verificar os seguintes programas para saber se funciona:

Quarto de volta

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

Experimente online!

Espelhado

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

Experimente online!

Espelhado e quarto de volta

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

Experimente online!

Klein (000) , 27 25 bytes

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

Experimente online! Rodado uma vez! Rodado duas vezes! Rodado três vezes!

E virou: Experimente online! Rodado uma vez! Rodado duas vezes! Rodado três vezes!

O único que me deu um pouco de dificuldade foi o inverter e girar uma vez, que se parece com:

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

Esta é a única razão para os dois conjuntos de ((.

Klein (211) , 37 bytes

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

Isso tem um programa diferente para cada rotação.

Explicação

Observe que cada um desses programas é preenchido com um quadrado sem ops antes da execução

Sem alteração

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

Experimente online!

!faz a execução saltar sobre \e "left"@carregar a string "left"na pilha e finaliza o programa imprimindo a pilha

Quarto de volta

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

Experimente online!

A execução sai do canto superior direito do quadrado, continua no canto inferior esquerdo e mais uma vez é !\"left"@impressa "left.

Meia volta

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

Experimente online!

Aqui, o caminho de execução sai do lado norte, entra novamente no lado oeste e sai novamente do leste. Antes de entrar no sul. \salta o caminho "left"@para imprimi-lo.

Volta de três quartos

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

Experimente online

A execução sai do canto superior direito e depois entra novamente no canto inferior esquerdo. Mais uma vez, os espelhos /\redirecionam o caminho "left"@para imprimi-lo.

Reflexão

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

É essencialmente o mesmo que para a esquerda em todas as rotações.

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/

Espelhado

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

Experimente online!

(Consulte o link TIO para todos os casos de teste, incluindo a versão espelhada)

Apesar de ainda 22x22 -> 21x21jogar golfe , o tamanho do crédito da @JoKing!

Tamanho 38x38 24x24 22x22 21x21 18x18 17x17 16x16, simetria 4 vezes.

Aí vem uma pergunta - é possível ter 15x15 ou menor para JS? Parece que o que eu preciso no mínimo é o separador de comentários entre dois sub-blocos e na borda, então pelo menos 7 + 2 + 2 + 5 = 16 linhas?

Tela , 109 89 71 bytes

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

Experimente aqui | Tente invertido! Esses são os únicos dois programas possíveis, pois o programa é rotacionalmente simétrico.

Feito nisso .

Gol> <> , 23 bytes

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

Experimente online!

Esse é o mesmo formato da minha resposta Klein , mas 2 bytes mais curto. Talvez exista outra linguagem 2D por aí que possa tirar os últimos 2 bytes de folga ... Mas, por enquanto, isso é o mais curto possível.

Alice , 25 bytes

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

Esquerda: Normal , 1/4 de volta no sentido horário , 1/2 de volta , 1/4 de volta no sentido anti-horário

Direita: refletir em toda eixo horizontal , diagonal para baixo com o botão direito , eixo vertical , diagonal-se com o botão direito

Explicação

Este programa tem três partes. A primeira parte são os três se {um }nos cantos. A {volta do IP para a esquerda até atingir o }ponto em que ele vira à direita. Na versão refletida, o IP percorre a linha superior do programa original. Na versão original, virar à direita atingirá imediatamente o adjacente {, apontando o IP ao longo da linha inferior no programa original.

A seguir, estão as duas barras na segunda coluna. Se o programa for orientado horizontalmente, qualquer tipo de barra simplesmente mudaria para o modo ordinal, enviando o IP na mesma direção esquerda / direita que ele já estava seguindo. Se o programa é orientado verticalmente, o IP salta um pouco mais, mas torná-los os dois barras dá o mesmo resultado. (Duas barras invertidas dariam o resultado oposto e uma de cada uma criaria um loop infinito.)

O restante do programa é direto. O IP no modo ordinal salta na diagonal, portanto, "left"o@ou "right"o@será executado dependendo de como esta seção foi inserida.

Hexagonia , 98 bytes

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

Experimente online! | Girado 90 ° | Girado 180 ° | Girado 270 °
Invertido | Girado 90 ° e invertido | Girado 180 ° e invertido | Girado 270 ° e invertido

A hexagonia foi divertida para esse desafio, porque uma rotação ou reversão pode mudar drasticamente o programa atual. Cada rotação / reversão é seu próprio programa. Alguns dos caminhos de execução do programa são muito mais interessantes que outros.

Eu admito que chegar a isso levou mais tempo do que provavelmente deveria. Tenho certeza de que uma resposta mais curta pode ser feita no Hexagony, então boa sorte!

Ruby , 131 bytes

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

Experimente online!

APL (dzaima / APL) , 181 bytes

O programa possui simetria rotacional, portanto, apenas dois casos precisam ser verificados

Esquerda

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

Experimente online!

Direito

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

Experimente online!

Explicação

Este é o meu primeiro programa APL, por isso é bastante simples. Ele usa apenas um truque que eu acho interessante.

Se começarmos a retirar todos os comentários, obteremos os seguintes programas

Esquerda

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

Direito

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

A partir do programa esquerdo, fazemos três coisas.

1. Atribuir 'lef'à variávelt

2. Imprimir a variável te a letra't'

3. Atribuir 'righ'à variávelt

Agora, porque é o espelho, o programa certo executa essas três etapas, mas na ordem oposta. Isso significa que imprimimos 'left'para o programa da esquerda e 'right'para o programa da direita.

O único truque aqui é que na 't'verdade vem de uma cópia girada do código. Se você olhar para a terceira coluna do nosso código, verá que é 't'. Reutilizamos isso 't'nas versões rotacionadas para acrescentar o tque é necessário.

Haskell , 461 379 bytes

82 bytes salvos 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----------_--

Experimente online!

Como este possui simetria 4 vezes, você só precisa testar o espelho:

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

Experimente online!

Isso é um começo. Está longe do ideal, mas há algumas coisas interessantes acontecendo aqui. Haskell é certamente uma linguagem interessante para esse desafio. Estou ansioso por uma resposta que supere esta seja minha ou de outra pessoa.

Prolog (SWI) , 649 188 bytes

Unflipped, Unrotated

:-%    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    %-:

Experimente online!

Não girado, 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:

Experimente online!

Invertida, não rotacionada

:-%     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     %-:

Experimente online!

Virado, 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:

Experimente online!

Prolog (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  %%%%%%%

Experimente online!

Como o programa tem simetria em quatro dobras, você só precisa verificar o espelho:

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

Experimente online!

Python 2 , 209 bytes (14 x 14)

Normal (esquerda):

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

Experimente online!

Refletido (à direita):

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

Experimente online!

Limpo , 1331 1055 bytes

-276 bytes graças 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//////////// //
// ///////////;/;//////////// //

Experimente "esquerda" online!

Tente "certo" online!

Isso foi difícil por vários motivos:

• Limpar requer que um cabeçalho de arquivo module <filename>esteja presente no início e somente no início do arquivo. Infelizmente, isso significa que, para que as rotações do programa espelhado sejam válidas, ele também deve aparecer na parte inferior do arquivo. Para fazer esta pior, module ..é inválido para globais, let .. in, where ..e with ..definições; e o token que moduleaparece se não tiver sido definido causa um erro.
• Os comentários em bloco e os comentários de linha são aninhados: /* /* */deixa em aberto um nível de comentário, e o mesmo acontece /* // */(além de comentar o restante da linha).
• A mesma função pode ser definida várias vezes, mas somente diretamente após ela mesma.

Felizmente, nós podemos definir modulecomo algo em um #..(deixe-before) expressão, que é toda a necessidade que nós. Como o Clean não verifica alternativas que nunca são usadas (e várias outras coisas igualmente não utilizadas), a segunda definição necessária Startpode ser um lixo completo. Isso nos permite usar o segundo Startpara consumir o cabeçalho do módulo na parte inferior do arquivo, porque trata limpas m module mcomo chamar a função mde modulee m(que desde que nós definido modulee m, não causa um erro). Não importa se mé uma string e não uma função, porque a Startalternativa nunca é verificada.

É mais fácil ver se você olha através dos olhos do compilador:

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

Braquilog , 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Ẹ

Experimente online!

! enilno ti yrT

Aproveita que o Brachylog adote o predicado principal como aquele na primeira linha e não se preocupe muito com as outras linhas além de exigir que elas possam compilar. Não refletida, ela imprime uma sequência vazia seguida de "esquerda" na mesma linha e refletida exibe uma sequência vazia seguida de "direita" na mesma linha. Fico tentado a pensar que pode haver uma maneira de criar uma versão não quadrada (útil) ṇ, mas isso pode ser bastante complicado sem tentar fazê-la funcionar de maneira diferente sob reflexão.

Ruby , 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#########

Experimente online!

Este é um porto da resposta Python de Curtis Bechtel para Ruby, jogou um pouco mais.

Na verdade, seu programa Python é um poliglota e roda em Ruby também, então minha primeira resposta foi uma cópia e pasta, mas parecia injusto. Então, eu escrevi um script que gera uma nova resposta a partir de um script base. Você pode tentar aqui:

Construa o seu próprio

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@
:@@@:::::::::::::

Explicação: A :é usado para indicar um rótulo, que é tão bom quanto um comentário, portanto, como o programa tem simetria rotacional, a única diferença entre as duas versões é qual das @linhas é a primeira, e nesse caso uma leftou righté emitida antes do script saídas.

Tentei sobrepor criativamente as linhas giradas, mas minha tentativa acabou com uma grade maior.

Editar: salvou 117 bytes graças a @ ØrjanJohansen.

05AB1E (legado) , 89 55 bytes

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

Abordagem muito básica. Saídas em minúsculas.

Experimente on-line ou on -line refletido (cada rotação é a mesma).

Explicação:

'…¸   '# 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

Invertida:

'ĩ   '# 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

Veja esta dica 05AB1E (seção Como usar o dicionário? ) Para entender por que '…¸é "left"e 'ĩé "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. 

Execute e depure

Essa é a variante "correta".

Encantos Rúnicos , 116 bytes

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

Experimente online!

E invertido

Não é exatamente uma porta, mas utilizou a resposta Klein 000 de Post Left Garf Hunter como ponto de partida, dada a quase compatibilidade típica dos dois idiomas (a maioria dos comandos é a mesma e o empacotamento de borda no Runic é idêntico ao Klein 000). O único problema era que os IPs Klein sempre começam do canto superior esquerdo e os da Runic não. Como tal, .todos fazem parte do código original e ainda são tratados como NOP pela Runic, enquanto os são NOPs que tive que adicionar como parte do controle do fluxo.

Imprime "left"nas 4 rotações e "right"quando espelhado (e nas quatro rotações). Duas colunas do meio ficaram completamente sem uso após minhas modificações, então pude removê-las.

Em teoria, uma rotação com muito espaço em branco à direita poderia ser usada para uma contagem de bytes mais baixa (por exemplo, essa variante ), no entanto, os espaços são necessários para girar corretamente a estrutura usando ferramentas externas e, portanto, eu as incluí.

As variantes abaixo contêm os pedaços não utilizados que foram removidos, mas são idênticos:

Todas as quatro esquerdas . Saídas leftleftleftleft(o fato de que todas as quatro podem ser executadas dessa maneira é coincidência).

Direito 1 , Direito 2 , Direito 3 , Direito 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  

Uau! Isso levou mais tempo do que eu esperava, no meio do caminho, percebi que o reflexo era vertical , não horizontal como eu estava codificando! Tenho certeza de que isso funciona, mas se eu cometer um erro, entre em contato. Provavelmente isso pode ser jogado muito mais, apenas tomei um método de força bruta extrema para fazer isso. A forma em si é na verdade um quadrado, é tecnicamente simétrica, exceto no eixo x, portanto, quando ela vira, retorna "DIREITA"!

O personagem que tornou esse programa possível é o 'A', que permite o teletransporte para o início de uma determinada linha!

Experimente online!