Rétine , 353 339 178 175 150 130 129 129 117 octets
R
5$*r
T`aq\we\ds`so`r.+
)`r(.*)
$1
^
:
a
sq
e
wd
+`(.+)q
w$1
+`(.+)d
s$1
+`sw
(.*)(\1w?):
$0$2
+`sw|ws
w+
-$0
\w
1
La sortie est en unaire, séparée par deux points. Cela signifie que vous ne verrez pas vraiment de zéros dans la sortie (bien que la présence de deux points vous dira laquelle des deux coordonnées est nulle, s'il n'y en a qu'une).
Essayez-le en ligne!
C'était vraiment amusant et a fini par être étonnamment court. :)
Explication
Quelques antécédents en premier. Il existe plusieurs systèmes de coordonnées pour décrire les grilles hexagonales. Celui qui a demandé utilise des coordonnées de décalage. C'est essentiellement comme les coordonnées de la grille rectangulaire, sauf qu'un axe "oscille" un peu. En particulier, la question demande la disposition "impaire-q" affichée sur la page liée. Ce système de coordonnées est un peu ennuyeux à utiliser, car la façon dont les coordonnées changent pendant un mouvement dépend non seulement de la direction du mouvement, mais également de la position actuelle.
Un autre système de coordonnées utilise des coordonnées axiales. C'est essentiellement imaginer l'hexgrid comme une tranche diagonale à travers un volume de cubes, et utiliser deux des axes (par exemple x et z) pour trouver une position sur le plan 2D. Sur la grille hexagonale, cela signifie que les deux axes forment un angle de 60 (ou 120) degrés. Ce système est un peu moins intuitif mais beaucoup plus facile à utiliser, car chaque direction correspond à un vecteur "delta" fixe. (Pour une meilleure explication de la façon d'arriver à ce système de coordonnées, consultez le lien et les jolis diagrammes et animations là-bas.)
Alors, voici ce que nous allons faire: nous calculons le mouvement en coordonnées axiales (en prenant soin de la rotation comme suggéré dans le défi, en remappant la signification des commandes), et lorsque nous avons terminé, nous convertissons l'axial en offset impair-q coordonnées.
Les six mouvements correspondent aux vecteurs delta suivants en coordonnées axiales (xz):
q => (-1, 0)
w => ( 0, -1)
e => ( 1, -1)
d => ( 1, 0)
s => ( 0, 1)
a => (-1, 1)
Attendez, c'est Retina, nous devrons travailler avec des nombres unaires. Comment travaillons-nous avec des nombres unaires négatifs? L'idée est d'utiliser deux chiffres différents. L'un représente +1et l'autre représente -1. Cela signifie que, que nous voulions ajouter ou soustraire 1de la position actuelle, nous pouvons toujours le faire en ajoutant un chiffre. Lorsque nous avons terminé, nous réduisons le résultat dans son amplitude (du chiffre correspondant) en annulant les chiffres équilibrés. Ensuite, nous déterminons le signe en fonction du chiffre restant et remplaçons tous les chiffres par 1.
Le plan est de construire les composantes axiales x et z à gauche et à droite de a :(comme séparateur), devant l'entrée. wet ss'ajoutera au côté droit. qet ds'ajoutera au côté gauche, et eet as'ajoutera aux deux côtés. Puisque wet ssont déjà du bon côté de :(qui ira devant), nous les utiliserons respectivement comme les chiffres -1et +1.
Passons en revue le code.
R
5$*r
Nous commençons par transformer chacun Ren cinq rs. Bien sûr, un virage à gauche est le même que cinq virages à droite sur une grille hexadécimale, et ce faisant, nous pouvons faire beaucoup de duplication sur l'étape de remappage.
T`aq\we\ds`so`r.+
Il s'agit d'une étape de translittération qui fait tourner les six commandes, si elles sont trouvées après la première r(traitant ainsi la première r). wet ddoivent être échappés pour les empêcher de se développer dans les classes de caractères. L' oinsère l'ensemble source dans l'ensemble cible, ce qui enregistre un tas d'octets pour ces tâches de rotation. Le mappage de caractères est donc:
aqweds
saqweds
où le dernier sde la deuxième ligne peut simplement être ignoré.
)`r(.*)
$1
Cela supprime le premier rde la chaîne, car il a été traité (j'aurais aimé avoir déjà implémenté des limites de substitution ...). Le )indique également à Retina d'exécuter toutes les étapes jusqu'à celle-ci en boucle jusqu'à ce que la chaîne cesse de changer. Lors des itérations suivantes, la première étape est un no-op car il n'y a plus de Rs et la deuxième étape appliquera une autre rotation tant qu'il restera des rs dans la chaîne.
Lorsque nous avons terminé, nous avons mappé toutes les commandes dans la direction à laquelle elles correspondent sur la grille non tournée et pouvons commencer à les traiter. Bien sûr, ce mouvement n'est qu'une somme de ces vecteurs delta, et les sommes sont commutatives, donc peu importe dans quel ordre nous les traitons maintenant que les rotations ont été éliminées.
^
:
Insérez le délimiteur de coordonnées à l'avant.
Maintenant, nous n'avons pas vraiment besoin de traiter set w. Ils sont nos +1et -1chiffres et ils sont déjà du bon côté du :donc ils vont juste abandonner comme requis à la fin. Nous pouvons faire une autre simplification: aest simplement s + qet eest w + d. Faisons cela:
a
sq
e
wd
Encore une fois, ceux-ci set wabandonneront. Tout ce que nous devons faire est de déplacer ces qs et ds vers l'avant et de les transformer en ws et ss eux-mêmes. Nous le faisons avec deux boucles distinctes:
+`(.+)q
w$1
+`(.+)d
s$1
Alors c'est fait. Temps de conversion des coordonnées axiales en coordonnées décalées. Pour cela, nous devons réduire les chiffres. Cependant, pour l'instant, nous ne nous soucions que du côté gauche. En raison de la façon dont nous avons traité les qs et les ds, nous savons que tous les ss du côté gauche apparaîtront devant tous les ws, nous n'avons donc qu'à vérifier une paire pour les réduire:
+`sw
Maintenant, la conversion réelle. Voici le pseudocode, extrait du lien ci-dessus:
# convert cube to odd-q offset
col = x
row = z + (x - (x&1)) / 2
Droite, donc le côté gauche est déjà correct. Le côté droit a cependant besoin du terme de correction (x - (x&1)) / 2. La prise &1est la même que pour le modulo 2. Elle est essentiellement analysée comme une x/2division entière, arrondie vers moins l'infini. Donc, pour le positif x, nous ajoutons la moitié du nombre de chiffres (arrondi vers le bas), et pour le négatif x, nous soustrayons la moitié du nombre de chiffres (arrondi vers le haut). Cela peut être exprimé de manière étonnamment concise en expression régulière:
(.*)(\1w?):
$0$2
En raison de la gourmandise, même x, le groupe 1 correspondra exactement à la moitié des chiffres, \1l'autre moitié et nous pouvons ignorer le w?. Nous insérons cette moitié après le :(qui est x/2). Si xc'est pair, alors nous devons distinguer le positif du négatif. Si xest positif, alors w?ne correspondra jamais, donc les deux groupes devront toujours correspondre au même nombre de chiffres. Ce n'est pas un problème si le premier sest simplement ignoré, alors nous arrondissons. Si xest négatif et impair, alors la correspondance possible est avec \1(la moitié de l' xarrondi vers le bas) et celle facultative w. Étant donné que les deux vont dans le groupe 2, nous écrirons x/2avec la magnitude arrondie (au besoin).
+`sw|ws
Maintenant, nous réduisons les chiffres sur le côté droit. Cette fois, nous ne connaissons pas l'ordre des set w, nous devons donc tenir compte des deux paires.
w+
-$0
Les deux parties sont maintenant réduites à un seul chiffre répété (ou rien). Si ce chiffre est w, nous insérons un signe moins devant.
\w
1
Et enfin, nous transformons à la fois en wet sen un seul chiffre unaire raisonnable. (Je suppose que je pourrais enregistrer un octet en utilisant wou scomme chiffre unaire, mais cela semble un peu étiré.)
Python (3,5)
193185182 octetsJe calcule également en coordonnées axiales et convertis à la fin.
J'ajoute une optimisation selon la solution @Martin Büttner: je remplace R par r * 5, cela ne change pas le nombre d'octets. Mais avec ce changement, nous pouvons remplacer le deuxième test
elif j=='r'par justeelseLa solution suppose que nous ne pouvons pas avoir de caractères invalides dans l'entrée.
Non golfé
Usage
la source
Lot,
708636586569 octetsJ'ai utilisé des coordonnées y doublées car cela simplifiait les calculs. Je ne suis pas sûr d'avoir pris en compte la rotation de la manière la plus idéale, mais c'est mieux que de compter le nombre de
rs.Edit: économisé 72 octets en améliorant la gestion de l'
Rart. 60 octets enregistrés en optimisant messet/arelevés. 17 octets enregistrés avec quelques optimisations mineures.la source
05AB1E , 60 octets
Essayez-le en ligne ou vérifiez tous les cas de test .
Explication:
Explication générale:
Nous commençons par une chaîne
"qwedsa"et une coordonnée[0,0], et bouclons sur les caractères de l'entrée.S'il s'agit d'un "r" ou d'un "R", nous faisons tourner cette chaîne respectivement vers la gauche ou la droite.
Sinon, nous obtenons l'index basé sur 0 dans cette chaîne et le mappons comme suit:
Explication du code:
Voir cette astuce 05AB1E (section Comment compresser des chaînes ne faisant pas partie du dictionnaire? ) Pour comprendre pourquoi
.•F?äM•est"qwedsa".la source
Python 3, 227 octets
la source
Python 3.5.0b3sur MacOS, et même si j'ai eu une erreur dans 5 et 6, en raison de l'arrondissement, le reste était correct. (Depuis fixe via Edit). Quelle version de Python utilisez-vous?