Một hình dạng là chirus nếu không có số lượng xoay có thể làm cho nó trông giống như hình ảnh phản chiếu của nó. Trong câu đố này, chúng tôi sẽ viết chương trình máy tính chirus.

Đối với câu đố này, chúng ta sẽ nghĩ về một chương trình như một ma trận hình chữ nhật của các ký tự. Vì vậy, tất cả các giải pháp cho thách thức này phải là hình chữ nhật (đó là tất cả các dòng phải có cùng độ dài). Chúng tôi có thể xoay các chương trình này theo gia số quý. Ví dụ chương trình

The quickish fish
    lept deftly  
  rightwards     

Khi xoay một phần tư lần lượt theo chiều kim đồng hồ trông giống như

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

Chúng tôi cũng có thể phản ánh các chương trình này. Đây là cùng một chương trình được phản ánh trên một trục dọc:

hsif hsikciuq ehT
  yltfed tpel    
    sdrawthgir   

Chương trình chirus là một chương trình mà khi được quay bất kỳ số lần nào sẽ luôn xuất ra " left". Tuy nhiên, khi được phản ánh sẽ tạo ra một chương trình xuất ra " right" bất kể nó được xoay bao nhiêu lần.

Nhiệm vụ của bạn là viết một chương trình chirus bằng càng ít byte càng tốt.

Quy tắc bổ sung

• Đầu ra không phải là trường hợp nhạy cảm nhưng nên nhất quán. (ví dụ: Bạn có thể xuất " LEFT" và " rIgHt" nhưng vỏ này phải nhất quán theo các phép quay)

• Các dòng sẽ được phân chia trên một dòng mới hoặc một dòng mới và một nguồn cấp dữ liệu.

• Chương trình của bạn phải là một hình chữ nhật, bạn có thể đệm nó bằng dấu cách hoặc nhận xét nhưng mỗi dòng phải có cùng độ dài.

• Bạn có thể tùy chọn có một dòng mới (hoặc dòng mới và nguồn cấp dữ liệu) trên tất cả các chương trình của bạn nếu bạn muốn.

Pascal (FPC) , 2161 755 349 byte

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

Hãy thử trái

Thử đúng

@tsh thúc đẩy tôi thử lại khi tôi thấy chương trình của anh ấy (trong phần bình luận) và đây rồi!

Cái trước có 755 byte:

 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 

Hãy thử trái

Thử đúng

Nếu bạn thấy bài nộp trước của tôi, hãy quên nó đi :)

Tất cả các phép quay cho cả chương trình bên trái và bên phải đều giống nhau.

Klein (000) , 109 87 byte

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

Hãy thử trực tuyến!

Nên có thể có được một phiên bản ngắn hơn của câu trả lời này để chúc may mắn!

Câu trả lời này được lấy cảm hứng từ xoắn ốc. Cụ thể, ý tưởng là hai hình xoắn ốc lồng vào nhau, một bên trái và một bên phải. Nó có hai đối xứng gấp, vì vậy chúng ta có thể kiểm tra các chương trình sau để biết nó hoạt động:

Quý rẽ

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

Hãy thử trực tuyến!

Nhân đôi

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

Hãy thử trực tuyến!

Nhân đôi và quý rẽ

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

Hãy thử trực tuyến!

Klein (000) , 27 25 byte

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

Hãy thử trực tuyến! Xoay một lần! Xoay hai lần! Xoay ba lần!

Và lật: Hãy thử trực tuyến! Xoay một lần! Xoay hai lần! Xoay ba lần!

Người duy nhất gây cho tôi một chút rắc rối là bị lật và xoay một lần, trông giống như:

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

Đây là lý do duy nhất cho hai bộ ((.

Klein (211) , 37 byte

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

Điều này có một chương trình khác nhau cho mỗi vòng quay.

Giải trình

Lưu ý rằng mỗi chương trình này được đệm vào một hình vuông không có op-op trước khi thực hiện

Không thay đổi

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

Hãy thử trực tuyến!

!làm cho việc thực thi nhảy qua \và "left"@tải chuỗi "left"vào ngăn xếp và chấm dứt chương trình in ngăn xếp

Quý rẽ

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

Hãy thử trực tuyến!

Thực thi chạy ra góc trên bên phải của hình vuông, tiếp tục ở góc dưới bên trái và một lần nữa !\"left"@in "left.

Nửa lượt

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

Hãy thử trực tuyến!

Ở đây, con đường hành quyết thoát ra từ phía Bắc, nhập lại qua phía Tây, thoát ra một lần nữa từ phía Đông Trước khi vào miền Nam. \trả lại đường dẫn "left"@để in nó

Lần lượt ba phần tư

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

Dùng thử trực tuyến

Thực thi thoát ra từ góc trên bên phải sau đó nhập lại ở phía dưới bên trái. Một lần nữa các gương /\chuyển hướng đường dẫn vào "left"@để in nó.

Suy tư

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

Điều này là rất cần thiết giống như cho trái trong tất cả các vòng quay.

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

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

Nhân đôi

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

Hãy thử trực tuyến!

(Vui lòng xem Liên kết TIO cho tất cả các trường hợp thử nghiệm, bao gồm cả phiên bản được nhân đôi)

Mặc dù chơi gôn nhiều hơn, kích thước 22x22 -> 21x21tín dụng của @JoKing!

Kích thước 38x38 24x24 22x22 21x21 18x18 17x17 16x16, đối xứng 4 lần.

Ở đây có một câu hỏi - có thể có 15x15 hoặc nhỏ hơn cho JS không? Dường như cái tôi cần ít nhất là dấu phân cách nhận xét giữa hai khối con và ở cạnh, vậy ít nhất 7 + 2 + 2 + 5 = 16 dòng?

Canvas , 109 89 71 byte

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

Dùng thử tại đây | Hãy thử đảo ngược! Đó là hai chương trình duy nhất có thể, vì chương trình này đối xứng xoay vòng.

Thực hiện trong này .

Gol> <> , 23 byte

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

Hãy thử trực tuyến!

Đây là định dạng giống như câu trả lời Klein của tôi , nhưng ngắn hơn 2 byte. Có lẽ có một ngôn ngữ 2D khác ngoài kia có thể đánh bại 2 byte cuối cùng đó ... Nhưng hiện tại, nó ngắn như nó có.

Alice , 25 byte

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

Trái: Bình thường , 1/4 lần lượt theo chiều kim đồng hồ , 1/2 lần lượt , 1/4 lần lượt ngược chiều kim đồng hồ

Phải: phản xạ qua trục ngang , đường chéo phải , trục dọc , đường chéo phải

Giải trình

Chương trình này có ba phần. Phần đầu tiên là ba {s và một }trên các góc. Lần {lượt IP trái sang cho đến khi đến }, tại điểm nó rẽ phải. Trong phiên bản được phản ánh, IP đi dọc theo hàng trên cùng trong chương trình gốc. Trong phiên bản gốc, rẽ phải sẽ ngay lập tức chạm vào liền kề {, chỉ IP dọc theo hàng dưới cùng trong chương trình gốc.

Tiếp theo là hai dấu gạch chéo trong cột thứ hai. Nếu chương trình được định hướng theo chiều ngang, một trong hai loại dấu gạch chéo sẽ chỉ chuyển sang chế độ thứ tự, gửi IP theo cùng hướng trái / phải mà nó đã đi. Nếu chương trình được định hướng theo chiều dọc, IP bị trả lại xung quanh khá nhiều, nhưng làm cho cả hai dấu gạch chéo về phía trước cho kết quả cuối cùng giống nhau. (Hai dấu gạch chéo ngược sẽ cho kết quả ngược lại và một trong số đó sẽ tạo ra một vòng lặp vô hạn.)

Phần còn lại của chương trình là đơn giản. IP ở chế độ thứ tự nảy theo đường chéo, do đó, "left"o@hoặc "right"o@sẽ được chạy tùy thuộc vào cách phần này được nhập.

Lục giác , 98 byte

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

Hãy thử trực tuyến! | Xoay 90 ° | Xoay 180 ° | Xoay 270 °
đảo ngược | Xoay 90 ° & đảo ngược | Xoay 180 ° & đảo ngược | Xoay 270 ° & đảo ngược

Hexagony là một niềm vui cho thử thách này, bởi vì một vòng quay hoặc đảo ngược có thể thay đổi mạnh mẽ chương trình thực tế. Mỗi Rotation / Reversal là chương trình độc đáo của riêng nó. Một số đường dẫn thực hiện chương trình thú vị hơn nhiều so với những đường dẫn khác.

Tôi sẽ thừa nhận rằng việc đưa ra điều này mất nhiều thời gian hơn nó có thể nên có. Tôi khá chắc chắn rằng một câu trả lời ngắn hơn có thể được thực hiện trong Hexagony, thật may mắn!

Ruby , 131 byte

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

Hãy thử trực tuyến!

APL (dzaima / APL) , 181 byte

Chương trình có tính đối xứng quay nên chỉ cần kiểm tra hai trường hợp

Trái

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

Hãy thử trực tuyến!

Đúng

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

Hãy thử trực tuyến!

Giải trình

Đây là chương trình APL đầu tiên của tôi nên khá đơn giản. Nó chỉ sử dụng một mẹo mà tôi nghĩ là thú vị.

Nếu chúng tôi bắt đầu bằng cách tước đi tất cả các ý kiến, chúng tôi sẽ nhận được các chương trình sau

Trái

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

Đúng

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

Bắt đầu từ chương trình bên trái, chúng tôi làm ba việc.

1. Gán 'lef'cho biếnt

2. In biến tvà chữ't'

3. Gán 'righ'cho biếnt

Bây giờ bởi vì nó là tấm gương, chương trình phù hợp thực hiện ba bước này nhưng theo thứ tự ngược lại. Điều này có nghĩa là chúng tôi in 'left'cho chương trình bên trái và 'right'cho chương trình bên phải.

Một mẹo ở đây là 't'thực sự đến từ một bản sao được xoay của mã. Nếu bạn nhìn vào cột thứ ba của mã của chúng tôi, bạn sẽ thấy rằng nó là 't'. Chúng tôi sử dụng lại điều này 't'trong các phiên bản xoay để nối thêm những tthứ cần thiết.

Haskell , 461 379 byte

82 byte được lưu bởi Ø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----------_--

Hãy thử trực tuyến!

Vì cái này có đối xứng 4 lần, bạn chỉ cần kiểm tra gương:

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

Hãy thử trực tuyến!

Đây là một sự khởi đầu. Nó là xa lý tưởng, nhưng có một vài điều thú vị đang diễn ra ở đây. Haskell chắc chắn là một ngôn ngữ thú vị cho thử thách này. Tôi mong chờ một câu trả lời rằng đây là của tôi hoặc của người khác.

Prolog (SWI) , 649 188 byte

Không bị lật, không được bảo vệ

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

Hãy thử trực tuyến!

Không bị lật, xoay

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

Hãy thử trực tuyến!

Lật, không bảo vệ

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

Hãy thử trực tuyến!

Lật, xoay

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

Hãy thử trực tuyến!

Prolog (SWI) , 239 223 209 181 byte

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

Hãy thử trực tuyến!

Vì chương trình có đối xứng 4 lần, bạn chỉ cần kiểm tra gương:

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

Hãy thử trực tuyến!

Python 2 , 209 byte (14 x 14)

Bình thường (trái):

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

Hãy thử trực tuyến!

Phản ánh (phải):

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

Hãy thử trực tuyến!

Sạch , 1331 1055 byte

-276 byte nhờ Ø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//////////// //
// ///////////;/;//////////// //

Hãy thử "trái" trực tuyến!

Hãy thử "đúng" trực tuyến!

Điều này thật khó khăn vì nhiều lý do:

• Clean yêu cầu một tiêu đề tệp module <filename>có mặt khi bắt đầu và chỉ bắt đầu tệp. Thật không may, điều này có nghĩa là để các phép quay của chương trình được nhân đôi có hiệu lực, nó cũng phải xuất hiện ở dưới cùng của tệp. Để làm cho điều này tồi tệ hơn, module ..là không hợp lệ cho toàn cầu let .. in, where ..và with ..định nghĩa; và mã thông báo modulexuất hiện nếu nó chưa được xác định gây ra lỗi.
• Cả hai bình luận khối và bình luận dòng lồng nhau: /* /* */để lại một mức độ bình luận mở, và cũng vậy /* // */(cũng như bình luận phần còn lại của dòng ra).
• Hàm tương tự có thể được định nghĩa nhiều lần, nhưng chỉ trực tiếp sau chính nó.

May mắn thay, chúng ta có thể định nghĩa modulelà một cái gì đó trong một #..biểu thức (cho phép trước), đó là tất cả những gì chúng ta cần. Vì Clean không kiểm tra các lựa chọn thay thế không bao giờ được sử dụng (và nhiều thứ khác không được sử dụng), định nghĩa thứ hai cần thiết Startcó thể là rác hoàn chỉnh. Điều này cho phép chúng tôi sử dụng cái thứ hai Startđể sử dụng tiêu đề mô-đun ở dưới cùng của tệp vì Clean xử lý m module mnhư gọi hàm mtrên modulevà m(do chúng tôi đã xác định modulevà mkhông gây ra lỗi). Nó không quan trọng đó mlà một chuỗi và không phải là một hàm, bởi vì sự Startthay thế không bao giờ được kiểm tra kiểu.

Điều này dễ nhìn hơn nếu bạn nhìn nó qua đôi mắt của nhà soạn nhạc:

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

Brachylog , 341 byte

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

Hãy thử trực tuyến!

! enilno ti yrT

Tận dụng lợi thế của Brachylog lấy vị từ chính là dòng trên dòng đầu tiên và không quan tâm nhiều đến các dòng khác ngoài yêu cầu chúng có thể biên dịch. Không bị phản hồi, nó in một chuỗi trống theo sau là "trái" trên cùng một dòng và phản ánh nó in một chuỗi trống theo sau là "phải" trên cùng một dòng. Tôi muốn nghĩ rằng có thể có một cách để tạo ra một phiên bản không vuông (hữu ích) bằng cách sử dụng ṇ, nhưng điều đó có thể rất khó khăn mà không cố gắng làm cho nó hoạt động khác đi dưới sự phản chiếu.

Ruby , 181 byte

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

Hãy thử trực tuyến!

Đây là một câu trả lời Python của Curtis Bechtel cho Ruby, đánh gôn thêm một chút.

Trên thực tế, chương trình Python của anh ấy là một polyglot và cũng chạy trên Ruby, vì vậy câu trả lời đầu tiên của tôi là một bản sao của nó, nhưng nó có vẻ không công bằng. Vì vậy, tôi đã viết một kịch bản tạo ra một câu trả lời mới bắt đầu từ một kịch bản cơ sở. Bạn có thể thử nó ở đây:

Xây dựng của riêng bạn

Hàng loạt, 438 321 byte

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

Giải thích: A :được sử dụng để chỉ nhãn, cũng tốt như một nhận xét, do đó chương trình có tính đối xứng xoay, sự khác biệt duy nhất giữa hai phiên bản là @dòng đầu tiên, trong trường hợp này lefthoặc rightlà đầu ra trước tập lệnh lối thoát hiểm

Tôi đã cố gắng sáng tạo chồng chéo các đường xoay với nhau nhưng nỗ lực của tôi thực sự đã kết thúc với một lưới lớn hơn.

Chỉnh sửa: Đã lưu 117 byte nhờ @ janrjanJohansen.

05AB1E (di sản) , 89 55 byte

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

Cách tiếp cận rất cơ bản. Đầu ra viết thường.

Hãy thử trực tuyến hoặc thử trực tuyến phản ánh (mỗi vòng quay là như nhau).

Giải trình:

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

Đảo ngược:

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

Xem mẹo 05AB1E này của tôi (phần Làm thế nào để sử dụng từ điển? ) Để hiểu tại sao '…¸là "left"và 'ĩlà "right".

Stax , 131 byte

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

Chạy và gỡ lỗi nó

Đây là biến thể "đúng".

Runic bùa mê , 116 byte

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

Hãy thử trực tuyến!

Và đảo ngược

Không chính xác là một cổng, nhưng sử dụng câu trả lời Klein 000 của Post Left Garf Hunter làm điểm bắt đầu, với khả năng tương thích gần như điển hình của hai ngôn ngữ (hầu hết các lệnh đều giống nhau và cách gói cạnh trong Runic giống hệt với Klein 000). Vấn đề duy nhất là IP Klein luôn bắt đầu từ trên cùng bên trái và Runic thì không. Như vậy, .tất cả đều là một phần của mã gốc và vẫn được coi là NOP bởi Runic, trong khi đó là các NOP mà tôi phải thêm vào như một phần của việc kiểm soát luồng.

In "left"trong cả 4 lần quay và "right"khi được nhân đôi (và trong cả bốn lần quay của chúng). Hai cột giữa hoàn toàn không được sử dụng sau khi sửa đổi, vì vậy tôi có thể xóa chúng.

Về lý thuyết, một phép quay có nhiều khoảng trắng theo sau có thể được sử dụng cho số byte thấp hơn (ví dụ: biến thể này ), tuy nhiên, cần có các khoảng trống để xoay chính xác cấu trúc bằng các công cụ bên ngoài và vì vậy tôi đã đưa chúng vào.

Các biến thể bên dưới chứa các đoạn không sử dụng đã bị xóa, nhưng lại giống hệt nhau:

Cả bốn tay trái . Đầu raleftleftleftleft (thực tế là cả bốn có thể được chạy như thế này là trùng hợp).

Phải 1 , Phải 2 , Phải 3 , Phải 4

Gol> <> , 342 byte

 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  

Ồ Mất nhiều thời gian hơn tôi mong đợi, nửa chừng tôi nhận ra sự phản chiếu là theo chiều dọc chứ không phải theo chiều ngang như tôi đã mã hóa! Tôi khá chắc chắn rằng điều này hoạt động, nhưng nếu tôi mắc lỗi xin vui lòng cho tôi biết. Điều này rất có thể được đánh golf nhiều hơn một cách vô lý, tôi chỉ cần thực hiện một phương pháp vũ phu cực đoan để làm như vậy. Hình dạng chính nó thực sự là một hình vuông, nó đối xứng về mặt kỹ thuật, ngoại trừ trên trục x, vì vậy khi lật, nó trả về "QUYỀN" thay vào đó !!!

Nhân vật làm cho chương trình này trở nên khả thi là 'A', cho phép dịch chuyển tức thời đến đầu một dòng nhất định!

Hãy thử trực tuyến!