如果没有任何旋转量，形状看起来像镜像，则该形状是手性的。在这个难题中，我们将编写手性计算机程序。

对于这个难题，我们将程序视为字符的矩形矩阵。因此，应对这一挑战的所有解决方案都必须是矩形的（也就是说，所有线的长度必须相同）。我们可以按四分之一圈的增量旋转这些程序。例如程序

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”，但此大小写在旋转下必须保持一致）

• 行将在换行符或换行符和换行符之间进行拆分。

• 您的程序必须是矩形，可以用空格或注释填充它，但每一行的长度必须相同。

• 如果需要，您可以选择在所有程序上使用尾随换行符（或换行符和换行符）。

Pascal（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链接，包括镜像版本）

尽管进一步打高尔夫球，但@JoKing的尺寸22x22 -> 21x21值得信赖！

尺寸38x38 24x24的 22×22 21×21 18×18 17×17 16×16，4倍对称。

这是一个问题-JS的尺寸可能为15x15或更小吗？看来我至少需要两个子块之间以及边缘处的注释分隔符，因此至少需要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\

在线尝试！

此格式与我的Klein答案相同，但短2个字节。也许还有另一种2D语言可以打高尔夫球的最后2个字节……但是就目前而言，它已经变得很短了。

爱丽丝，25个字节

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

左：正常，顺时针1/4圈，1/2圈，逆时针1/4圈

右：反映跨越水平轴，下右对角线，垂直轴，右上方对角线

说明

该程序分为三个部分。第一部分是三个{s，一个}在角落。该{转的IP离开，直到它到达}，此时它向右转。在反射版本中，IP沿原始程序的第一行。在原始版本中，向右转会立即击中相邻{的IP地址，使IP沿原始程序的底部行指向。

接下来是第二列中的两个斜杠。如果程序是水平定向的，则任何一种斜杠都将简单地更改为顺序模式，以与已经使用的相同的左右方向发送IP。如果程序是垂直定向的，则IP会反弹很多，但是使它们都使用正斜杠将得到相同的最终结果。（两个反斜杠将产生相反的结果，每个反斜杠将产生一个无限循环。）

该程序的其余部分很简单。顺序模式下的IP沿对角线方向跳动，因此"left"o@或"right"o@将根据该部分的输入方式运行。

六角形，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°，反转

六边形对于这种挑战很有趣，因为旋转或反转可以大大改变实际程序。每个旋转/反转都是其自己的独特程序。一些程序执行路径比其他一些有趣。

我承认，提出此建议所花费的时间可能超过了原本应该的时间。我很确定可以在Hexagony中做一个简短的回答，祝您好运！

红宝石，131字节

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

在线尝试！

APL（dzaima / 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所需的代码。

哈斯克尔，461个 379字节

ØrjanJohansen保存了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对于这一挑战无疑是一种有趣的语言。无论是我的还是别人的，我都期待有一个比这更好的答案。

Prolog（SWI），649188字节

不翻转，不旋转

:-%    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 x 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字节归功于ØrjanJohansen

// ////////////;/;/////////// //
// ////////////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为#..（before-before）表达式中的某些内容。因为Clean不会类型检查从未使用过的替代方法（以及其他各种未使用的事物），所以必需的第二个定义Start可以是完全垃圾。这使我们可以使用第二个Start来消耗文件底部的模块头，因为Clean视为在和上m module m调用函数（由于我们已经定义了和，因此不会引起错误）。没关系是字符串而不是函数，因为替代方法永远不会进行类型检查。mmodulemmodulemmStart

如果从编译器的角度来看，这更容易看清：

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

Brachylog，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 ti 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#########

在线尝试！

这是柯蒂斯·贝克特尔（Curtis Bechtel）对Ruby的Python回答的一部分，但使用了更多技巧。

实际上，他的Python程序是多语言的，并且也可以在Ruby上运行，所以我的第一个答案是将其复制粘贴，但似乎不公平。因此，我编写了一个脚本，该脚本从基本脚本开始生成新的答案。您可以在这里尝试：

建立你自己的

批处理，438321字节

:::::::::::::@@@:
@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输出该脚本之前退出。

我确实尝试过将旋转的线条彼此创造性地重叠，但是实际上我的尝试最终得到了更大的网格。

编辑：由于@ØrjanJohansen，节省了117个字节。

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的Klein 000答案作为起点（大多数命令是相同的，并且在符文中的边换行与Klein 000相同）。唯一的问题是，克莱因（Klein）IP总是从左上角开始，而符文（Runic）则不是。因此，.所有这些都是原始代码的一部分，仍然被Runic视为NOP，而我必须添加的NOP作为控制流程的一部分。

"left"在所有4个旋转中以及"right"在镜像时（及其所有4个旋转中）打印。修改后，中间的两个列完全未使用，因此可以删除它们。

从理论上讲，可以使用带有大量尾随空格的旋转来减少字节数（例如，此变体），但是需要使用空格来使用外部工具正确旋转结构，因此我将它们包括在内。

以下变体包含已删除但未使用的未使用的块：

所有四个左。输出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轴上，因此在翻转时会返回“ RIGHT”！

使该程序成为可能的字符是“ A”，它允许传送到特定行的开头！

在线尝试！