Il y a une vieille histoire à propos d'un tailleur de pierre qui n'a jamais été satisfait de ce qu'il était. Il souhaitait pouvoir devenir le soleil, et il l'était. Bloqué par les nuages, il souhaitait être - et est devenu - un nuage. Quand le vent a soufflé, il s'est souhaité devenir le vent. Arrêté par la montagne, il souhaitait être une montagne, et le devint ainsi. Bientôt, cependant, il était piraté par un tailleur de pierre et souhaitait être tailleur de pierre.

De même, votre tâche consiste à écrire un programme qui n'est jamais satisfait de la langue dans laquelle il se trouve. Votre programme doit produire un ensemble de remplacements d'expressions régulières pour le transformer en une langue différente. Etc.

Règles

1. Écrivez un programme dans la langue de votre choix.
2. Le programme doit produire une série d'au moins deux segments. Un segment est un groupe de texte, séparé par des points-virgules. Cependant, si un point-virgule est contenu dans une expression régulière, de sorte que sa décomposition entraînera une syntaxe non valide, il ne sépare pas les segments. Voir l'exemple.
3. Le premier segment est un modèle d'expression régulière à rechercher, et le second segment est le modèle de remplacement. Le troisième est un autre motif de «recherche», et le quatrième est un motif de «remplacement», etc.
4. Appliquez les modèles d'expression régulière au programme. Remplacez le motif sur le premier segment par un sur le second; remplacez le troisième motif par celui du quatrième, et ainsi de suite.
5. Le résultat devrait être un programme dans une langue différente, qui, elle-même, suit les règles 2 à 4.
6. Les langues utilisées doivent former un cycle infini et répétitif.
   • Par exemple, Python -> PHP -> C ++ -> Python -> PHP -> C ++ -> Python -> ...
7. Votre score est la période du cycle. Les liens sont rompus par la longueur de code initiale la plus courte.
   • Dans l'exemple ci-dessus, le score est de trois.
8. À chaque itération du cycle, aucune langue ne peut être utilisée plus d'une fois.
9. Pour les règles 5 et 7, les langages compatibles (C et C ++) et les différentes versions du même langage (Python 2 et Python 3) sont considérés comme identiques.
10. Les programmes eux-mêmes n'ont pas besoin de se répéter.
    • Dans l'exemple ci-dessus, les premier et quatrième programmes peuvent être différents.
11. Toute version de regex est acceptable, mais la même doit être utilisée pour tous les programmes.
12. La sortie totale de chaque programme ne doit pas dépasser 100 caractères.
13. Chaque sortie doit contenir des instructions pour modifier réellement le programme. Autrement dit, deux programmes consécutifs du cycle peuvent ne pas être identiques.

Exemple

Python -> Ruby -> Python -> ...

print "uts;Z;rint;uts;Z(?=;Z);rint"

Les sorties:

uts;Z;rint;uts;Z(?=;Z);rint

Les segments sont:

FIND     ;    REPLACE
uts      ;    Z
rint     ;    uts
Z(?=;Z   ;    rint   (breaking the first segment in two would result in invalid syntax)

L'application des remplacements d'expressions régulières, dans l'ordre, nous donne:

print "Z;Z;rint;Z;Z(?=;Z);rint"      # replace each "uts" with "Z"
puts "Z;Z;uts;Z;Z(?=;Z);uts"         # replace each "rint" with "uts"
puts "rint;Z;uts;rint;Z(?=;Z);uts"   # replace each "Z" followed by ";Z" with "rint"

L'exécution de la dernière ligne nous donne les instructions pour transformer cela en code Python.

2 langues: Python, Ruby; 33 29 octets

Voici une autre façon de faire Python et Ruby, qui est un peu plus courte que celle du défi:

Python:   print'^;puts"^.*?\\42#\\73"#'
prints:   ^;puts"^.*?\42#\73"#

Ruby:     puts"^.*?\42#\73"#print'^;puts"^.*?\\42#\\73"#'
prints:   ^.*?"#;

Il ne devrait pas être trop difficile d'ajouter PHP dans le mix.

2 langues: Python 2 et Befunge-93, 77 octets

Après avoir lu attentivement les règles cette fois , j'ai trouvé une vraie réponse. Il ne gagnera aucun prix, mais Befunge est trop amusant à programmer.

u=u">>>>>:#,_@;Z;print;>>>>>:#,_@;Z(?=;Z);print;<v;Y;u;<v;Y(?=;Y);u"
print u

Ce programme Python génère:

>>>>>:#,_@;Z;print;>>>>>:#,_@;Z(?=;Z);print;<v;Y;u;<v;Y(?=;Y);u

Ce qui donne ces remplacements:

FIND         REPLACE
>>>>>:#,_@   Z
print        >>>>>:#,_@
Z(?=;Z)      print
<v           Y
u            <v
Y(?=;Y)      u

Ce qui transforme le programme en ce programme Befunge:

<v=<v"print;Z;>>>>>:#,_@;print;Z(?=;Z);>>>>>:#,_@;u;Y;<v;u;Y(?=;Y);<v"
>>>>>:#,_@ <v

Je vais peut-être voir si je peux en faire une ligne. Franchement, je suis un peu surpris que Befunge travaille pour ce genre de problème.

(Désolé pour la suppression et la suppression d'un groupe; je paniquais une seconde parce que je pensais que le programme n'avait peut-être pas fonctionné.)