Una forma è chirale se nessuna rotazione può far sembrare che sia un'immagine speculare. In questo puzzle scriveremo programmi per computer chirali.

Per questo puzzle penseremo a un programma come a una matrice rettangolare di personaggi. Pertanto tutte le soluzioni a questa sfida devono essere rettangolari (ovvero tutte le linee devono avere la stessa lunghezza). Possiamo ruotare questi programmi con incrementi di un quarto di giro. Ad esempio il programma

The quickish fish
    lept deftly  
  rightwards     

Se ruotato di un quarto di giro, appare in senso orario

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

Possiamo anche riflettere questi programmi. Ecco lo stesso programma riflesso su un asse verticale:

hsif hsikciuq ehT
  yltfed tpel    
    sdrawthgir   

Un programma chirale è un programma che quando viene ruotato un numero qualsiasi di volte emetterà sempre " left". Tuttavia, quando riflette produce un programma che emette " right" indipendentemente da quante volte viene ruotato.

Il tuo compito è scrivere un programma chirale nel minor numero di byte possibile.

Regole aggiuntive

• L'output non fa distinzione tra maiuscole e minuscole ma dovrebbe essere coerente. (ad es. è possibile produrre " LEFT" e " rIgHt" ma questo involucro deve essere coerente in base alle rotazioni)

• Le linee devono essere divise su una nuova riga o una nuova riga e un avanzamento riga.

• Il tuo programma deve essere un rettangolo, puoi riempirlo con spazi o commenti ma ogni riga deve avere la stessa lunghezza.

• Se lo si desidera, è possibile disporre di una nuova riga finale (o nuova riga e avanzamento riga) su tutti i programmi.

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

Prova a sinistra

Prova bene

@tsh mi ha motivato a riprovare quando ho visto il suo programma (nei commenti) ed eccolo qui!

Uno precedente con 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 

Prova a sinistra

Prova bene

Se hai visto il mio precedente contributo, dimenticalo :)

Tutte le rotazioni per i programmi sinistro e destro sono uguali.

Klein (000) , 109 87 byte

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

Provalo online!

Dovrebbe essere possibile ottenere una versione più breve di questa risposta, quindi buona fortuna!

Questa risposta è ispirata dalle spirali. In particolare l'idea è di due spirali interconnesse, una per sinistra e una per destra. Ha una duplice simmetria, quindi possiamo controllare i seguenti programmi per sapere che funziona:

Quarto di giro

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

Provalo online!

Rispecchiato

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

Provalo online!

Specchiata e quarto di giro

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

Provalo online!

Klein (000) , 27 25 byte

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

Provalo online! Ruotato una volta! Ruotato due volte! Ruotato tre volte!

E capovolto: provalo online! Ruotato una volta! Ruotato due volte! Ruotato tre volte!

L'unico che mi ha dato un po 'di problemi è stato capovolto e ruotato una volta, che assomiglia a:

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

Questa è l'unica ragione per le due serie di ((.

Klein (211) , 37 byte

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

Questo ha un programma diverso per ogni rotazione.

Spiegazione

Si noti che ciascuno di questi programmi è riempito con un quadrato senza operazioni operative prima dell'esecuzione

Nessun cambiamento

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

Provalo online!

!fa saltare l'esecuzione \e "left"@carica la stringa "left"nello stack e termina il programma stampando lo stack

Quarto di giro

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

Provalo online!

L'esecuzione scorre nell'angolo in alto a destra del quadrato, continua nell'angolo in basso a sinistra e !\"left"@stampa di nuovo "left.

Mezzo giro

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

Provalo online!

Qui, il percorso di esecuzione esce dal lato nord, rientra attraverso il lato ovest, esce di nuovo da est prima di entrare nel sud. \rimbalza il percorso "left"@per stamparlo.

Giro di tre quarti

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

Provalo online

L'esecuzione esce dall'angolo in alto a destra, quindi rientra in basso a sinistra. Ancora una volta i mirror /\reindirizzano il percorso "left"@per stamparlo.

Riflessione

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

Questo è essenzialmente lo stesso di sinistra in tutte le rotazioni.

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/

Rispecchiato

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

Provalo online!

(Consultare il collegamento TIO per tutti i casi di test, inclusa la versione speculare)

Anche se ulteriormente golfato, dimensioni 22x22 -> 21x21a credito di @JoKing!

Dimensioni 38x38 24x24 22x22 21x21 18x18 17x17 16x16, simmetria 4 volte.

Ecco una domanda: è possibile avere 15x15 o più piccoli per JS? Sembra che quello di cui ho bisogno almeno sia il separatore dei commenti tra due sottoblocchi e sul bordo, quindi almeno 7 + 2 + 2 + 5 = 16 righe?

Tela , 109 89 71 byte

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

Provalo qui | Prova al contrario! Questi sono gli unici due programmi possibili, poiché il programma è simmetrico in senso rotazionale.

Fatto in questo .

Gol> <> , 23 byte

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

Provalo online!

Questo è lo stesso formato della mia risposta Klein , ma è più breve di 2 byte. Forse c'è un altro linguaggio 2D là fuori che può golf quegli ultimi 2 byte di sconto ... Ma per ora, questo è il più breve possibile.

Alice , 25 byte

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

Sinistra: Normale , 1/4 di giro in senso orario , 1/2 giro , di 1/4 di giro in senso antiorario

Destra: riflette attraverso l' asse orizzontale , la diagonale verso il basso a destra , l'asse verticale , la diagonale verso l'alto a destra

Spiegazione

Questo programma ha tre parti. La prima parte è la tre se {una }sugli angoli. Il {turno del IP a sinistra fino a raggiungere il }, a quel punto si gira a destra. Nella versione riflessa, l'IP va nella prima riga del programma originale. Nella versione originale, girare a destra colpirà immediatamente l'adiacente {, indicando l'IP lungo la riga inferiore del programma originale.

Poi ci sono le due barre nella seconda colonna. Se il programma è orientato in senso orizzontale, entrambi i tipi di barra passerebbero semplicemente alla modalità ordinale, inviando l'IP nella stessa direzione sinistra / destra già in atto. Se il programma è orientato verticalmente, l'IP rimbalza un po 'di più, ma rendendole entrambe le barre in avanti fornisce lo stesso risultato finale. (Due barre rovesciate darebbero il risultato opposto e una di ciascuna creerebbe un ciclo infinito.)

Il resto del programma è semplice. L'IP in modalità ordinale rimbalza in diagonale, quindi "left"o@o "right"o@verrà eseguito a seconda di come è stata inserita questa sezione.

Esagonia , 98 byte

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

Provalo online! | Ruotato di 90 ° | Ruotato di 180 ° | Rotazione di 270 °
invertita | Ruotato di 90 ° e invertito | Ruotato di 180 ° e invertito | Rotazione di 270 ° e retromarcia

L'esagonia è stata divertente per questa sfida, perché una rotazione o un'inversione può cambiare drasticamente il programma attuale. Ogni rotazione / inversione è il suo programma unico. Alcuni dei percorsi di esecuzione del programma sono molto più interessanti di altri.

Devo ammettere che inventarlo ha richiesto più tempo di quanto probabilmente avrebbe dovuto. Sono abbastanza sicuro che una risposta più breve possa essere fatta in Hexagony, quindi buona fortuna!

Rubino , 131 byte

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

Provalo online!

APL (dzaima / APL) , 181 byte

Il programma ha una simmetria rotazionale, quindi è necessario controllare solo due casi

Sinistra

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

Provalo online!

Giusto

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

Provalo online!

Spiegazione

Questo è il mio primo programma APL, quindi è piuttosto semplice. Usa solo un trucco che penso sia interessante.

Se iniziamo togliendo tutti i commenti otteniamo i seguenti programmi

Sinistra

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

Giusto

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

A partire dal programma di sinistra facciamo tre cose.

1. Assegna 'lef'alla variabilet

2. Stampa la variabile te la lettera't'

3. Assegna 'righ'alla variabilet

Ora, poiché è il mirror, il programma giusto esegue questi tre passaggi ma nell'ordine opposto. Ciò significa che stampiamo 'left'per il programma di sinistra e 'right'per il programma di destra.

L'unico trucco qui è che 't'effettivamente proviene da una copia ruotata del codice. Se guardi la terza colonna del nostro codice vedrai che lo è 't'. Lo riutilizziamo 't'nelle versioni ruotate per aggiungere tciò che è necessario.

Haskell , 461 379 byte

82 byte salvati da Ø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----------_--

Provalo online!

Poiché questo ha una simmetria quadrupla, devi solo testare lo specchio:

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

Provalo online!

Questo è un inizio È tutt'altro che ideale, ma qui ci sono alcune cose interessanti. Haskell è sicuramente un linguaggio interessante per questa sfida. Non vedo l'ora di trovare una risposta che sia migliore della mia o di qualcun altro.

Prolog (SWI) , 649 188 byte

Non capovolto, non ruotato

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

Provalo online!

Non capovolto, ruotato

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

Provalo online!

Capovolto, non ruotato

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

Provalo online!

Capovolto, ruotato

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

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

Provalo online!

Poiché il programma ha una simmetria di 4 volte, è sufficiente controllare lo specchio:

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

Provalo online!

Python 2 , 209 byte (14 x 14)

Normale (a sinistra):

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

Provalo online!

Riflesso (a destra):

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

Provalo online!

Pulito , 1331 1055 byte

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

Prova "lasciato" online!

Prova "giusto" online!

Questo è stato difficile per molte ragioni:

• Clean richiede che all'inizio module <filename>sia presente un'intestazione del file e solo l'inizio del file. Sfortunatamente, ciò significa che, affinché le rotazioni del programma speculare siano valide, deve apparire anche nella parte inferiore del file. A peggiorare le cose, module ..non è valido per globale let .. in, where ..e with ..definizioni; e il token che moduleappare se non è stato definito causa un errore.
• Nidificano sia i commenti di blocco che quelli di linea: /* /* */lascia aperto un livello di commento, e così fa /* // */(oltre a commentare il resto della riga).
• La stessa funzione può essere definita più volte, ma solo direttamente dopo se stessa.

Per fortuna, siamo in grado di definire modulecome qualcosa in un #..(let-prima) espressione, che è tutto abbiamo bisogno. Poiché Clean non controlla le alternative mai utilizzate (e una varietà di altre cose ugualmente inutilizzate), la seconda definizione necessaria di Startpuò essere spazzatura completa. Questo ci permette di utilizzare il secondo Startdi consumare l'intestazione del modulo in fondo al file perché tratta Pulire m module mcome chiamare la funzione msu modulee m(che da quando abbiamo definito modulee m, non causa un errore). Non importa che msia una stringa e non una funzione, perché l' Startalternativa non viene mai controllata dal tipo.

Questo è più facile da vedere se lo guardi attraverso gli occhi del compilatore:

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Ẹ

Provalo online!

! enilno ti yrT

Sfrutta il fatto che Brachylog considera il predicato principale come quello sulla prima riga e non si preoccupa molto delle altre righe oltre a richiedere che possano essere compilate. Non riflessa, stampa una stringa vuota seguita da "sinistra" sulla stessa riga e riflessa stampa una stringa vuota seguita da "destra" sulla stessa riga. Sono tentato di pensare che potrebbe esserci un modo per creare una versione (utilmente) non quadrata ṇ, ma ciò potrebbe essere molto complicato senza cercare di farlo funzionare diversamente in riflesso.

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

Provalo online!

Questa è una porta della risposta Python di Curtis Bechtel a Ruby, giocata a golf un po 'di più.

In realtà, il suo programma Python è un poliglotta e funziona anche su Ruby, quindi la mia prima risposta è stata una copia-incolla di esso, ma sembrava ingiusto. Quindi ho scritto uno script che genera una nuova risposta a partire da uno script di base. Puoi provarlo qui:

Costruisci il tuo

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

Spiegazione: A :viene utilizzato per indicare un'etichetta, che è buona come un commento, quindi poiché il programma ha una simmetria rotazionale l'unica differenza tra le due versioni è quale delle @linee è la prima, nel qual caso una lefto rightviene emessa prima dello script uscite.

Ho provato a sovrapporre in modo creativo le linee ruotate tra loro, ma il mio tentativo in realtà è finito con una griglia più grande.

Modifica: salvato 117 byte grazie a @ ØrjanJohansen.

05AB1E (legacy) , 89 55 byte

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

Approccio molto basilare. Uscite in minuscolo completo.

Provalo online o provalo online riflesso (ogni rotazione è la stessa).

Spiegazione:

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

invertito:

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

Vedi questo mio suggerimento 05AB1E (sezione Come usare il dizionario? ) Per capire perché '…¸è "left"ed 'ĩè "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. 

Esegui ed esegui il debug

Questa è la variante "giusta".

Incantesimi runici , 116 byte

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

Provalo online!

E invertito

Non esattamente una porta, ma ha utilizzato la risposta Klein 000 di Post Left Garf Hunter come punto di partenza, data la tipica quasi compatibilità delle due lingue (la maggior parte dei comandi è la stessa e la disposizione dei bordi in Runic è identica a Klein 000). L'unico problema era che gli IP di Klein iniziano sempre dall'angolo in alto a sinistra e quelli di Runic no. In quanto tali, .fanno tutti parte del codice originale e sono ancora trattati come NOP da Runic, mentre sono i NOP che ho dovuto aggiungere come parte del controllo del flusso.

Stampa "left"in tutte e 4 le rotazioni e "right"quando è specchiato (e in tutte e quattro le rotazioni). Due colonne centrali erano completamente inutilizzate dopo le mie modifiche, quindi sono stato in grado di rimuoverle.

In teoria una rotazione con molti spazi bianchi finali potrebbe essere utilizzata per un conteggio di byte inferiore (ad es. Questa variante ), tuttavia gli spazi sono necessari per ruotare correttamente la struttura utilizzando strumenti esterni e quindi li ho inclusi.

Le varianti seguenti contengono i blocchi non utilizzati che sono stati rimossi, ma per il resto identici:

Tutte e quattro le sinistre . Output leftleftleftleft(il fatto che tutti e quattro possano essere eseguiti in questo modo è una coincidenza).

Destra 1 , Destra 2 , Destra 3 , Destra 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! Ci è voluto più tempo di quanto mi aspettassi, a metà strada mi sono reso conto che il riflesso era verticale , non orizzontale come avevo programmato! Sono abbastanza sicuro che funzioni, ma se ho fatto un errore per favore fatemelo sapere. Molto probabilmente questo può essere giocato a golf in modo ridicolo in più, ho appena preso un metodo di forza bruta estrema per farlo. La stessa forma è in realtà un quadrato, è tecnicamente simmetrica, tranne che sull'asse X, quindi quando si gira, invece restituisce "DESTRA" !!!

Il carattere che ha reso possibile questo programma è la 'A', che consente il teletrasporto all'inizio di una certa linea!

Provalo online!