Bir döndürme miktarı, ayna görüntüsü gibi görünmesini sağlayamazsa , şekil şiraldir . Bu yapbozda kiral bilgisayar programları yazacağız.

Bu yapboz için bir programı karakterlerin dikdörtgen matrisi olarak düşüneceğiz. Bu nedenle, bu zorluğa yönelik tüm çözümler dikdörtgen olmalıdır (tüm satırlar aynı uzunlukta olmalıdır). Bu programları çeyrek tur artışlarla döndürebiliriz. Örneğin program

The quickish fish
    lept deftly  
  rightwards     

Çeyrek dönüş saat yönünde döndürüldüğünde

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

Bu programları da yansıtabiliriz. Dikey eksen üzerinde yansıyan aynı program:

hsif hsikciuq ehT
  yltfed tpel    
    sdrawthgir   

Kiral program, herhangi bir sayıda döndürüldüğünde her zaman " left" çıktısını alacağı bir programdır . Ancak yansıyan, rightkaç kez döndürüldüğü önemli değil, " " çıktı veren bir program üretir .

Göreviniz, mümkün olduğu kadar az bayt cinsinden kiral bir program yazmaktır.

Ek Kurallar

• Çıktı büyük / küçük harf duyarlı değildir, ancak tutarlı olmalıdır. (örneğin, " LEFT" ve " rIgHt" çıktısını alabilirsiniz, ancak bu muhafaza rotasyonlar altında tutarlı olmalıdır)

• Satırlar ya yeni bir satırda ya da yeni bir satırda ve bir satır beslemesinde bölünür.

• Programınız bir dikdörtgen olmalı, boşluk ya da yorumlar ile doldurabilirsiniz, ancak her satır aynı uzunlukta olmalıdır.

• İsterseniz isteğe bağlı olarak tüm programlarınızda takip eden bir yeni satır (veya yeni satır ve satır besleme) olabilir.

Pascal (FPC) , 2161 755 349 bayt

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

Sola git

Doğru dene

@tsh programı (yorumda) gördüğümde tekrar denemek için beni motive etti ve işte burada!

755 bayt olan önceki:

 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 

Sola git

Doğru dene

Eğer önceki gönderimi görürseniz, unut gitsin :)

Hem sol hem de sağ programlar için tüm rotasyonlar aynıdır.

Klein (000) , 109 87 bayt

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

Çevrimiçi deneyin!

Bu cevabın daha kısa bir versiyonunu almak mümkün olmalı, bu yüzden iyi şanslar!

Bu cevap, spirallerden esinlenmiştir. Özellikle fikir, biri birbirine sol, diğeri de sağ olmak üzere birbirine kenetlenmiş iki spiraldir. İki katlı simetriye sahiptir, yani çalıştığını bilmek için aşağıdaki programları kontrol edebiliriz:

Çeyrek dönüş

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

Çevrimiçi deneyin!

Yansıtmalı

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

Çevrimiçi deneyin!

Yansıtılmış ve Çeyrek dönüş

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

Çevrimiçi deneyin!

Klein (000) , 27 25 bayt

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

Çevrimiçi deneyin! Bir kez döndürülmüş! İki kez döndürülmüş! Üç kez döndürülmüş!

Ve saygısız: Çevrimiçi deneyin! Bir kez döndürülmüş! İki kez döndürülmüş! Döndürülmüş üç kere!

Bana biraz sıkıntı veren tek şey, bir kere çevrilmiş ve döndürülmüş gibiydi:

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

İki setin tek nedeni bu ((.

Klein (211) , 37 bayt

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

Bunun her dönüş için farklı bir programı var.

açıklama

Bu programların her birinin yürütmeden önce çalışmayan bir kareye yattığına dikkat edin.

Değişiklik yok

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

Çevrimiçi deneyin!

!yürütmeyi atlatır \ve "left"@dizeyi "left"yığına yükler ve yığını yazdırma programını sonlandırır

Çeyrek dönüş

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

Çevrimiçi deneyin!

İşlem karenin sağ üst köşesinden geçer, sol alt köşede devam eder ve bir kez daha !\"left"@yazdırır "left.

Yarım dönüş

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

Çevrimiçi deneyin!

Burada yürütme yolu kuzeyden, batıdan tekrar girer, tekrar güneyden, güneyden girmeden çıkar. yazdırmak \için yolu zıplar "left"@.

Üç çeyrek dönüş

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

Çevrimiçi deneyin

İşlem sağ üst köşeden çıkar ve sol alt köşeye tekrar girer. Aynalar bir kez daha yazdırmak /\için yolu yönlendirir "left"@.

yansıma

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

Bu esasında tüm rotasyonlarda sol ile aynıdır.

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

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

Yansıtmalı

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

Çevrimiçi deneyin!

(Yansıtılmış versiyon da dahil olmak üzere tüm test durumları için TIO Link’e bakınız)

Daha fazla golf oynamasına rağmen, büyüklük 22x22 -> 21x21 , @JoKing'in kredisi !

Boyut 38x38 24x24 22x22 21x21 18x18 17x17 16x16, 4 kat simetri.

İşte bir soru geliyor - JS için 15x15 veya daha küçük olması mümkün mü? En azından ihtiyacım olan şey, iki alt blok ile kenar arasındaki yorum ayırıcı, yani en az 7 + 2 + 2 + 5 = 16 satır mı?

Tuval , 109 89 71 bayt

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

Burada dene | Tersine dönmeyi dene!Program rotasyonel olarak simetrik olduğundan, bu iki olası programdır.

Made in bu .

Gol> <> , 23 bayt

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

Çevrimiçi deneyin!

Bu benim Klein cevabım aynı format , ancak 2 bayt daha kısa. Belki de orada son 2 byte'lık golf oynayabilecek başka bir 2D dili var ... Ama şimdilik, bu olabildiğince kısa.

Alice , 25 bayt

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

Sol: Normal , saat yönünde 1/4 tur , 1/2 tur , saat yönünün tersine 1/4 tur

Sağ: yatay eksen boyunca , aşağı doğru çapraz , dikey eksen , yukarı doğru çapraz

açıklama

Bu program üç bölümden oluşmaktadır. İlk bölüm, köşedeki üç {saniye ve bir bölüm }. {O ulaşana kadar dönüş IP sol }hangi doğru döner işaret. Yansıtılan sürümde IP, orijinal programdaki en üst satır boyunca ilerler. Orijinal versiyonda, sağa çevirmek derhal bitişikteki isabet eder {ve IP'yi orijinal programdaki alt satır boyunca işaret eder.

Sonraki ikinci sütunda iki eğik çizgi. Program yatay olarak yönlendirilirse, herhangi bir eğik çizgi türü sıralı moda geçer ve IP'yi halihazırdaki aynı sol / sağ yöne gönderir. Program dikey olarak yönlendirilirse, IP biraz daha seker, ancak her ikisini de eğik çizgi yapmak aynı sonuç verir. (İki ters eğik çizgi tam tersi bir sonuç verir ve her biri bir sonsuz döngü oluşturur.)

Programın geri kalanı basittir. Sıralı moddaki IP, çapraz olarak sekerek, bu bölümün nasıl girildiğine bağlı olarak ya çalışır ya "left"o@da "right"o@çalışır.

Altıgen , 98 bayt

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

Çevrimiçi deneyin! | 90 ° Döndürülmüş | 180 ° Döndürülmüş | Döndürülmüş 270 °
Ters | 90 ° Döndürülmüş ve Ters Çevirilmiş | Döndürülmüş 180 ° ve Ters Çevirildi | Döndürülmüş 270 ° ve Ters

Altıgenlik bu zorluk için biraz eğlenceliydi, çünkü bir rotasyon veya geri dönüş asıl programı büyük ölçüde değiştirebilir. Her Rotation / Reversal, kendine özgü bir programdır. Program yürütme yollarının bazıları diğerlerinden çok daha ilginç.

Bununla gelmenin muhtemelen olması gerekenden daha uzun sürdüğünü itiraf edeceğim. Hexagony'de daha kısa bir cevap verilebileceğinden eminim, çok iyi şanslar!

Ruby , 131 bayt

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

Çevrimiçi deneyin!

APL (dzaima / APL) , 181 bayt

Programın dönme simetrisi vardır, bu nedenle sadece iki durumun kontrol edilmesi gerekir

Ayrıldı

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

Çevrimiçi deneyin!

Sağ

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

Çevrimiçi deneyin!

açıklama

Bu benim ilk APL programım, bu yüzden oldukça basit. Sadece ilginç olduğunu düşündüğüm bir numara kullanıyor.

Tüm yorumları çıkarmaya başlarsak aşağıdaki programları alırız.

Ayrıldı

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

Sağ

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

Sol programdan başlayarak üç şey yaparız.

1. 'lef'Değişkene atat

2. Değişkeni tve mektubu yazdır't'

3. 'righ'Değişkene atat

Şimdi ayna olduğu için doğru program bu üç adımı ancak tersi sırayla yapıyor. Bu 'left', sol program için yazdırdığımız ve'right' doğru program için .

Buradaki tek numara, 't'aslında kodun döndürülmüş bir kopyasından gelmesidir. Kodumuzun üçüncü sütununa bakarsanız, bunun olduğunu göreceksiniz 't'. Bunu gerekli olanı 't'eklemek için döndürülmüş versiyonlarda tekrar kullanıyoruz t.

Haskell , 461 379 bayt

Ørjan Johansen tarafından kaydedilen 82 bayt

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

Çevrimiçi deneyin!

Bunun 4 katlı bir simetrisi olduğundan, aynayı test etmeniz yeterlidir:

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

Çevrimiçi deneyin!

Bu bir başlangıç. İdeal olmaktan uzak, ama burada olan birkaç ilginç şey var. Haskell bu meydan okuma için kesinlikle ilginç bir dil. Bunu benimkinin veya başkasınınki gibi yapan bir cevabı bekliyorum.

Prolog (SWI) , 649 188 bayt

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

Çevrimiçi deneyin!

Çevirilmemiş, Döndürülmüş

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

Çevrimiçi deneyin!

Döndürülmüş, Düzeltilmemiş

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

Çevrimiçi deneyin!

Döndürülmüş, Döndürülmüş

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

Çevrimiçi deneyin!

Prolog (SWI) , 239 223 209 181 bayt

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

Çevrimiçi deneyin!

Program 4 kat simetriye sahip olduğundan, yalnızca aynayı kontrol etmeniz gerekir:

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

Çevrimiçi deneyin!

Python 2,209 bayt (14 x 14)

Normal (sol):

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

Çevrimiçi deneyin!

Yansıyan (sağ):

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

Çevrimiçi deneyin!

Temiz , 1331 1055 bayt

-276 bayt Ørjan Johansen sayesinde

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

Çevrimiçi "sola" deneyin!

Çevrimiçi "doğru" deneyin!

Bu birçok nedenden dolayı zordu:

• Temiz gerektiren bir dosya başlığı module <filename>başlangıcında mevcut olabilir ve yalnızca başlangıç dosyasının. Ne yazık ki, bu yansıtılmış programın dönüşlerinin geçerli olması için dosyanın altında görünmesi gerektiği anlamına gelir. Daha da kötüsü yapmak module ..için global let .. in, where ..ve with ..tanımları geçersiz ; ve belirteçmodule tanımlanmamışsa beliren hataya neden olur.
• Hem blok yorumları hem de satır yorumları yuvası: /* /* */bir yorum düzeyini açık bırakır, vb. /* // */(Satırın geri kalanını yorumlamanın yanı sıra)
• Aynı işlev birden çok kez tanımlanabilir, ancak yalnızca doğrudan kendisinden sonra tanımlanabilir.

Neyse ki, olabilir tanımlamak modulebir de şey olarak #..hepimiz ihtiyacıdır (let-öncesi) ifadesi. Clean, hiç kullanılmamış alternatifleri (ve diğer eşit derecede kullanılmayan şeyleri) tip kontrolleri yapmadığından, gerekli ikinci tanımı Starttam çöp olabilir. Bu, ikinci işlevi Start, dosyanın üst kısmındaki modül başlığını tüketmek için kullanmamızı sağlar çünkü Temiz m module mişlevi çağırır.m yapar moduleve m(ki bu hata tanımlamamış moduleve mhataya yol açmaz). Bunun mbir dize ve bir işlev olduğu önemli değildir, çünkü Startalternatif hiçbir zaman kontrol edilmez .

Derleyicinin gözlerine bakarsanız görmek daha kolaydır:

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

Brachylog , 341 bayt

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

Çevrimiçi deneyin!

! enilno ti yrT

Brachylog, ana çizgiyi ilk satırda biri olarak seçip, derleyebilmelerini gerektirecek ötesinde diğer satırları çok fazla önemsemekten faydalanır. Beklenmeyen, boş bir dize ve ardından aynı satırda "sola" ve aynı çizgide "sağ" yazan bir yazı yazdırır. Kullanarak kare olmayan bir versiyonunu kullanmanın bir yolu olabileceğini düşünmeye cazip geliyorum ṇ, ancak bu, yansıma altında farklı şekilde çalışmasını sağlamaya çalışmaksızın çok zor olabilir.

Ruby , 181 bayt

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

Çevrimiçi deneyin!

Bu Curtis Bechtel'in Python'un Ruby'ye verdiği cevabın limanı, biraz daha golf oynadı.

Aslında, Python programı bir çok dilli ve Ruby'de de çalışıyor, bu yüzden ilk cevabım bunun bir kopyasıydı, ama haksız görünüyordu. Bu yüzden bir temel komut dosyasından başlayarak yeni bir cevap üreten bir komut dosyası yazdım. Burada deneyebilirsiniz:

Kendinizinkini oluşturun

Toplu İş, 438 321 bayt

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

Açıklama: A :, yorum kadar iyi olan bir etiketi belirtmek için kullanılır, böylece program dönme simetrisine sahip olduğundan, iki versiyon arasındaki tek fark @satırlardan hangisinin ilk olduğudur, bu durumda leftveyaright komut dosyasından önce çıktı çıkışlar.

Döndürülmüş çizgilerin üst üste yaratıcı bir şekilde üst üste binmesini denedim, ancak girişimim aslında daha büyük bir ızgarayla sonuçlandı.

Düzenleme: @ ØrjanJohansen sayesinde 117 bayt kaydedildi.

05AB1E (eski) , 89 55 bayt

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

Çok temel yaklaşım. Tam küçük harf olarak çıkar.

Çevrimiçi deneyin ya da çevrimiçi yansıyan deneyin (her döndürme aynıdır).

Açıklama:

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

ters:

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

Benim bu 05AB1E ucu bakın (bölüm nasıl sözlüğü kullanılır? ) Anlamak için '…¸ise "left"ve 'ĩolup "right".

Stax , 131 bayt

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

Koş ve hata ayıkla

Bu "doğru" değişkendir.

Runik Büyüleri , 116 bayt

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

Çevrimiçi deneyin!

Ve tersine döndü

Tam bir bağlantı noktası değil, kullanılmış olan Sol Garf Avcısı'nın Klein 000'ı , iki dilin tipik yakın uyumluluğu göz önüne alındığında, başlangıç ​​noktası olarak cevap verir (çoğu komut aynıdır ve Runic'deki kenar sargısı Klein 000 ile aynıdır). Tek sorun, Klein IP'lerin her zaman sol üstten başlaması ve Runic'in başlamamasıydı. Gibi. orijinal kodun bir parçası ve hala Runic tarafından NOP olarak kabul edilir, NOP'ları ise akış kontrolünün bir parçası olarak eklemek zorunda kaldım.

"left"Tüm 4 rotasyonda yazdırır ve"right" yansıtıldığında (ve bunların dört dönüşünde) . Değişikliklerimden sonra iki orta sütun tamamen kullanılmadığı için bunları kaldırdım.

Teoride daha düşük bir bayt sayısı için çok sayıda izleyen boşluk olan bir rotasyon kullanılabilir (örneğin, bu değişken , ) , ancak dış araçları kullanarak yapıyı doğru bir şekilde döndürmek için boşluklar gerekir ve bu yüzden onları dahil ettim.

Aşağıdaki varyantlar, kaldırılmış, ancak başka şekilde özdeş olmayan kullanılmayan parçaları içerir:

Dört solun hepsi . Çıktılar leftleftleftleft(dördünün de bu şekilde çalıştırılabilir olması tesadüf eseridir).

Sağ 1 , Sağ 2 , Sağ 3 , Sağ 4

Gol> <> , 342 bayt

 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  

Vaov! Beklediğimden daha uzun sürdü, yarı yarıya yansımasının dikey olduğunu fark ettim. kodlama yaptığım gibi yatay değil ! Bunun işe yaradığından eminim, ama bir hata yaptıysam lütfen bana bildirin. Bu büyük olasılıkla saçma bir miktar daha golf olabilir, ben sadece bunu yapmak için aşırı kaba kuvvet yöntemini kullandım. Şeklin kendisi aslında bir karedir, x ekseni boyunca teknik olarak simetriktir, bu yüzden çevirdiğinde yerine "SAĞ" döndürür !!!

Bu programı mümkün kılan karakter, belirli bir çizginin başlangıcına ışınlanmaya izin veren 'A' dır!

Çevrimiçi deneyin!