Je vous présente fièrement ...
<}74}}:23}29}59}}}}}}}:111_}}}}:::::::23_}:111
? @
:" }}_47}_95 3""""""""(
_ : } _ } {=}
2 23_}29_ _ ; : \
0 ; 3 +_( 3_" 60{ .{.{.
"-_95:}}"" 2 0 ) 2 " _ _ {
"" _ : 2 _ ."(; } 3 .{
;_92}_47} : _ 0 = : * ;
: "" 2 {.{{ . -""(
}}:59_}}:::: "";_ . { _ "
} " {.{.{. 32.
}}}_95:}}}}_20-
... mon nouveau Labyrinthe Esolang en deux dimensions! Le code ci-dessus n'est pas incroyablement bien joué (il y a 161 espaces et 25 NOP, donc une meilleure disposition pourrait raccourcir cela beaucoup), mais au moins j'ai réussi à montrer que le langage est utilisable pour des tâches non triviales. :)
Comment ça marche
Tout d'abord, un bref aperçu de la langue:
- Labyrinth fonctionne sur deux piles, principale et auxiliaire , qui peuvent contenir des entiers signés arbitraires. Au bas des deux piles, il y a une quantité infinie de zéros.
- Les commandes sont des caractères individuels sur une grille 2D et elles forment un labyrinthe (c'est-à-dire que les personnages inconnus, en particulier les espaces, sont des murs).
"est un NOP qui n'est pas un mur et peut être utile pour remplir certains chemins dans le code. Contrairement à de nombreux autres langages 2D, les bords ne s'enroulent pas .
- Le pointeur d'instruction (IP) commence au premier caractère non mural (dans l'ordre de lecture) se déplaçant vers la droite.
@termine le programme.
- Si possible, l'IP suit les couloirs (également autour des virages). Si l'IP a plusieurs cellules vers lesquelles se déplacer, elle tournera généralement à gauche si le haut de la pile principale est négative, se déplacera tout droit si elle est nulle ou tourner à droite si elle est positive. Lorsque l'IP frappe un mur, il change de direction. (Il existe quelques subtilités supplémentaires, mais elles ne devraient pas avoir d'importance pour ce code.) C'est le seul moyen d'implémenter le flux de contrôle.
- Outre les commandes arithmétiques et de manipulation de pile, le code source peut être modifié au moment de l'exécution avec les quatre commandes
>v<^qui décaleront une ligne ou une colonne du code source de façon cyclique d'une cellule. La ligne ou la colonne affectée dépend du haut de la pile. Si la propre ligne ou colonne de l'IP est décalée, elle se déplacera avec le décalage. Cela permet de sauter d'un bord du code source à l'autre.
Maintenant, pour ce défi particulier, voici l'idée générale de l'algorithme:
- Poussez les extrémités des voitures jusqu'aux capots (c.-à-d.
/ \_o oo o) Sur la pile auxiliaire.
- Lisez l'entrée et déterminez s'il faut pousser
__ou /\continuer.
- Poussez le reste des voitures (c'est
__ __ _/ \-à- dire et deux espaces de tête) sur la pile auxiliaire.
- CLAMP l'entrée à une valeur maximale de
20, Appelons cette N .
- Effectuez maintenant les 3 opérations suivantes:
- Imprimez N espaces.
- Imprimez 6 caractères enregistrés.
- Imprimez 60 à 3 * N espaces.
- Imprimez 6 caractères enregistrés.
- Imprimez une nouvelle ligne.
Enfin, regardons quelques parties du code. L'IP commence dans le coin supérieur gauche, sur une commande de décalage de grille. Le haut de la pile principale est 0(qui est utilisé comme index relatif), de sorte que la première ligne est décalée vers la gauche, ce qui déplace également l'IP à l'extrémité droite de la grille. Maintenant, la première ligne est simplement exécutée de droite à gauche, ce qui pousse le premier jeu de caractères fixes sur la pile auxiliaire:
}74}}:23}29}59}}}}}}}:111_}}}}:::::::23_}:111<
Ce décalage de ligne est utile pour le golf lorsque vous souhaitez commencer avec une grande quantité de code linéaire.
Ensuite, nous lisons l'entrée et poussons les bons bonnets:
?
:"
_
2
0 ;
"-_95:}}""
"" _
;_92}_47}
Le bit à gauche avec les trois NOP envoie des résultats négatifs le long de la branche supérieure et des résultats non négatifs le long de la branche inférieure. À droite, ils sont réunis.
Suit maintenant une autre grande section linéaire (qui pourrait probablement être beaucoup jouée avec une autre astuce de changement de ligne):
}}_47}_95
: }
23_}29_ _
3
2
:
:
:
}}:59_}}::::
}
}}}_95:}}}}
Cela pousse le reste des voitures sur la pile auxiliaire.
Ensuite, nous calculons min(20, input), qui est similaire à la première branche:
;
+_(
0 )
2 _
_ 0
"" 2
"";_
"
_20-
Enfin, nous avons la boucle qui s'exécute trois fois pour imprimer les lignes. Chaque itération de la boucle contient deux petites boucles (3x3) pour imprimer les espaces, ainsi que deux sections pour imprimer 6 caractères de la pile auxiliaire:
@
3""""""""(
_ } {=}
: \
3_" 60{ .{.{.
2 " _ _ {
."(; } 3 .{
= : * ;
{.{{ . -""(
. { _ "
{.{.{. 32.
Une astuce astucieuse sur laquelle je voudrais attirer l'attention est .{.{.le côté droit. C'est une impasse, donc à part .à la fin, le code est exécuté deux fois, une fois en avant et une en arrière. Cela donne un moyen pratique de raccourcir le code palindromique (le problème est que vous devez vous assurer que l'IP prend le bon virage lorsque vous sortez à nouveau de l'impasse).
/ \plutôt qu'en baisse_ _?