Une forme est chirale si aucune rotation ne peut lui donner l’image miroir. Dans ce puzzle, nous allons écrire des programmes informatiques chiraux.

Pour ce casse-tête, nous allons considérer un programme comme une matrice rectangulaire de caractères. En tant que telles, toutes les solutions à ce défi doivent être rectangulaires (c’est-à-dire que toutes les lignes doivent être de la même longueur). Nous pouvons effectuer une rotation de ces programmes par incréments d'un quart de tour. Par exemple le programme

The quickish fish
    lept deftly  
  rightwards     

Lorsque tourné d'un quart de tour dans le sens des aiguilles d'une montre ressemble à

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

Nous pouvons également refléter ces programmes. Voici le même programme reflété sur un axe vertical:

hsif hsikciuq ehT
  yltfed tpel    
    sdrawthgir   

Un programme chiral est un programme qui, lorsqu'il est pivoté, génère toujours " left". Cependant, lorsque reflété, produit un programme qui génère " right" peu importe le nombre de rotations.

Votre tâche est d’écrire un programme chiral avec le moins d’octets possible.

Règles supplémentaires

• La sortie n'est pas sensible à la casse mais doit être cohérente. (Par exemple, vous pouvez éditer " LEFT" et " rIgHt" mais ce boîtier doit être cohérent sous les rotations)

• Les lignes doivent être divisées sur une nouvelle ligne ou une nouvelle ligne et un saut de ligne.

• Votre programme doit être un rectangle, vous pouvez le remplir avec des espaces ou des commentaires mais chaque ligne doit avoir la même longueur.

• Vous pouvez éventuellement avoir une nouvelle ligne de fin (ou une nouvelle ligne et un saut de ligne) sur tous vos programmes si vous le souhaitez.

Pascal (FPC) , 2161 755 349 octets

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

Essayer à gauche

Essayer juste

@tsh m'a motivé à réessayer quand j'ai vu son programme (en commentaire) et le voici!

Précédent avec 755 octets:

 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 

Essayer à gauche

Essayer juste

Si vous avez vu ma soumission précédente, oubliez-la :)

Toutes les rotations des programmes gauche et droit sont identiques.

Klein (000) , 109 87 octets

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

Essayez-le en ligne!

Devrait être possible d'obtenir une version plus courte de cette réponse, alors bonne chance!

Cette réponse est inspirée par des spirales. En particulier, l'idée est deux spirales imbriquées, une pour la gauche et une pour la droite. Il a une double symétrie, nous pouvons donc vérifier les programmes suivants pour savoir si cela fonctionne:

Quart de tour

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

Essayez-le en ligne!

En miroir

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

Essayez-le en ligne!

Miroir et quart de tour

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

Essayez-le en ligne!

Klein (000) , 27 à 25 octets

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

Essayez-le en ligne! Tourné une fois! Tourné deux fois! Tourné trois fois!

Et retourné: essayez-le en ligne! Tourné une fois! Tourné deux fois! Tourné trois fois!

Le seul qui m'a donné un peu de peine est l'inversion et la rotation, qui ressemble à:

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

Ceci est la seule raison pour les deux ensembles de ((.

Klein (211) , 37 octets

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

Cela a un programme différent pour chaque rotation.

Explication

Notez que chacun de ces programmes est ajouté à un carré avec no-ops avant exécution

Pas de changement

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

Essayez-le en ligne!

!fait sauter l'exécution par dessus \, "left"@charge la chaîne "left"dans la pile et termine le programme imprimant la pile

Quart de tour

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

Essayez-le en ligne!

L'exécution se déroule dans le coin supérieur droit du carré, continue dans le coin inférieur gauche et !\"left"@imprime à nouveau "left.

Demi tour

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

Essayez-le en ligne!

Ici, le chemin d'exécution sort par le côté nord, rentre par le côté ouest, ressort par l'est avant d'entrer dans le sud. \fait rebondir le chemin "left"@pour l’imprimer.

Trois quarts de tour

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

Essayez-le en ligne

L'exécution sort du coin supérieur droit, puis rentre en bas à gauche. Une fois encore, les miroirs /\redirigent le chemin "left"@pour l’imprimer.

Réflexion

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

Ceci est essentiellement le même que pour gauche dans toutes les rotations.

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

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

En miroir

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

Essayez-le en ligne!

(Veuillez consulter le lien TIO pour tous les cas de test, y compris la version en miroir)

Bien que plus golfé, taille 22x22 -> 21x21à crédit de @JoKing!

Taille 38x38 24x24 22x22 21x21 18x18 17x17 16x16, symétrie 4 fois.

Voici une question - est-il possible d'avoir 15x15 ou plus petit pour JS? Il me semble qu’il me faut au moins le séparateur de commentaires entre deux sous-blocs et au bord, donc au moins 7 + 2 + 2 + 5 = 16 lignes?

Toile , 109 89 71 octets

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

Essayez-le ici | Essayez inversé! Ce sont les deux seuls programmes possibles, car le programme est symétrique par rotation.

Fabriqué en cela .

Gol> <> , 23 octets

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

Essayez-le en ligne!

C'est le même format que ma réponse de Klein , mais 2 octets plus court. Peut-être existe-t-il un autre langage 2D permettant de jouer au golf sur ces 2 derniers octets ... Mais pour l'instant, c'est aussi court que possible.

Alice , 25 octets

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

Gauche: normal , 1/4 de tour dans le sens horaire , 1/2 tour , 1/4 de tour dans le sens anti-horaire

À droite: l' image sur l' axe horizontal , diagonal droite , axe vertical , diagonal en haut à droite

Explication

Ce programme comporte trois parties. La première partie est les trois {et une }sur les coins. Le {tour de la gauche IP jusqu'à ce qu'il atteigne le }, à quel point il tourne à droite. Dans la version reflétée, l'adresse IP suit la ligne du haut du programme d'origine. Dans la version originale, en tournant à droite, vous frappez immédiatement la partie adjacente {, en indiquant l’adresse IP le long de la dernière ligne du programme original.

Viennent ensuite les deux barres obliques dans la deuxième colonne. Si le programme est orienté horizontalement, l'un ou l'autre type de barre oblique changerait simplement en mode ordinal, envoyant l'adresse IP dans la même direction gauche / droite que celle déjà suivie. Si le programme est orienté verticalement, l'IP rebondit beaucoup plus, mais le fait de les rendre obliques donne le même résultat final. (Deux barres obliques inverses donneraient le résultat opposé et une de chacune créerait une boucle infinie.)

Le reste du programme est simple. L'IP en mode ordinal rebondit en diagonale. Par conséquent, l'un "left"o@ou l' autre "right"o@sera exécuté en fonction de la manière dont cette section a été entrée.

Hexagonie , 98 octets

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

Essayez-le en ligne! | Tourné à 90 ° | Tourné à 180 ° | Tourné à 270 °
inversé | Tourné à 90 ° & inversé | Tourné à 180 ° et inversé | Tourné à 270 ° et inversé

Hexagony était assez amusant pour ce défi, car une rotation ou un renversement peut changer radicalement le programme actuel. Chaque rotation / inversion est son propre programme. Certains chemins d’exécution de programme sont beaucoup plus intéressants que d’autres.

Je conviens que cela a pris plus de temps que prévu. Je suis à peu près sûr qu'une réponse plus courte peut être faite en hexagone, alors bonne chance!

Ruby , 131 octets

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

Essayez-le en ligne!

APL (dzaima / APL) , 181 octets

Le programme a une symétrie de rotation, de sorte que seuls deux cas doivent être vérifiés

La gauche

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

Essayez-le en ligne!

Droite

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

Essayez-le en ligne!

Explication

C'est mon premier programme APL, donc c'est assez simple. Il utilise seulement un truc que je trouve intéressant.

Si nous commençons par éliminer tous les commentaires, nous obtenons les programmes suivants

La gauche

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

Droite

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

À partir du programme de gauche, nous faisons trois choses.

1. Assigner 'lef'à la variablet

2. Imprimer la variable tet la lettre't'

3. Assigner 'righ'à la variablet

Maintenant, parce que c'est le miroir, le bon programme fait ces trois étapes, mais dans l'ordre inverse. Cela signifie que nous imprimons 'left'pour le programme de gauche et 'right'pour le programme de droite.

L’un des trucs ici est qu’il 't's’agit en réalité d’une copie tournée du code. Si vous regardez la troisième colonne de notre code, vous verrez que c'est le cas 't'. Nous réutilisons cela 't'dans les versions alternées pour ajouter ce tqui est nécessaire.

Haskell , 461 379 octets

82 octets enregistrés par Ø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----------_--

Essayez-le en ligne!

Comme celui-ci présente une symétrie quadruple, il vous suffit de tester le miroir:

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

Essayez-le en ligne!

C'est un début. C'est loin d'être idéal, mais il y a quelques choses intéressantes qui se passent ici. Haskell est certainement une langue intéressante pour ce défi. J'attends avec impatience une réponse qui bat cette idée, que ce soit la mienne ou celle de quelqu'un d'autre.

Prolog (SWI) , 649 188 octets

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

Essayez-le en ligne!

Non retourné, tourné

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

Essayez-le en ligne!

Retourné, non tourné

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

Essayez-le en ligne!

Retourné, tourné

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

Essayez-le en ligne!

Prolog (SWI) , 239 223 209 181 octets

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

Essayez-le en ligne!

Comme le programme a 4 symétries, il vous suffit de vérifier le miroir:

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

Essayez-le en ligne!

Python 2 , 209 octets (14 x 14)

Normal (à gauche):

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

Essayez-le en ligne!

Reflété (à droite):

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

Essayez-le en ligne!

Propre , 1331 1055 octets

-276 octets grâce à Ø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//////////// //
// ///////////;/;//////////// //

Essayez "laissé" en ligne!

Essayez "juste" en ligne!

C'était difficile pour plusieurs raisons:

• Nettoyer nécessite qu'un en-tête de fichier module <filename>soit présent au début et que seul le début du fichier. Malheureusement, cela signifie que pour que les rotations du programme en miroir soient valides, elles doivent également figurer au bas du fichier. Pour aggraver cela, module ..n’est pas valable pour global let .. in, where ..et with ..définitions; et le jeton qui moduleapparaît s'il n'a pas été défini provoque une erreur.
• Les commentaires de bloc et les commentaires de ligne sont imbriqués: /* /* */laisse un niveau de commentaire ouvert, et il en va de même /* // */(ainsi que le commentaire du reste de la ligne).
• La même fonction peut être définie plusieurs fois, mais uniquement directement après.

Heureusement, nous pouvons définir modulecomme quelque chose dans une #..expression (laissez-avant), qui est tout ce dont nous avons besoin. Parce que Clean ne vérifie pas les variantes qui ne sont jamais utilisées (et une variété d’autres choses tout aussi inutilisées), la deuxième définition requise de Startpeut être un déchet complet. Cela nous permet d'utiliser le second Startconsommer l' en- tête du module au fond du dossier parce que Clean traite m module men appelant la fonction msur moduleet m(qui , depuis que nous avons défini moduleet m, ne provoque pas une erreur). Peu importe qu’il ms’agisse d’une chaîne et non d’une fonction, l’ Startalternative n’est jamais vérifiée.

C'est plus facile à voir si vous le regardez à travers les yeux du compilateur:

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

Brachylog , 341 octets

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

Essayez-le en ligne!

! enilno ti yrT

Profite de Brachylog en prenant le prédicat principal comme étant celui de la première ligne et ne se souciant pas beaucoup des autres lignes au-delà de l’obligation de les compiler. Non réfléchi, il imprime une chaîne vide suivie de "left" sur la même ligne, et réfléchi, une chaîne vide suivie de "right" sur la même ligne. Je suis tenté de penser qu'il pourrait y avoir un moyen de faire une version (utilement) non-carrée ṇ, mais cela pourrait être bien compliqué sans essayer de le faire fonctionner différemment à la réflexion.

Ruby , 181 octets

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

Essayez-le en ligne!

Ceci est un port de la réponse de Curtis Bechtel en Python à Ruby, qui joue au golf un peu plus.

En fait, son programme Python est un polyglotte et tourne également sur Ruby. Ma première réponse fut donc un copier-coller, mais cela me semblait injuste. J'ai donc écrit un script qui génère une nouvelle réponse à partir d'un script de base. Vous pouvez l'essayer ici:

Construit le tien

Lot, 438 321 octets

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

Explanation: A :est utilisé pour indiquer une étiquette, qui vaut un commentaire. Par conséquent, comme le programme a une symétrie de rotation, la seule différence entre les deux versions est de savoir laquelle des @lignes est la première, auquel cas leftou rightest affiché avant le script. sorties.

J'ai essayé de superposer de manière créative les lignes pivotées, mais ma tentative s'est en fait terminée avec une grille plus grande.

Edit: 117 octets sauvegardés grâce à @ ØrjanJohansen.

05AB1E (hérité) , 89 55 octets

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

Approche très basique. Les sorties sont en minuscules.

Essayez-le en ligne ou essayez-le en ligne (chaque rotation est la même).

Explication:

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

Renversé:

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

Voir ce conseil 05AB1E (section Comment utiliser le dictionnaire? ) Pour comprendre pourquoi '…¸est "left"et 'ĩest "right".

Stax , 131 octets

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

Exécuter et déboguer

C'est la "bonne" variante.

Enchantements runiques , 116 octets

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

Essayez-le en ligne!

Et inversé

Pas vraiment un port, mais la réponse Klein 000 de Garf Hunter de Post Left est utilisée comme point de départ, étant donné la quasi-compatibilité typique des deux langues (la plupart des commandes sont identiques et l’emballage des bords dans Runic est identique à Klein 000). Le seul problème était que les IP de Klein commençaient toujours par le haut à gauche, contrairement à Runic. En tant que tels, ils .font tous partie du code original et sont toujours traités en tant que NOP par Runic, alors que ce sont des NOP que je devais ajouter dans le cadre du contrôle du flux.

Imprime "left"dans les 4 rotations et en "right"cas de reflets (et dans les quatre rotations correspondantes). Deux colonnes du milieu étaient complètement inutilisées après mes modifications, j'ai donc pu les supprimer.

En théorie, une rotation avec beaucoup d'espaces finaux pourrait être utilisée pour un nombre d'octets inférieur (par exemple, cette variante ), mais les espaces sont nécessaires pour faire pivoter correctement la structure à l'aide d'outils externes et je les ai donc inclus.

Les variantes ci-dessous contiennent les fragments inutilisés qui ont été supprimés, mais sont par ailleurs identiques:

Les quatre gauches . Résultats leftleftleftleft(le fait que les quatre puissent être exécutés comme ceci est une coïncidence).

Droit 1 , Droit 2 , Droit 3 , Droit 4

Gol> <> , 342 octets

 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  

Hou la la! Cela a pris plus de temps que prévu, à mi-parcours, j'ai réalisé que le reflet était vertical , pas horizontal comme je l'avais codé! Je suis à peu près sûr que cela fonctionne, mais si je fais une erreur, faites-le-moi savoir. Cela peut très probablement être joué un peu plus ridicule, je viens de prendre une méthode de force brute extrême pour le faire. La forme elle-même est en fait un carré, elle est techniquement symétrique, sauf sur l'axe des x, donc quand elle bascule, elle retourne "DROIT" à la place !!!

Le personnage qui a rendu ce programme possible est le 'A', qui permet la téléportation au début d'une certaine ligne!

Essayez-le en ligne!