Kształt jest chiralny, jeśli żaden obrót nie może sprawić, że będzie wyglądał jak odbicie lustrzane. W tej układance będziemy pisać chiralne programy komputerowe.

W przypadku tej układanki pomyślimy o programie jako prostokątnej matrycy znaków. W związku z tym wszystkie rozwiązania tego wyzwania muszą być prostokątne (tzn. Wszystkie linie muszą być tej samej długości). Możemy obracać te programy w krokach co ćwierć obrotu. Na przykład program

The quickish fish
    lept deftly  
  rightwards     

Po obróceniu o ćwierć obrotu w prawo wygląda

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

Możemy również odzwierciedlić te programy. Oto ten sam program odbity na osi pionowej:

hsif hsikciuq ehT
  yltfed tpel    
    sdrawthgir   

Program chiralny to program, który po obróceniu dowolną liczbę razy zawsze wyświetla „ left”. Jednak po odbiciu tworzy program, który wyprowadza „ right” bez względu na to, ile razy jest obracany.

Twoim zadaniem jest napisanie programu chiralnego w jak najmniejszej liczbie bajtów.

Dodatkowe zasady

• Dane wyjściowe nie rozróżniają wielkości liter, ale powinny być spójne. (np. możesz wyprowadzać znaki „ LEFT” i „ rIgHt”, ale ta obudowa musi być spójna podczas rotacji)

• Linie mają być dzielone na nowej linii lub nowej linii i na linii.

• Twój program musi być prostokątem, możesz uzupełnić go spacjami lub komentarzami, ale każda linia musi mieć tę samą długość.

• Opcjonalnie możesz mieć końcowy znak nowej linii (lub znak nowej linii i podawanie linii) we wszystkich swoich programach, jeśli chcesz.

Pascal (FPC) , 2161 755 349 bajtów

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

Spróbuj w lewo

Spróbuj dobrze

@tsh zmotywowało mnie do ponownej próby, kiedy zobaczyłem jego program (w komentarzu) i oto on!

Poprzedni z 755 bajtami:

 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 

Spróbuj w lewo

Spróbuj dobrze

Jeśli widziałeś moje poprzednie zgłoszenie, po prostu zapomnij :)

Wszystkie obroty dla programów lewego i prawego są takie same.

Klein (000) , 109 87 bajtów

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

Wypróbuj online!

Powinieneś mieć możliwość uzyskania krótszej wersji tej odpowiedzi, więc powodzenia!

Ta odpowiedź jest inspirowana spiralami. W szczególności chodzi o dwie powiązane ze sobą spirale, jedną dla lewej i jedną dla prawej. Ma podwójną symetrię, więc możemy sprawdzić następujące programy, aby wiedzieć, że to działa:

Kwartalna kolej

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

Wypróbuj online!

Odbicie lustrzane

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

Wypróbuj online!

Odbicie lustrzane i tura ćwiartki

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

Wypróbuj online!

Klein (000) , 27 25 bajtów

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

Wypróbuj online! Raz obrócony! Obrócono dwukrotnie! Obrócony trzy razy!

I odwrócił: Wypróbuj online! Raz obrócony! Obrócono dwukrotnie! Obrócony trzy razy!

Jedynym, który sprawił mi trochę kłopotów, było odwrócenie i obrócenie raz, co wygląda następująco:

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

Jest to jedyny powód dwóch zestawów ((.

Klein (211) , 37 bajtów

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

Ma inny program dla każdego obrotu.

Wyjaśnienie

Zauważ, że każdy z tych programów jest wypełniany do kwadratu bez operacji przed wykonaniem

Brak zmiany

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

Wypróbuj online!

!powoduje przeskakiwanie wykonywania \i "left"@ładuje ciąg "left"do stosu i przerywa program drukujący stos

Kwartalna kolej

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

Wypróbuj online!

Wykonanie wychodzi poza prawy górny róg kwadratu, kontynuuje w lewym dolnym rogu i ponownie !\"left"@drukuje "left.

Pół obrotu

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

Wypróbuj online!

Tutaj ścieżka egzekucji wychodzi ze strony północnej, wchodzi ponownie przez stronę zachodnią, wychodzi ponownie ze wschodu Przed wejściem na południu. \odbija ścieżkę, "left"@aby ją wydrukować.

Obrót o trzy czwarte

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

Wypróbuj online

Wykonanie wychodzi z prawego górnego rogu, a następnie ponownie wchodzi w lewym dolnym rogu. Po raz kolejny lustra /\przekierowują ścieżkę, "left"@aby ją wydrukować.

Odbicie

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

Jest to zasadniczo takie samo jak dla lewej we wszystkich obrotach.

JavaScript (Node.js) , 1481 599 505 461 341 305 271 bajtów

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

Odbicie lustrzane

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

Wypróbuj online!

(Zobacz TIO Link dla wszystkich przypadków testowych, w tym wersji lustrzanej)

Chociaż dalej grał w golfa, rozmiar 22x22 -> 21x21na kredyt @JoKing!

Rozmiar 38x38 24x24 22x22 21x21 18x18 17x17 16x16, 4-krotna symetria.

Pojawia się pytanie - czy można mieć 15 x 15 lub mniej dla JS? Wydaje się, że potrzebuję przynajmniej separatora komentarzy między dwoma podblokami i na krawędzi, więc co najmniej 7 + 2 + 2 + 5 = 16 linii?

Płótno , 109 89 71 bajtów

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

Wypróbuj tutaj | Spróbuj odwrócić! Są to jedyne dwa możliwe programy, ponieważ program jest obrotowo symetryczny.

Wykonane w tym .

Gol> <> , 23 bajty

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

Wypróbuj online!

Jest to ten sam format, co moja odpowiedź Kleina , ale o 2 bajty krótszy. Być może istnieje inny język 2D, który może odegrać w golfa te ostatnie 2 bajty wyłączone ... Ale na razie jest to tak krótkie, jak to możliwe.

Alice , 25 bajtów

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

Lewy: Normalny , 1/4 obrotu w prawo , 1/2 obrotu , 1/4 obrotu w lewo

Po prawej: odbijanie w poprzek osi poziomej , przekątnej w dół po prawej , osi pionowej , przekątnej w górę w prawo

Wyjaśnienie

Ten program składa się z trzech części. Pierwsza część to trzy {si jeden }w rogach. {Kolej IP lewo, aż osiągnie }, w którym momencie skręca w prawo. W wersji odzwierciedlonej adres IP przebiega wzdłuż górnego wiersza oryginalnego programu. W oryginalnej wersji obrócenie w prawo natychmiast uderzy w sąsiednie {, wskazując adres IP wzdłuż dolnego rzędu w oryginalnym programie.

Następne są dwa ukośniki w drugiej kolumnie. Jeśli program jest zorientowany poziomo, każdy typ ukośnika po prostu zmieni się na tryb porządkowy, wysyłając adres IP w tym samym kierunku w lewo / prawo, w którym już się poruszał. Jeśli program jest zorientowany pionowo, adres IP odbija się nieco więcej, ale wykonanie obu ukośników do przodu daje ten sam efekt końcowy. (Dwa odwrotne ukośniki dają przeciwny wynik, a jeden z nich tworzy nieskończoną pętlę).

Reszta programu jest prosta. Adres IP w trybie porządkowym odbija się po przekątnej, więc albo będzie "left"o@albo "right"o@działał w zależności od tego, jak wprowadzono tę sekcję.

Sześciokąt , 98 bajtów

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

Wypróbuj online! | Obrócony o 90 ° | Obrócony o 180 ° | Obrócony o 270 °
Odwrócony | Obrócony o 90 ° i odwrócony | Obrócone o 180 ° i odwrócone | Obrócony o 270 ° i odwrócony

Sześciokąt był zabawą dla tego wyzwania, ponieważ obrót lub odwrócenie może drastycznie zmienić rzeczywisty program. Każda rotacja / cofanie jest własnym, unikalnym programem. Niektóre ścieżki wykonywania programu są znacznie bardziej interesujące niż inne.

Przyznaję, że wymyślenie tego zajęło więcej czasu niż powinno. Jestem pewien, że w Hexagony można uzyskać krótszą odpowiedź, więc powodzenia!

Rubin , 131 bajtów

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

Wypróbuj online!

APL (dzaima / APL) , 181 bajtów

Program ma symetrię obrotową, dlatego należy sprawdzić tylko dwa przypadki

Lewo

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

Wypróbuj online!

Dobrze

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

Wypróbuj online!

Wyjaśnienie

To jest mój pierwszy program APL, więc jest dość prosty. Wykorzystuje tylko jedną sztuczkę, która moim zdaniem jest interesująca.

Jeśli zaczniemy od usunięcia wszystkich komentarzy, otrzymamy następujące programy

Lewo

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

Dobrze

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

Począwszy od lewego programu robimy trzy rzeczy.

1. Przypisz 'lef'do zmiennejt

2. Wydrukuj zmienną ti literę't'

3. Przypisz 'righ'do zmiennejt

Ponieważ jest to kopia lustrzana, właściwy program wykonuje te trzy kroki, ale w odwrotnej kolejności. Oznacza to, że drukujemy 'left'dla lewego programu i 'right'dla prawego programu.

Jedyną sztuczką jest to, że 't'faktycznie pochodzi z obróconej kopii kodu. Jeśli spojrzysz na trzecią kolumnę naszego kodu, zobaczysz, że tak 't'. Używamy tego ponownie 't'w obróconych wersjach, aby dołączyć to, tco jest potrzebne.

Haskell , 461 379 bajtów

82 bajty zapisane przez Ø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----------_--

Wypróbuj online!

Ponieważ ten ma 4-krotną symetrię, wystarczy przetestować lustro:

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

Wypróbuj online!

To jest początek. Jest daleki od ideału, ale dzieje się tutaj kilka interesujących rzeczy. Haskell jest z pewnością interesującym językiem dla tego wyzwania. Z niecierpliwością czekam na odpowiedź, która przebije moją odpowiedź lub odpowiedź kogoś innego.

Prolog (SWI) , 649 188 bajtów

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

Wypróbuj online!

Odczepiony, obrócony

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

Wypróbuj online!

Odwrócony, niechroniony

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

Wypróbuj online!

Odwrócony, obrócony

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

Wypróbuj online!

Prolog (SWI) , 239 223 209 181 bajtów

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

Wypróbuj online!

Ponieważ program ma 4-krotną symetrię, wystarczy sprawdzić lustro:

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

Wypróbuj online!

Python 2 , 209 bajtów (14 x 14)

Normalny (po lewej):

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

Wypróbuj online!

Odbicie (po prawej):

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

Wypróbuj online!

Czysty , 1331 1055 bajtów

-276 bajtów dzięki Ø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//////////// //
// ///////////;/;//////////// //

Spróbuj „w lewo” online!

Spróbuj „dobrze” online!

Było to trudne z wielu powodów:

• Czyszczenie wymaga nagłówka pliku module <filename>na początku i tylko na początku pliku. Niestety oznacza to, że aby rotacje programu dublowanego były ważne, muszą również pojawiać się na dole pliku. Co gorsza, module ..jest nieważny dla globalnego,let .. in , where ..i with ..definicji; a modulepojawienie się tokena, jeśli nie został zdefiniowany, powoduje błąd.
• Zagnieżdżane są zarówno komentarze blokowe, jak i liniowe: /* /* */ pozostawia jeden poziom komentarza otwarty, podobnie jak /* // */(podobnie jak komentowanie reszty linii).
• Tę samą funkcję można zdefiniować wiele razy, ale tylko bezpośrednio po niej.

Na szczęście, można określić modulejako coś w #..(przed) let-ekspresji, czyli wszystko, czego potrzebujemy. Ponieważ Clean nie sprawdza typów alternatyw, które nigdy nie są używane (i wielu innych równie nieużywanych rzeczy), wymaganą drugą definicją Startmoże być kompletne śmieci. To pozwala nam użyć drugiego Startdo zużywania nagłówka modułu na dole pliku, ponieważ Clean traktuje m module mjak wywołanie funkcji mna ( modulei mponieważ od tego, co zdefiniowaliśmy, modulei mnie powoduje błędu). To nie ma znaczeniam jest to ciąg znaków, a nie funkcja, ponieważ Startalternatywa nigdy nie jest sprawdzana pod kątem typu.

Łatwiej to zobaczyć, jeśli spojrzysz na to oczami kompilatora:

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

Brachylog , 341 bajtów

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

Wypróbuj online!

! enilno ti yrT

Korzysta z tego, że Brachylog bierze główny predykat jako ten z pierwszej linii i nie dba o inne linie poza tym, że wymaga kompilacji. Bez odbicia drukuje pusty ciąg, po którym następuje „lewo” w tym samym wierszu, i odzwierciedla, że ​​drukuje pusty ciąg, po którym następuje „prawo” w tym samym wierszu. Kusi mnie, aby pomyśleć, że może istnieć sposób na (użyteczne) użycie wersji niekwadratowej ṇ, ale może to być dość skomplikowane bez próby sprawienia, by działała inaczej pod wpływem refleksji.

Rubinowy , 181 bajtów

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

Wypróbuj online!

To jest port odpowiedzi Curtisa Bechtela na Ruby'ego, trochę więcej grał w golfa.

W rzeczywistości jego program w Pythonie jest poliglotą i działa również na Ruby, więc moją pierwszą odpowiedzią było skopiowanie go, ale wydawało się to niesprawiedliwe. Napisałem więc skrypt, który generuje nową odpowiedź, zaczynając od skryptu podstawowego. Możesz spróbować tutaj:

Zbuduj swoją własną

Partia, 438 321 bajtów

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

Objaśnienie: :służy do wskazania etykietę, która jest tak dobra jak w komentarzu, tak jak program ma symetrię obrotową jedyną różnicą pomiędzy tymi dwoma wersjami, która z @linii jest pierwszym, w którym to przypadku albo leftalboright jest wyjście przed skryptem wychodzi.

Próbowałem twórczo nakładać na siebie obrócone linie, ale moja próba zakończyła się większą siatką.

Edycja: Zapisano 117 bajtów dzięki @ ØrjanJohansen.

05AB1E (starsza wersja) , 89 55 bajtów

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

Bardzo podstawowe podejście. Dane wyjściowe są pisane małymi literami.

Wypróbuj online lub wypróbuj online odzwierciedlone (każdy obrót jest taki sam).

Wyjaśnienie:

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

Wywrócony:

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

Zobacz moją wskazówkę 05AB1E (sekcja Jak korzystać ze słownika? ), Aby zrozumieć, dlaczego '…¸jest "left"i 'ĩjest "right".

Stax , 131 bajtów

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

Uruchom i debuguj

To jest „właściwy” wariant.

Runiczne Zaklęcia , 116 bajtów

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

Wypróbuj online!

I odwrócone

Nie do końca port, ale wykorzystał jako odpowiedź punkt wyjściowy Klein 000 Posta Garfa Huntera Huntera , biorąc pod uwagę typową prawie kompatybilność dwóch języków (większość poleceń jest taka sama, a zawijanie krawędzi w Runicznej jest identyczne jak Klein 000). Jedynym problemem było to, że adresy IP Klein zawsze zaczynają się od lewego górnego rogu, a Runic nie. Jako takie, .wszystkie są częścią oryginalnego kodu i nadal są traktowane przez Runic jako NOP, podczas gdy są to NOP, które musiałem dodać w ramach kontroli przepływu.

Drukuje "left"we wszystkich 4 obrotach i"right" po odbiciu lustrzanym (i we wszystkich czterech obrotach). Dwie środkowe kolumny były całkowicie nieużywane po moich modyfikacjach, więc mogłem je usunąć.

Teoretycznie obrót z dużą ilością spacji końcowych może być wykorzystany dla niższej liczby bajtów (np. Ten wariant ), jednak przestrzeń jest potrzebna do prawidłowego obrócenia konstrukcji za pomocą zewnętrznych narzędzi, więc je zawarłem.

Poniższe warianty zawierają nieużywane fragmenty, które zostały usunięte, ale poza tym są identyczne:

Wszystkie cztery lewe . Wyjścia leftleftleftleft(fakt, że wszystkie cztery można uruchomić w ten sposób, to zbieg okoliczności).

Prawo 1 , Prawo 2 , Prawo 3 , Prawo 4

Gol> <> , 342 bajtów

 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  

Łał! Trwało to dłużej niż się spodziewałem, w połowie zdałem sobie sprawę, że odbicie jest w pionie , a nie w poziomie, jak wcześniej kodowałem! Jestem pewien, że to działa, ale jeśli popełniłem błąd, proszę dać mi znać. Najprawdopodobniej można to zrobić w golfa jeszcze bardziej absurdalnie, właśnie zastosowałem metodę ekstremalnej brutalnej siły. Sam kształt jest właściwie kwadratem, jest technicznie symetryczny, z wyjątkiem osi w poprzek osi x, więc kiedy się odwraca, zamiast tego zwraca „PRAWO” !!!

Znakiem, który umożliwił uruchomienie tego programu, jest „A”, co pozwala na teleportację na początek określonej linii!

Wypróbuj online!