Форма является хиральной, если никакое вращение не может сделать ее похожей на зеркальное отражение. В этой головоломке мы будем писать киральные компьютерные программы.

Для этой головоломки мы будем думать о программе как о прямоугольной матрице символов. Таким образом, все решения этой задачи должны быть прямоугольными (то есть все линии должны быть одинаковой длины). Мы можем вращать эти программы с шагом в четверть оборота. Например, программа

The quickish fish
    lept deftly  
  rightwards     

При повороте на четверть оборота по часовой стрелке выглядит

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

Мы также можем отразить эти программы. Вот та же программа, отраженная по вертикальной оси:

hsif hsikciuq ehT
  yltfed tpel    
    sdrawthgir   

Киральная программа - это программа, которая при вращении любое количество раз всегда будет выводить " left". Однако при отражении создается программа, которая выдает « right» независимо от того, сколько раз она поворачивается.

Ваша задача - написать киральную программу с минимальным количеством байтов.

Дополнительные правила

• Выходные данные не чувствительны к регистру, но должны быть согласованы. (например, вы можете вывести " LEFT" и " rIgHt", но этот корпус должен быть согласован при поворотах)

• Строки должны быть разделены либо на новую строку, либо на новую строку и перевод строки.

• Ваша программа должна быть прямоугольником, вы можете заполнить ее пробелами или комментариями, но каждая строка должна иметь одинаковую длину.

• При желании вы можете использовать завершающий символ новой строки (или символ новой строки и перевода строки) во всех своих программах.

Паскаль (FPC) , 2161 755 349 байт

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

Попробуй налево

Попробуйте прямо

@tsh побудил меня попробовать еще раз, когда я увидел его программу (в комментарии), и вот она!

Предыдущий с 755 байтами:

 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 

Попробуй налево

Попробуйте прямо

Если вы видели мое предыдущее представление, просто забудьте об этом :)

Все повороты для левой и правой программ одинаковы.

Кляйн (000) , 109 87 байт

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

Попробуйте онлайн!

Должна быть возможность получить более короткую версию этого ответа, так что удачи!

Этот ответ вдохновлен спиралями. В частности, идея заключается в двух взаимосвязанных спиралях, одна для левой и одна для правой. Он имеет двойную симметрию, поэтому мы можем проверить следующие программы, чтобы убедиться, что он работает:

Четверть оборота

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

Попробуйте онлайн!

Зеркальный

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

Попробуйте онлайн!

Зеркальный и четверть оборота

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

Попробуйте онлайн!

Кляйн (000) , 27 25 байтов

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

Попробуйте онлайн! Вращается один раз! Вращается дважды! Вращается три раза!

И перевернул: Попробуйте онлайн! Вращается один раз! Вращается дважды! Вращается трижды!

Единственный, кто доставил мне немного хлопот, был один раз перевернут и повернут, что выглядит примерно так:

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

Это единственная причина для двух наборов ((.

Кляйн (211) , 37 байт

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

Это имеет разные программы для каждого вращения.

объяснение

Обратите внимание, что каждая из этих программ перед выполнением дополняется квадратом без операций

Без изменений

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

Попробуйте онлайн!

!делает выполнение перепрыгивает через \и "left"@загружает строку "left"в стек и завершает программу печати стека

Четверть оборота

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

Попробуйте онлайн!

Выполнение выполняется в верхнем правом углу квадрата, продолжается в нижнем левом углу и снова !\"left"@печатается "left.

Пол оборота

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

Попробуйте онлайн!

Здесь путь казни выходит с северной стороны, возвращается через западную сторону, снова выходит с востока, прежде чем войти на юг. \отскакивает путь, "left"@чтобы напечатать его.

Три четверти оборота

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

Попробуйте онлайн

Выполнение завершается из правого верхнего угла, а затем снова входит в нижний левый. Еще раз зеркала /\перенаправляют путь, "left"@чтобы напечатать это.

отражение

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

Это в основном так же, как и для левого поворота во всех поворотах.

JavaScript (Node.js) , 1481 599 505 461 341 305 271 байт

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

Зеркальный

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

Попробуйте онлайн!

(Пожалуйста, смотрите TIO Link для всех тестовых случаев, включая зеркальную версию)

Хотя в дальнейшем игра в гольф, размер 22x22 -> 21x21в кредит @JoKing!

Размер 38x38 24x24 22x22 21x21 18x18 17x17 16x16, 4-кратные симметрии.

Возникает вопрос - можно ли иметь размер 15х15 или меньше для JS? Кажется, что мне нужно, по крайней мере, разделитель комментариев между двумя подблоками и по краю, так что, по крайней мере, 7 + 2 + 2 + 5 = 16 строк?

Холст , 109 89 71 байт

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

Попробуй это здесь | Попробуйте наоборот!Это единственные две возможные программы, так как программа является вращательно-симметричной.

Сделано в этом .

Gol> <> , 23 байта

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

Попробуйте онлайн!

Это тот же формат, что и мой ответ Кляйна , но на 2 байта короче. Может быть, есть еще один 2D-язык, который может сыграть в гольф последние 2 байта ... Но пока это так коротко, как только может.

Алиса , 25 байт

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

Влево: нормальный , 1/4 оборота по часовой стрелке , 1/2 оборота , 1/4 оборота против часовой стрелки

Справа: отражение по горизонтальной оси , диагональ вниз-вправо , вертикальная ось , диагональ вверх-вправо

объяснение

Эта программа состоит из трех частей. Первая часть - три {с и одна }по углам. {Очередь IP - влево , пока он не достигнет }, в какой момент он поворачивает направо. В отраженной версии IP идет вдоль верхнего ряда в исходной программе. В исходной версии поворот вправо сразу же поразит соседний {, указывая IP вдоль нижнего ряда в исходной программе.

Далее идут две косые черты во втором столбце. Если программа ориентирована горизонтально, любой тип слеша просто переходит в порядковый режим, отправляя IP в том же левом / правом направлении, в котором он уже был. Если программа ориентирована по вертикали, IP-адрес отскакивает немного больше, но создание их обоих слэшей дает одинаковый конечный результат. (Два обратных слеша дадут противоположный результат, и один из них создаст бесконечный цикл.)

Остальная часть программы проста. IP в порядковом режиме отскоков по диагонали, так что либо "left"o@или "right"o@будет работать в зависимости от того, как был введен этот раздел.

Hexagony , 98 байт

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

Попробуйте онлайн! | Повернут на 90 ° | Повернут на 180 ° | Повернуто на 270 °
Реверс | Повернуто на 90 ° и перевернуто |Повернуто на 180 ° и перевернуто | Повернут на 270 ° и повернут

Гексагония была забавной для этого вызова, потому что ротация или разворот могут радикально изменить реальную программу. Каждое вращение / обращение - это своя уникальная программа. Некоторые пути выполнения программы намного интереснее других.

Я признаю, что придумывание этого заняло больше времени, чем, вероятно, следовало бы. Я почти уверен, что в Гексагонии можно сделать более короткий ответ, так что удачи!

Рубин , 131 байт

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

Попробуйте онлайн!

APL (Дзайма / APL) , 181 байт

Программа имеет вращательную симметрию, поэтому необходимо проверить только два случая

Оставил

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

Попробуйте онлайн!

Правильно

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

Попробуйте онлайн!

объяснение

Это моя первая программа APL, поэтому она довольно проста. Он использует только один трюк, который я считаю интересным.

Если мы начнем с удаления всех комментариев, мы получим следующие программы

Оставил

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

Правильно

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

Начиная с левой программы, мы делаем три вещи.

1. Присвоить 'lef'переменнойt

2. Распечатать переменную tи письмо't'

3. Присвоить 'righ'переменнойt

Теперь, потому что это зеркало, правильная программа делает эти три шага, но в обратном порядке. Это означает, что мы печатаем 'left'для левой программы и'right' для правой программы.

Единственная хитрость заключается в том, что на 't'самом деле происходит из повернутой копии кода. Если вы посмотрите на третий столбец нашего кода, вы увидите, что это так 't'. Мы повторно используем это 't'в повернутых версиях, чтобы добавить то, tчто нужно.

Haskell , 461 379 байт

Эрджан Йохансен спас 82 байта

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

Попробуйте онлайн!

Так как этот имеет 4-х кратную симметрию, вам нужно только проверить зеркало:

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

Попробуйте онлайн!

Это начало. Это далеко от идеала, но здесь происходит несколько интересных вещей. Haskell, безусловно, интересный язык для этой задачи. Я с нетерпением жду ответа, который превосходит это, будь то мой или чей-то еще.

Пролог (SWI) , 649 188 байт

Разбитый, Не повернутый

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

Попробуйте онлайн!

Развернутый, повернутый

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

Попробуйте онлайн!

Перевернутый, Не повернутый

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

Попробуйте онлайн!

Перевернутый, повернутый

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

Попробуйте онлайн!

Пролог (SWI) , 239 223 209 181 байт

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

Попробуйте онлайн!

Поскольку программа имеет 4-кратную симметрию, вам нужно только проверить зеркало:

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

Попробуйте онлайн!

Python 2 , 209 байт (14 х 14)

Нормальный (слева):

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

Попробуйте онлайн!

Отражение (справа):

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

Попробуйте онлайн!

Чисто , 1331 1055 байт

-276 байт благодаря Орджану Йохансену

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

Попробуйте "левый" онлайн!

Попробуйте "правильно" онлайн!

Это было сложно по многим причинам:

• Очистка требует наличия заголовка файла module <filename>в начале и только в начале файла. К сожалению, это означает, что для правильного поворота зеркальной программы она также должна отображаться внизу файла. Чтобы сделать это хуже, module ..является недействительным для глобальных, let .. in, where ..и with ..определений; и токен, moduleесли он не был определен, вызывает ошибку.
• И блочные комментарии, и комментарии строки: гнездо: /* /* */оставляет один уровень комментария открытым, как и /* // */(так же, как и комментирование остальной части строки).
• Одна и та же функция может быть определена несколько раз, но только непосредственно после нее.

К счастью, мы можем определитьmodule что-то в #..выражении (пусть до), и это все, что нам нужно. Поскольку Clean не проверяет альтернативы, которые никогда не используются (и множество других одинаково неиспользуемых вещей), необходимое второе определение Startможет быть полным мусором. Это позволяет использовать второй Startпотреблять заголовок модуля в нижней части файла , так как чистые лакомства , m module mкак вызов функции mна moduleи m(что , так как мы определили moduleи m, не вызывает ошибку). Неважно, что mэто строка, а не функция, потому чтоStart альтернатива никогда не проверяется на тип.

Это легче увидеть, если вы посмотрите на это глазами компилятора:

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

Брахилог , 341 байт

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

Попробуйте онлайн!

! Enilno TY YRT

Воспользуется тем, что Brachylog использует основной предикат в качестве первого в первой строке и не слишком заботится о других строках, не требуя их компиляции. Не отраженный, он печатает пустую строку, за которой следует «left» в той же строке, и при отражении печатает пустую строку, за которой следует «right» в той же строке. Я испытываю желание подумать, что может быть способ сделать (полезную) неквадратную версию ṇ, но это может быть довольно сложно, не пытаясь заставить ее работать по-другому в рефлексии.

Рубин , 181 байт

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

Попробуйте онлайн!

Это порт Питона, ответ Куртиса Бектела на Ruby, немного больше в гольфе.

На самом деле, его программа на Python является полиглотом и работает также на Ruby, поэтому мой первый ответ был копией, но это казалось несправедливым. Поэтому я написал скрипт, который генерирует новый ответ, начиная с базового скрипта. Вы можете попробовать это здесь:

Построй свой собственный

Batch, 438 321 байт

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

Пояснение: А : используются для указания метки, которая так хорошо , как комментарий, так как программа имеет осевую симметрию единственное различие между этими двумя версиями есть какая из @линий первый, в этом случае либо leftили rightвыводятся перед сценарием выходы.

Я действительно пытался творчески перекрывать повернутые линии друг с другом, но моя попытка фактически закончилась с большей сеткой.

Редактировать: Сохранено 117 байтов благодаря @ ØrjanJohansen.

05AB1E (наследие) , 89 55 байтов

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

Очень простой подход. Выходы в полном нижнем регистре.

Попробуйте онлайн или попробуйте онлайн с отражением (каждый оборот одинаков).

Объяснение:

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

Перевернутый:

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

Посмотрите эту подсказку 05AB1E (раздел Как пользоваться словарем? ), Чтобы понять, почему '…¸есть "left"и 'ĩесть "right".

Stax , 131 байт

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

Запустите и отладьте его

Это «правильный» вариант.

Рунические чары , 116 байт

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

Попробуйте онлайн!

И поменял местами

Не совсем порт, но использовал ответ Post Left Garf Hunter's Klein 000 в качестве отправной точки, учитывая типичную почти совместимость двух языков (большинство команд одинаковы, а обтекание краев в Runic идентично Klein 000). Единственная проблема заключалась в том, что IP-адреса Кляйна всегда начинаются сверху слева, а рунические - нет. Таким образом ., все они являются частью исходного кода и по-прежнему рассматриваются как NOP Runic, в то время как как NOP, которые я должен был добавить как часть управления потоком.

Печать "left"во всех 4 поворотах и ​​в "right"зеркальном отображении (и во всех четырех поворотах). Две средние колонки были полностью не использованы после моих модификаций, поэтому я смог их удалить.

В теории вращение с большим количеством пробелов может использоваться для меньшего количества байтов (например, этот вариант ), однако пробелы необходимы для правильного вращения структуры с использованием внешних инструментов, и поэтому я включил их.

Варианты ниже содержат неиспользованные куски, которые были удалены, но в остальном идентичны:

Все четыре левых . Выходы leftleftleftleft(тот факт, что все четыре можно запустить таким образом, является совпадением).

Справа 1 , справа 2 , справа 3 , справа 4

Gol> <> , 342 байта

 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  

Вау! Это заняло больше времени, чем я ожидал, на полпути я понял, что отражение было вертикально , а не горизонтально, как я кодировал! Я уверен, что это работает, но если я допустил ошибку, пожалуйста, дайте мне знать. Скорее всего, это может быть игра в гольф на смешную сумму больше, я просто использовал метод грубой силы. Сама фигура на самом деле является квадратом, она технически симметрична, за исключением поперечной оси X, поэтому, когда она переворачивается, вместо нее возвращается «ВПРАВО» !!!

Символ, который сделал эту программу возможной, - «А», которая позволяет телепортироваться в начало определенной строки!

Попробуйте онлайн!