Bentuk adalah kiral jika tidak ada jumlah rotasi yang membuatnya tampak seperti gambar cermin. Dalam teka-teki ini kita akan menulis program komputer kiral.

Untuk puzzle ini kita akan menganggap sebuah program sebagai matriks karakter persegi panjang. Karena itu, semua solusi untuk tantangan ini harus berbentuk persegi panjang (yaitu semua garis harus memiliki panjang yang sama). Kita dapat memutar program-program ini dalam peningkatan seperempat putaran. Misalnya programnya

The quickish fish
    lept deftly  
  rightwards     

Ketika diputar seperempat putaran searah jarum jam terlihat seperti

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

Kami juga dapat mencerminkan program-program ini. Berikut adalah program yang sama tercermin pada sumbu vertikal:

hsif hsikciuq ehT
  yltfed tpel    
    sdrawthgir   

Program kiral adalah program yang ketika diputar berapa kali akan selalu menghasilkan " left". Namun ketika direfleksikan menghasilkan program yang menghasilkan " right" tidak peduli berapa kali ia diputar.

Tugas Anda adalah menulis program chiral dalam beberapa byte mungkin.

Aturan tambahan

• Keluaran tidak peka huruf besar-kecil tetapi harus konsisten. (mis. Anda dapat menampilkan " LEFT" dan " rIgHt" tetapi casing ini harus konsisten di bawah rotasi)

• Garis harus dipisah pada baris baru atau baris baru dan baris baris.

• Program Anda harus berbentuk persegi panjang, Anda dapat menambahkannya dengan spasi atau komentar tetapi setiap baris harus memiliki panjang yang sama.

• Secara opsional, Anda dapat memiliki baris tambahan (atau baris baru dan umpan baris) pada semua program Anda jika diinginkan.

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

Coba ke kiri

Coba yang benar

@ tsh memotivasi saya untuk mencoba lagi ketika saya melihat programnya (dalam komentar) dan ini dia!

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

Coba ke kiri

Coba yang benar

Jika Anda melihat kiriman saya sebelumnya, lupakan saja :)

Semua rotasi untuk program kiri dan kanan adalah sama.

Klein (000) , 109 87 byte

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

Cobalah online!

Seharusnya dimungkinkan untuk mendapatkan versi yang lebih pendek dari jawaban ini, semoga berhasil!

Jawaban ini terinspirasi oleh spiral. Secara khusus idenya adalah dua spiral yang saling bertautan, satu untuk kiri dan satu untuk kanan. Ini memiliki dua simetri lipat, Jadi kita dapat memeriksa program-program berikut untuk mengetahui kerjanya:

Perempat putaran

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

Cobalah online!

Dicerminkan

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

Cobalah online!

Cermin dan Perempat putaran

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

Cobalah online!

Klein (000) , 27 25 byte

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

Cobalah online! Diputar sekali! Diputar dua kali! Diputar tiga kali!

Dan membalik: Coba online! Diputar sekali! Diputar dua kali! Diputar tiga kali!

Satu-satunya yang memberi saya sedikit masalah adalah yang terbalik dan diputar sekali, yang terlihat seperti:

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

Ini adalah satu-satunya alasan untuk dua set ((.

Klein (211) , 37 byte

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

Ini memiliki program yang berbeda untuk setiap rotasi.

Penjelasan

Perhatikan bahwa masing-masing program ini diisi ke kotak dengan no-ops sebelum eksekusi

Tidak ada perubahan

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

Cobalah online!

!membuat eksekusi melompati \dan "left"@memuat string "left"ke stack dan mengakhiri program pencetakan stack

Perempat putaran

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

Cobalah online!

Eksekusi berjalan dari sudut kanan atas alun-alun, berlanjut di sudut kiri bawah dan sekali lagi !\"left"@dicetak "left.

Setengah putaran

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

Cobalah online!

Di sini, jalur eksekusi keluar dari sisi Utara, masuk kembali melalui sisi Barat, keluar lagi dari Timur Sebelum masuk di selatan. \memantulkan jalur ke "left"@untuk mencetaknya.

Giliran tiga perempat

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

Cobalah online

Eksekusi keluar dari sudut kanan atas kemudian masuk kembali di kiri bawah. Sekali lagi mirror /\mengarahkan jalur ke "left"@untuk mencetaknya.

Refleksi

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

Ini pada dasarnya sama dengan yang tersisa di semua rotasi.

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/

Dicerminkan

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

Cobalah online!

(Silakan lihat TIO Link untuk semua kasus uji, termasuk versi cermin)

Meskipun lebih lanjut 22x22 -> 21x21bermain golf , ukuran kredit @JoKing!

Ukuran 38x38 24x24 22x22 21x21 18x18 17x17 16x16, simetri 4 kali lipat.

Ada pertanyaan - apakah mungkin untuk memiliki 15x15 atau lebih kecil untuk JS? Tampaknya yang paling saya butuhkan adalah pemisah komentar antara dua sub-blok dan di tepi, jadi setidaknya 7 + 2 + 2 + 5 = 16 baris?

Kanvas , 109 89 71 byte

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

Coba di sini | Coba dibalik! Hanya ada dua program yang mungkin, karena program ini simetris secara rotasi.

Dibuat dalam hal ini .

Gol> <> , 23 byte

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

Cobalah online!

Ini adalah format yang sama dengan jawaban Klein saya , tetapi 2 byte lebih pendek. Mungkin ada bahasa 2D lain di luar sana yang dapat melepaskan 2 byte terakhir ... Tapi untuk saat ini, ini sesingkat mungkin.

Alice , 25 byte

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

Kiri: Normal , 1/4 putaran searah jarum jam , 1/2 putaran , 1/4 putaran berlawanan arah jarum jam

Kanan: merefleksikan sumbu horizontal , diagonal kanan bawah , sumbu vertikal , diagonal kanan atas

Penjelasan

Program ini memiliki tiga bagian. Bagian pertama adalah tiga {dan satu }di sudut. The {gilirannya IP kiri sampai mencapai }, di mana titik itu ternyata benar. Dalam versi yang direfleksikan, IP berada di baris paling atas dalam program asli. Pada versi asli, berbelok ke kanan akan langsung menekan yang berdekatan {, mengarahkan IP di sepanjang baris bawah dalam program asli.

Berikutnya adalah dua garis miring di kolom kedua. Jika program berorientasi horizontal, salah satu jenis slash hanya akan berubah ke mode ordinal, mengirimkan IP dalam arah kiri / kanan yang sama dengan yang sudah berjalan. Jika program ini berorientasi vertikal, IP memantul sedikit lebih banyak, tetapi membuat keduanya memajukan garis miring memberikan hasil akhir yang sama. (Dua garis miring terbalik akan memberikan hasil yang berlawanan, dan masing-masing akan menciptakan loop tak terbatas.)

Sisa dari program ini sangat mudah. IP dalam mode ordinal memantul secara diagonal, sehingga salah satu "left"o@atau "right"o@akan dijalankan tergantung pada bagaimana bagian ini dimasukkan.

Hexagony , 98 byte

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

Cobalah online! | Diputar 90 ° | Diputar 180 ° | Diputar 270 °
Terbalik | Diputar 90 ° & Terbalik | Diputar 180 ° & Terbalik | Diputar 270 ° & Terbalik

Hexagony menyenangkan untuk tantangan ini, karena rotasi atau pembalikan dapat secara drastis mengubah program yang sebenarnya. Setiap Rotasi / Pembalikan adalah program uniknya sendiri. Beberapa jalur eksekusi program jauh lebih menarik daripada yang lain.

Aku akan mengakui bahwa untuk menyelesaikan ini butuh waktu lebih lama daripada yang seharusnya. Saya cukup yakin jawaban yang lebih singkat dapat dilakukan di Hexagony, semoga beruntung!

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

Cobalah online!

APL (dzaima / APL) , 181 byte

Program ini memiliki simetri rotasi sehingga hanya dua kasus yang perlu diperiksa

Kiri

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

Cobalah online!

Baik

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

Cobalah online!

Penjelasan

Ini adalah program APL pertama saya jadi sangat sederhana. Hanya menggunakan satu trik yang menurut saya menarik.

Jika kita mulai dengan menghilangkan semua komentar kita mendapatkan program berikut

Kiri

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

Baik

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

Mulai dari program kiri kami melakukan tiga hal.

1. Tetapkan 'lef'ke variabelt

2. Cetak variabel tdan suratnya't'

3. Tetapkan 'righ'ke variabelt

Sekarang karena itu adalah program yang tepat cermin melakukan tiga langkah ini tetapi dalam urutan yang berlawanan. Ini berarti kami mencetak 'left'untuk program kiri dan 'right'untuk program kanan.

Satu trik di sini adalah bahwa 't'sebenarnya berasal dari salinan kode yang diputar. Jika Anda melihat kolom ketiga kode kami, Anda akan melihatnya 't'. Kami menggunakan kembali ini 't'dalam versi yang dirotasi untuk menambahkan tyang diperlukan.

Haskell , 461 379 byte

82 byte disimpan oleh Ø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----------_--

Cobalah online!

Karena yang ini memiliki simetri 4 kali lipat, Anda hanya perlu menguji cermin:

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

Cobalah online!

Ini awal. Ini jauh dari ideal, tetapi ada beberapa hal menarik yang terjadi di sini. Haskell jelas merupakan bahasa yang menarik untuk tantangan ini. Saya menantikan jawaban yang mengalahkan ini baik milik saya atau milik orang lain.

Prolog (SWI) , 649 188 byte

Tidak diputar, Tidak diputar

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

Cobalah online!

Tidak Diputar, Diputar

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

Cobalah online!

Terbalik, Tidak diputar

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

Cobalah online!

Terbalik, Diputar

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

Cobalah online!

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

Cobalah online!

Karena program memiliki 4 simetri lipat, Anda hanya perlu memeriksa cermin:

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

Cobalah online!

Python 2 , 209 byte (14 x 14)

Normal (kiri):

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

Cobalah online!

Tercermin (kanan):

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

Cobalah online!

Bersih , 1331 1055 byte

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

Coba "kiri" online!

Coba "benar" secara online!

Ini sulit karena banyak alasan:

• Bersihkan membutuhkan header file module <filename>hadir di awal, dan hanya di awal file. Sayangnya, ini berarti agar rotasi dari program yang dicerminkan valid, itu juga harus muncul di bagian bawah file. Untuk memperburuk ini, module ..tidak valid untuk global let .. in,, where ..dan with ..definisi; dan token yang modulemuncul jika belum didefinisikan menyebabkan kesalahan.
• Baik komentar blok dan komentar baris: /* /* */membiarkan satu tingkat komentar terbuka, dan begitu juga /* // */(juga mengomentari sisa baris lainnya).
• Fungsi yang sama dapat didefinisikan beberapa kali, tetapi hanya secara langsung setelah itu sendiri.

Untungnya, kita dapat mendefinisikan modulesebagai sesuatu dalam #..ekspresi (sebelum) yang kita butuhkan. Karena Clean tidak mengetik-periksa alternatif yang tidak pernah digunakan (dan berbagai hal lain yang sama sekali tidak digunakan), definisi kedua yang diperlukan dari Startbisa menjadi sampah lengkap. Hal ini memungkinkan kita untuk menggunakan kedua Startuntuk mengkonsumsi header modul di bagian bawah file karena memperlakukan Bersih m module mseperti memanggil fungsi mpada moduledan m(yang karena kita telah mendefinisikan moduledan m, tidak menyebabkan kesalahan). Tidak masalah itu madalah string dan bukan fungsi, karena Startalternatif tidak pernah diperiksa jenisnya.

Ini lebih mudah dilihat jika Anda melihatnya melalui mata kompiler:

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Ẹ

Cobalah online!

! enilno ti thn

Mengambil keuntungan dari Brachylog mengambil predikat utama untuk menjadi yang ada di baris pertama dan tidak terlalu peduli dengan jalur lain di luar mengharuskan mereka dapat dikompilasi. Tidak direfleksikan, ia mencetak string kosong diikuti oleh "kiri" pada baris yang sama, dan memantulkannya mencetak string kosong diikuti oleh "kanan" pada baris yang sama. Saya tergoda untuk berpikir mungkin ada cara untuk membuat versi non-square (bermanfaat) menggunakan ṇ, tetapi itu mungkin banyak rumit tanpa mencoba membuatnya bekerja secara berbeda di bawah refleksi.

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

Cobalah online!

Ini adalah port jawaban Python Curtis Bechtel untuk Ruby, bermain golf lebih banyak.

Sebenarnya, program Python-nya adalah polyglot dan berjalan di Ruby juga, jadi jawaban pertama saya adalah salin-tempelnya, tetapi sepertinya tidak adil. Jadi saya menulis skrip yang menghasilkan jawaban baru mulai dari skrip dasar. Anda dapat mencobanya di sini:

Bangun sendiri

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

Penjelasan: A :digunakan untuk menunjukkan label, yang sebagus komentar, sehingga program memiliki simetri rotasi, satu-satunya perbedaan antara dua versi adalah @baris mana yang lebih dulu, dalam hal ini salah satu leftatauright merupakan output sebelum skrip keluar.

Saya memang mencoba secara kreatif tumpang tindih garis yang diputar satu sama lain tetapi usaha saya benar-benar berakhir dengan grid yang lebih besar.

Sunting: Disimpan 117 byte berkat @ ØrjanJohansen.

05AB1E (legacy) , 89 55 byte

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

Pendekatan yang sangat mendasar. Output dalam huruf kecil penuh.

Cobalah secara online atau coba tercermin secara online (setiap rotasi adalah sama).

Penjelasan:

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

Terbalik:

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

Lihat tip tambang 05AB1E ini (bagian Cara menggunakan kamus? ) Untuk memahami mengapa '…¸ini "left"dan 'ĩitu "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. 

Jalankan dan debug itu

Ini adalah varian "benar".

Pesona Rise , 116 byte

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

Cobalah online!

Dan terbalik

Tidak persis port, tetapi digunakan jawaban Kiri Kiri Garf Hunter's Klein 000 sebagai titik awal, mengingat kompatibilitas hampir khas dari dua bahasa (kebanyakan perintah adalah sama dan tepi pembungkus dalam Runic identik dengan Klein 000). Satu-satunya masalah adalah Klein IP selalu mulai dari kiri atas dan Runic tidak. Karena itu .semua adalah bagian dari kode asli dan masih diperlakukan sebagai NOP oleh Runic, sedangkan NOP adalah saya harus menambahkan sebagai bagian dari mengendalikan aliran.

Mencetak "left"di semua 4 rotasi dan"right" ketika dicerminkan (dan dalam keempat rotasi tersebut). Dua kolom tengah sama sekali tidak digunakan setelah modifikasi saya, jadi saya bisa menghapusnya.

Secara teori, rotasi dengan banyak spasi spasi tambahan dapat digunakan untuk jumlah byte yang lebih rendah (mis. Varian ini ), namun ruang diperlukan untuk memutar struktur dengan benar menggunakan alat eksternal dan jadi saya memasukkannya.

Varian di bawah ini berisi potongan yang tidak digunakan yang dihapus, tetapi sebaliknya identik:

Keempat kiri . Keluaran leftleftleftleft(fakta bahwa keempatnya dapat dijalankan seperti ini adalah kebetulan).

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

Wow! Itu membutuhkan waktu lebih lama daripada yang saya harapkan, di tengah jalan saya menyadari bahwa refleksi itu secara vertikal , tidak secara horizontal seperti yang saya lakukan sebelumnya! Saya cukup yakin ini berhasil, tetapi jika saya membuat kesalahan, tolong beri tahu saya. Ini kemungkinan besar bisa bermain golf dalam jumlah yang lebih konyol, saya hanya mengambil metode brute force yang ekstrim untuk melakukannya. Bentuknya sendiri sebenarnya adalah bujur sangkar, secara teknis simetris, kecuali pada sumbu x, jadi ketika terbalik, ia mengembalikan "KANAN" sebagai gantinya !!!

Karakter yang memungkinkan program ini adalah 'A', yang memungkinkan teleportasi ke awal baris tertentu!

Cobalah online!