Eine Form ist chiral, wenn keine Drehung sie spiegelbildlich erscheinen lässt. In diesem Puzzle werden wir chirale Computerprogramme schreiben.

Für dieses Puzzle stellen wir uns ein Programm als rechteckige Zeichenmatrix vor. Als solche müssen alle Lösungen für diese Herausforderung rechteckig sein (dh alle Linien müssen die gleiche Länge haben). Wir können diese Programme in Vierteldrehungsschritten drehen. Zum Beispiel das Programm

The quickish fish
    lept deftly  
  rightwards     

Eine Vierteldrehung im Uhrzeigersinn sieht so aus

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

Wir können diese Programme auch reflektieren. Hier ist dasselbe Programm, das sich über eine vertikale Achse spiegelt:

hsif hsikciuq ehT
  yltfed tpel    
    sdrawthgir   

Ein chirales Programm ist ein Programm, das bei beliebiger Drehung immer " left" ausgibt . Bei " right" Reflexion wird jedoch ein Programm erstellt, das unabhängig davon, wie oft es gedreht wird , " " ausgegeben wird.

Ihre Aufgabe ist es, ein chirales Programm in möglichst wenigen Bytes zu schreiben.

Zusätzliche Regeln

• Die Ausgabe unterscheidet nicht zwischen Groß- und Kleinschreibung, sollte jedoch konsistent sein. (zB Sie können " LEFT" und " rIgHt" ausgeben, aber dieses Gehäuse muss unter Rotationen konsistent sein)

• Zeilen sind entweder auf eine neue Zeile oder eine neue Zeile und einen Zeilenvorschub aufzuteilen.

• Ihr Programm muss ein Rechteck sein. Sie können es mit Leerzeichen oder Kommentaren auffüllen, aber jede Zeile muss dieselbe Länge haben.

• Optional können Sie für alle Ihre Programme einen nachgestellten Zeilenumbruch (oder Zeilenumbruch und Zeilenvorschub) festlegen.

Pascal (FPC) , 2161 755 349 Bytes

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

Versuchen Sie es links

Versuchen Sie es richtig

@tsh hat mich motiviert, es noch einmal zu versuchen, als ich sein Programm sah (im Kommentar) und hier ist es!

Vorherige mit 755 Bytes:

 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 

Versuchen Sie es links

Versuchen Sie es richtig

Wenn Sie meinen vorherigen Beitrag gesehen haben, vergessen Sie ihn einfach :)

Alle Drehungen für das linke und das rechte Programm sind gleich.

Klein (000) , 109 87 Bytes

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

Probieren Sie es online!

Sollte es möglich sein, eine kürzere Version dieser Antwort zu bekommen, so viel Glück!

Diese Antwort ist von Spiralen inspiriert. Insbesondere geht es um zwei ineinandergreifende Spiralen, eine für links und eine für rechts. Es hat eine zweifache Symmetrie. Wir können also die folgenden Programme überprüfen, um zu wissen, ob es funktioniert:

Vierteldrehung

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

Probieren Sie es online!

Gespiegelt

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

Probieren Sie es online!

Gespiegelt und Vierteldrehung

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

Probieren Sie es online!

Klein (000) , 27 25 Bytes

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

Probieren Sie es online! Einmal gedreht! Zweimal gedreht! Dreimal gedreht!

Und umgedreht: Online ausprobieren! Einmal gedreht! Zweimal gedreht! Dreimal gedreht!

Das Einzige, was mir ein bisschen Ärger bereitete, war das einmalige Umdrehen und Drehen. Das sieht so aus:

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

Dies ist der einzige Grund für die beiden Sätze von ((.

Klein (211) , 37 Bytes

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

Dies hat ein anderes Programm für jede Umdrehung.

Erläuterung

Beachten Sie, dass jedes dieser Programme vor der Ausführung mit No-Ops zu einem Quadrat aufgefüllt wird

Keine Änderung

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

Probieren Sie es online!

!macht Ausführung Sprung über die \und "left"@die Zeichenfolge Lasten "left"in den Stapel und beendet das Programm Drucken des Stapels

Vierteldrehung

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

Probieren Sie es online!

Die Ausführung läuft an der oberen rechten Ecke des Quadrats ab, wird in der unteren linken Ecke fortgesetzt und erneut !\"left"@gedruckt "left.

Halbe Drehung

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

Probieren Sie es online!

Hier verlässt der Hinrichtungsweg die Nordseite, tritt wieder durch die Westseite ein, verlässt wieder den Osten, bevor er in den Süden eintritt. \hüpft der Pfad hinein "left"@, um ihn zu drucken.

Dreiviertelumdrehung

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

Probieren Sie es online aus

Die Ausführung wird in der oberen rechten Ecke beendet und tritt dann in der unteren linken Ecke wieder ein. Wieder /\leiten die Spiegel den Pfad "left"@zum Drucken um.

Reflexion

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

Dies ist im Wesentlichen dasselbe wie für links in allen Umdrehungen.

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/

Gespiegelt

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

Probieren Sie es online!

(Informationen zu allen Testfällen, einschließlich der gespiegelten Version, finden Sie unter TIO Link.)

Obwohl weiter golfen, Größe 22x22 -> 21x21auf Kredit von @JoKing!

Größe 38x38 24x24 22x22 21x21 18x18 17x17 16x16 , 4-fache Symmetrie.

Hier kommt eine Frage - ist es möglich, 15x15 oder kleiner für JS zu haben? Es scheint, dass ich mindestens das Kommentar-Trennzeichen zwischen zwei Unterblöcken und am Rand brauche, also mindestens 7 + 2 + 2 + 5 = 16 Zeilen?

Canvas , 109 89 71 Bytes

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

Versuchen Sie es hier | Versuchen Sie es umgekehrt! Dies sind die einzigen zwei möglichen Programme, da das Programm rotationssymmetrisch ist.

Gemacht in diesem .

Gol> <> , 23 Bytes

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

Probieren Sie es online!

Dies ist das gleiche Format wie meine Klein-Antwort , aber 2 Bytes kürzer. Vielleicht gibt es da draußen eine andere 2D-Sprache, die die letzten 2 Bytes Golf spielen kann ... Aber im Moment ist dies so kurz wie es nur geht.

Alice , 25 Bytes

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

Links: Normal , 1/4 Umdrehung im Uhrzeigersinn , 1/2 Umdrehung , 1/4 Umdrehung gegen den Uhrzeigersinn

Rechts: Spiegeln über die horizontale Achse , die Diagonale nach unten rechts , die vertikale Achse , die Diagonale nach oben rechts

Erläuterung

Dieses Programm besteht aus drei Teilen. Der erste Teil sind die drei {s und eins }an den Ecken. Die {wiederum die IP - links , bis er das erreicht }, an welcher Stelle es nach rechts abbiegt. In der reflektierten Version steht die IP im ursprünglichen Programm in der obersten Zeile. Wenn Sie in der Originalversion nach rechts drehen, wird sofort die angrenzende {IP-Adresse berührt, wobei die IP-Adresse in der unteren Zeile des Originalprogramms angezeigt wird.

Als nächstes folgen die beiden Schrägstriche in der zweiten Spalte. Wenn das Programm horizontal ausgerichtet ist, wechselt eine der beiden Arten von Schrägstrichen einfach in den Ordnungsmodus und sendet die IP in die gleiche Richtung nach links / rechts, in der sie bereits ausgeführt wurde. Wenn das Programm vertikal ausgerichtet ist, springt die IP-Adresse viel mehr herum, aber wenn Sie beide Schrägstriche verwenden, erhalten Sie dasselbe Endergebnis. (Zwei umgekehrte Schrägstriche würden das entgegengesetzte Ergebnis ergeben, und einer von jedem würde eine Endlosschleife erzeugen.)

Der Rest des Programms ist unkompliziert. Die IP im ordinalen Modus springt diagonal ab. Je nachdem, wie dieser Abschnitt eingegeben wurde, wird sie entweder ausgeführt "left"o@oder "right"o@ausgeführt.

Hexagony , 98 Bytes

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

Probieren Sie es online! | 90 ° gedreht | 180 ° gedreht | 270 ° gedreht
Umgekehrt | 90 ° gedreht & umgekehrt | 180 ° gedreht & umgekehrt | 270 ° gedreht und umgekehrt

Hexagony hat bei dieser Herausforderung Spaß gemacht, da eine Drehung oder Umkehrung das eigentliche Programm drastisch verändern kann. Jede Drehung / Umkehrung ist ein eigenes Programm. Einige der Programmausführungspfade sind viel interessanter als andere.

Ich gebe zu, dass es länger gedauert hat, als es wahrscheinlich hätte dauern sollen. Ich bin mir ziemlich sicher, dass eine kürzere Antwort in Hexagony möglich ist, also viel Glück!

Rubin , 131 Bytes

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

Probieren Sie es online!

APL (Dzaima / APL) , 181 Bytes

Das Programm ist rotationssymmetrisch, sodass nur zwei Fälle geprüft werden müssen

Links

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

Probieren Sie es online!

Richtig

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

Probieren Sie es online!

Erläuterung

Dies ist mein erstes APL-Programm, es ist also ziemlich einfach. Es wird nur ein Trick verwendet, den ich für interessant halte.

Wenn wir alle Kommentare entfernen, erhalten wir die folgenden Programme

Links

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

Richtig

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

Ausgehend vom linken Programm machen wir drei Dinge.

1. Weisen Sie 'lef'der Variablen zut

2. Drucken Sie die Variable tund den Buchstaben't'

3. Weisen Sie 'righ'der Variablen zut

Da es sich nun um den Spiegel handelt, führt das richtige Programm diese drei Schritte in umgekehrter Reihenfolge aus. Dies bedeutet, dass wir 'left'für das linke Programm und 'right'für das rechte Programm drucken .

Der einzige Trick dabei ist, dass das 't'tatsächlich von einer gedrehten Kopie des Codes kommt. Wenn Sie sich die dritte Spalte unseres Codes ansehen, werden Sie feststellen, dass dies der Fall ist 't'. Wir verwenden dies 't'in den gedrehten Versionen erneut, um das Notwendige anzuhängen t.

Haskell , 461 379 Bytes

82 Bytes von Ørjan Johansen gespeichert

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

Probieren Sie es online!

Da diese 4-fache Symmetrie hat, müssen Sie nur den Spiegel testen:

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

Probieren Sie es online!

Dies ist ein Anfang. Es ist alles andere als ideal, aber es gibt ein paar interessante Dinge, die hier vor sich gehen. Haskell ist sicherlich eine interessante Sprache für diese Herausforderung. Ich freue mich auf eine Antwort, die besser ist als meine oder die einer anderen Person.

Prolog (SWI) , 649.188 Bytes

Nicht gedreht, nicht gedreht

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

Probieren Sie es online!

Ungewendet, gedreht

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

Probieren Sie es online!

Umgedreht, nicht gedreht

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

Probieren Sie es online!

Umgedreht, gedreht

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

Probieren Sie es online!

Prolog (SWI) , 239 223 209 181 Bytes

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

Probieren Sie es online!

Da das Programm eine 4-fache Symmetrie hat, müssen Sie nur den Spiegel überprüfen:

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

Probieren Sie es online!

Python 2 , 209 Bytes (14 x 14)

Normal (links):

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

Probieren Sie es online!

Reflektiert (rechts):

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

Probieren Sie es online!

Sauber , 1331 1055 Bytes

-276 Bytes dank Ø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//////////// //
// ///////////;/;//////////// //

Versuchen Sie "links" online!

Online "richtig" testen!

Das war aus vielen Gründen schwierig:

• Clean setzt voraus, module <filename>dass am Anfang ein Dateikopf und nur der Anfang der Datei vorhanden ist. Leider bedeutet dies, dass die Rotationen des gespiegelten Programms auch am Ende der Datei angezeigt werden müssen, damit sie gültig sind. Um diesen noch schlimmer zu machen, module ..ist ungültig für die globalen, let .. in, where ..und with ..Definitionen; und das Token module, das angezeigt wird , wenn es nicht definiert wurde, verursacht einen Fehler.
• Sowohl Blockkommentare als auch Zeilenkommentare verschachteln: /* /* */Lässt eine Kommentarebene offen, /* // */ebenso wie das Auskommentieren des Restes der Zeile.
• Die gleiche Funktion kann mehrfach definiert werden, jedoch nur direkt nach sich.

Glücklicherweise wir können definieren , modulewie etwas in einem #..(let-vor) Ausdruck, der alles , was wir brauchen ist. Da Clean keine Alternativen prüft, die niemals verwendet werden (und eine Vielzahl anderer, ebenfalls nicht verwendeter Dinge), kann die erforderliche zweite Definition von StartMüll vollständig sein. Auf diese Weise können wir die zweite verwenden Start, um den Modulheader am Ende der Datei zu belegen, da Clean m module mdie Funktion mon moduleund aufruft m(was, da wir moduleand definiert haben m, keinen Fehler verursacht). Es spielt keine Rolle, dass mes sich um eine Zeichenfolge und nicht um eine Funktion handelt, da die StartAlternative niemals einer Typprüfung unterzogen wird.

Dies ist einfacher zu sehen, wenn Sie es mit den Augen des Compilers betrachten:

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

Brachylog , 341 Bytes

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

Probieren Sie es online!

! enilno ti yrT

Nutzt den Vorteil von Brachylog, dass das Hauptprädikat in der ersten Zeile steht und die anderen Zeilen nicht so wichtig sind, als dass sie kompiliert werden müssen. Unreflektiert wird eine leere Zeichenfolge gefolgt von "left" in derselben Zeile ausgegeben, und gespiegelt wird eine leere Zeichenfolge gefolgt von "right" in derselben Zeile. Ich bin versucht zu glauben, dass es eine Möglichkeit gibt, eine (sinnvolle) nicht-quadratische Version zu ṇerstellen, aber das könnte eine Menge schwieriger sein, ohne zu versuchen, sie unter Reflektion anders zu gestalten.

Ruby , 181 Bytes

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

Probieren Sie es online!

Dies ist eine Portierung der Python-Antwort von Curtis Bechtel auf Ruby, die ein wenig mehr Golf gespielt hat.

Eigentlich ist sein Python-Programm ein Polyglott und läuft auch unter Ruby, also war meine erste Antwort das Kopieren, aber es schien unfair. Also habe ich ein Skript geschrieben, das ausgehend von einem Basisskript eine neue Antwort generiert. Sie können es hier ausprobieren:

Bau dein eigenes

Batch, 438 321 Bytes

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

Erläuterung: Mit A :wird eine Beschriftung angegeben, die so gut wie ein Kommentar ist. Da das Programm also rotationssymmetrisch ist, besteht der einzige Unterschied zwischen den beiden Versionen darin, welche der @Zeilen die erste ist. In diesem Fall wird entweder leftoder rightvor dem Skript ausgegeben Ausgänge.

Ich habe versucht, die gedrehten Linien kreativ miteinander zu überlappen, aber mein Versuch endete tatsächlich mit einem größeren Raster.

Bearbeiten: 117 Bytes dank @ ØrjanJohansen gespeichert.

05AB1E (legacy) , 89 55 Bytes

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

Sehr einfacher Ansatz. Ausgabe in Kleinbuchstaben.

Probieren Sie es online oder online aus (jede Umdrehung ist gleich).

Erläuterung:

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

Rückgängig gemacht:

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

Sehen Sie sich meinen Tipp 05AB1E (Abschnitt Wie verwende ich das Wörterbuch? ) An, um zu verstehen, warum es '…¸ist "left"und 'ĩist "right".

Stax , 131 Bytes

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

Führen Sie es aus und debuggen Sie es

Dies ist die "richtige" Variante.

Runenverzauberungen , 116 Bytes

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

Probieren Sie es online!

Und umgekehrt

Nicht gerade ein Port, sondern als Ausgangspunkt die Klein 000-Antwort von Post Left Garf Hunter , da beide Sprachen nahezu kompatibel sind (die meisten Befehle sind gleich und der Kantenumbruch in Runic ist identisch mit Klein 000). Das einzige Problem war, dass Klein-IPs immer von links oben beginnen und Runic's nicht. Als solche .sind sie alle Teil des ursprünglichen Codes und werden von Runic immer noch als NOP behandelt, während die NOPs ich als Teil der Flusssteuerung hinzufügen musste.

Druckt "left"in allen 4 Umdrehungen und "right"im gespiegelten Zustand (und in allen vier Umdrehungen davon). Zwei mittlere Spalten waren nach meinen Änderungen völlig unbenutzt, so dass ich sie entfernen konnte.

Theoretisch könnte eine Rotation mit vielen nachgestellten Leerzeichen für eine niedrigere Bytezahl verwendet werden (z. B. diese Variante ), die Leerzeichen werden jedoch benötigt, um die Struktur mit externen Werkzeugen korrekt zu drehen, und so habe ich sie eingeschlossen.

Die folgenden Varianten enthalten die nicht verwendeten Teile, die entfernt wurden, aber ansonsten identisch sind:

Alle vier links . Ausgänge leftleftleftleft(die Tatsache, dass alle vier so ausgeführt werden können, ist Zufall).

Richtig 1 , Richtig 2 , Richtig 3 , Richtig 4

Gol> <> , 342 Bytes

 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  

Beeindruckend! Das hat länger gedauert, als ich erwartet hatte, als mir auf halbem Weg klar wurde, dass die Reflexion vertikal und nicht horizontal war, wie ich es mir vorgestellt hatte! Ich bin mir ziemlich sicher, dass dies funktioniert, aber wenn ich einen Fehler gemacht habe, lassen Sie es mich bitte wissen. Dies kann höchstwahrscheinlich eine lächerliche Menge mehr golfen werden, ich habe gerade eine extreme Brute-Force-Methode angewendet, um dies zu tun. Die Form selbst ist eigentlich ein Quadrat, sie ist technisch symmetrisch, außer auf der x-Achse. Wenn sie also umgedreht wird, wird stattdessen "RECHTS" zurückgegeben !!!

Der Charakter, der dieses Programm möglich gemacht hat, ist das 'A', das das Teleportieren an den Anfang einer bestimmten Zeile ermöglicht!

Probieren Sie es online!