Vous vivez à l'intérieur d'un terminal de 80 caractères de large. Vous vous ennuyez, vous décidez donc de jouer aux dominos. Non, pas le genre ennuyeux qui ressemble au Scrabble, le genre amusant où vous passez une heure à les fixer pour les regarder tomber en une seconde.

Dans les terminaux, les dominos ressemblent à ceci:

|   upright domino
\   left-tilted domino
/   right-tilted domino
__  fallen domino

Comme nous le savons tous, si un domino incliné touche un montant, le deuxième domino est également incliné. La seule exception à cela est que si deux dominos inclinés le touchent:

|\ --> \\        /| --> //        /|\ --> /|\

Ajustez la constante gravitationnelle de votre terminal pour que cette transition prenne 100 ms.

Si un domino incliné est soutenu par un autre domino ou les murs du terminal, son voyage se termine.

Aucun des dominos inclinés dans

\||||____||||/__                /|\    /\    /|\                __\||||____||||/

(80 caractères) se déplacera, car les deux dominos inclinés les plus à l'extérieur sont supportés par les murs du terminal et tous les autres sont supportés par d'autres dominos.

Cependant, si l'espace dans le sens de l'inclinaison est vide, le domino tombe:

| \\ --> |__\        // | --> /__|

Terminal. Constante gravitationnelle. Tu obtiens le point…

Enfin, il y a un léger vent de gauche, donc les dominos inclinés à droite tombent plus vite que les dominos inclinés à gauche:

|/ \| --> |__\|

Tâche

Écrivez un programme / une fonction qui montre une animation de jouer aux dominos dans un terminal.

Votre code doit effectuer les opérations suivantes:

1. Lire une chaîne d'entrée, représentant l'état initial des dominos.

   Cette chaîne ne contiendra pas plus de 80 caractères et se composera uniquement des dominos décrits ci-dessus et des espaces vides.

2. Imprimez l'état et attendez 100 ms.

3. Transformez l'état comme expliqué ci-dessus.

4. Si l'état a changé, revenez à 2.

Règles supplémentaires

• La longueur de la chaîne d'entrée n'affecte pas la largeur du terminal; même si la chaîne est inférieure à 80 caractères, les murs du terminal sont toujours séparés de 80 caractères.

• Chaque fois que l'étape 2 est exécutée, l'état doit être imprimé au même emplacement, écrasant l'état précédent.

• Étant donné que certaines langues sont incapables d'attendre exactement 100 ms, n'hésitez pas à attendre n'importe quelle quantité entre 50 et 1000 ms.

• Les règles de code-golf standard s'appliquent.

Exemples

• Pour l'état initial

   ||\/||
  

  imprimer ce qui suit (l'un sur l'autre):

   ||\/||
   |\\//|
   \\\///
  __\\//__
  

• Pour l'état initial

  /||||\
  

  imprimer ce qui suit

  /||||\
  //||\\
  ///\\\
  

• Pour l'état initial

  /|||\
  

  imprimer ce qui suit

  /|||\
  //|\\
  

• Pour l'état initial

  |/ \|/ \|/ \|/ \|
  

  imprimer ce qui suit:

  |__\|__\|__\|__\|
  

• Pour l'état initial (80 caractères)

  \||||____||||/__                /|\    /\    /|\                __\||||____||||/
  

  imprimer ce qui suit

  \||||____||||/__                /|\    /\    /|\                __\||||____||||/
  

Rétine , 87 86 85 octets

Merci à Dennis d'avoir économisé 1 octet.

^.{0,79}$
$0 
:`^
<ESC>c
(`/ | \\
__
/\|(?!\\)
//a
(?<!/)\|\\
\\
$
aaaaa
a
aaaa
(a+)+b|a
<empty>

<ESC>doit être remplacé par le caractère de contrôle réel (0x1B). <empty>représente une ligne de fin vide. Vous pouvez ensuite exécuter le code ci-dessus à partir d'un seul fichier avec l' -sindicateur.

Le code nécessite un terminal qui prend en charge les codes d'échappement ANSI. Je ne peux pas supprimer le saut de ligne dans la sortie de Retina, j'ai donc besoin d'effacer la console entière à <ESC>cchaque fois. J'ai testé le code en bash en utilisant Mono pour exécuter Retina.

Explication

^.{0,79}$
$0 

Nous commençons par ajouter un espace si l'entrée contient moins de 80 caractères. Il en est ainsi pour qu'un /à l'extrémité droite ne doive pas être traité séparément.

:`^
<ESC>c

Maintenant, nous ajoutons <ESC>cla chaîne, qui est le code d'échappement ANSI pour effacer le terminal. Ainsi, chaque fois que la chaîne est imprimée, elle le fera en haut du terminal. Le :`demande à Retina d'imprimer le résultat de cette substitution, c'est-à-dire la configuration initiale.

(`/ | \\
__

(`commence une boucle. Puisqu'il n'y a pas de correspondance ), la boucle est supposée aller jusqu'à la dernière étape du programme. Chaque itération simulera une étape de la chute des dominos puis "dormira" un peu. Cette première étape remplace /et à \côté d'un espace en __. Cela gère automatiquement le / \cas correctement, car les correspondances ne peuvent pas se chevaucher et sont recherchées de gauche à droite. Donc, le /<sp>serait apparié et transformé en __tel que le \ne peut pas être apparié, et nous obtenons le bon __\.

/\|(?!\\)
//a

Cela devient /|à //condition qu'il n'y en ait pas à \côté. Nous ajoutons un atel que ce nouveau /ne dérange pas avec la prochaine étape (qui ne devrait pas "connaître" encore ce changement).

(?<!/)\|\\
\\

La situation inverse: se transformer |\en \\pourvu qu'il n'y en ait pas à /côté. Nous n'avons pas besoin de mettre un aici, car nous avons terminé cette étape de la simulation.

Maintenant la partie endormie ...

$
aaaaa

Ajoute 5 as supplémentaires à la fin du code.

a
aaaa

Transforme chacun aen 4 as, nous obtenons donc 20 as à la fin.

(a+)+b|a
<empty>

Maintenant, la partie amusante ... nous dormons un peu avec l'aide d' un retour en arrière catastrophique . Il existe une quantité exponentielle de façons de diviser une correspondance (a+)+entre les répétitions du groupe. Parce que la bcause de l'échec de la correspondance, le moteur va revenir en arrière et essayer chacune de ces combinaisons avant de décider que (a+)+bcela ne peut pas correspondre. Pour les vingt aà la fin, cela prend environ une demi-seconde.

En même temps, nous permettons à l'expression régulière de correspondre à un seul a , mais uniquement après avoir effectué le retour arrière. Lorsque cela correspond, nous le remplaçons par une chaîne vide, supprimant tous les as que nous avons insérés pour une raison ou une autre dans la chaîne.

Cela laisse l'impression de la chaîne à la fin de l'itération de la boucle. Ici, il est pratique que je n'ai pas encore corrigé le comportement d'impression des boucles dans Retina. Actuellement, il n'y a qu'un seul indicateur pour chaque étape, qui dit "imprimer" ou "ne pas imprimer". La valeur par défaut est «ne pas imprimer», sauf pour la dernière étape du programme, qui par défaut est «imprimer». Mais la scène est bouclée, ce qui signifie qu'elle affiche en fait la chaîne actuelle à chaque itération. Normalement, c'est vraiment ennuyeux, et vous devez presque toujours inclure une étape vide supplémentaire à la fin si vous ne voulez que le résultat final, mais ici, cela me permet d'économiser quatre octets.

Javascript (ES6), 206 148 129 158 octets

Je l'avais finalement descendu à un point bien bas, mais cela n'effacerait pas la console ou ajouterait un espace supplémentaire; ces problèmes ont été résolus maintenant.

c=console;d=s=>{c.clear(s[79]||(s+=' ')),c.log(s),t=s[R='replace'](/\/ | \\/g,'__')[R](/\/\|/g,'//a')[R](/\|\\/g,'\\\\')[R](/a/g,'');t!=s&&setTimeout(d,99,t)}

Version alternative de 153 octets qui devrait fonctionner dans Node.JS:

d=s=>{s[79]||(s+=' '),console.log("\033c"+s),t=s[R='replace'](/\/ | \\/g,'__')[R](/\/\|/g,'//a')[R](/\|\\/g,'\\\\')[R](/a/g,'');t!=s&&setTimeout(d,99,t)}

À mon humble avis, c'est assez amusant de jouer avec. Essayez une version HTML ici:

output=document.getElementById("output"),console.log=a=>output.innerHTML=a;
d=s=>{s[79]||(s+=' ');console.log(s),t=s[R='replace'](/\/ | \\/g,'__')[R](/\/\|/g,'//a')[R](/\|\\/g,'\\\\')[R](/a/g,'');t!=s&&setTimeout(d,99,t)}
s=n=>{n=n||15,r='';for(i=0;i<n;i++)r+=(i%2?'|'.repeat(Math.random()*16|0):'\\ /'[Math.random()*3|0].repeat(Math.random()*3+1|0));return r} // randomizer
input=document.getElementById("input");
input.addEventListener("keydown",e=>e.keyCode==13?(e.preventDefault(),d(input.value)):0);

<p>Enter your dominoes here:</p>
<textarea id="input" rows="1" cols="80">|||\ |||\ /|\ /||||||||\ /|||| /|||</textarea>
<button id="random" onclick="input.value=s()">Randomize</button><button id="run" onclick="d(input.value)">Run</button>
<p>Result:</p>
<pre id="output"></pre>

Il y a probablement beaucoup plus de place pour le golf. Bienvenue suggestions!

Perl 5, 154 146

J'ai dû utiliser un caractère temporaire pour maintenir l'état entre 2 regex.
Pour faire face au risque que quelque chose comme / | | | \ finirait par / / / \ \ au lieu de / / | \ \.

$_=substr(pop.' ',0,80);$|++;while($}ne$_){print"$_\r";$}=$_;s@ \\|/ @__@g;s@/\|(?=[^\\])@/F@g;s@([^/])\|\\@$1\\\\@g;tr@F@/@;select($\,$\,$\,0.1)}

Tester

$ perl dominos.pl '|\ |\/|||\/|'
|\__\//|\\/__

ES6 , 220 218 195 195 octets

Minified

f=d=>{var e,c=console;if(!d[79])d+=' ';c.clear();c.log(d);e=d;d=d[R='replace'](/\/\|\\/g,'a')[R](/\/ | \\/g,'__')[R](/\/\|/g,'//')[R](/\|\\/g,'\\\\')[R]('a','/|\\');if(e!=d)setTimeout(f,100,d);};

Plus lisible

f=d=> {
    var e,
    c=console;
    if(!d[79])
        d+=' ';
    c.clear();
    c.log(d);
    e=d;
    d = d[R='replace'](/\/\|\\/g, 'a')  //Substitute '/|\' with 'a' so it doesn't get replaced
        [R](/\/ |  \\/g, '__')     //Replace '/ ' and ' \' with '__'
        [R](/\/\|/g, '//')    //Replace '/|' with '//'
        [R](/\|\\/g, '\\\\')  //Replace '|\' with '\\'
        [R]('a', '/|\\');     //Put '/|\' back
    if(e!=d)
        setTimeout(f,100,d);
};

C #, 335 octets

Pas un grand choix de langue.

J'ai abusé du délai autorisé entre 50 et 1000 pour sélectionner un nombre à deux chiffres.

Nouvelles lignes et indentation ajoutées pour plus de clarté:

namespace System.Threading{
    class P{
        static void Main(string[]z){
            var c=@"/|\,/|\,/|,//,|\,\\,/ ,__, \,__".Split(',');
            for(string a=z[0].PadRight(80),b="";a!=b;){
                Console.Clear();
                Console.Write(b=a);
                Thread.Sleep(99);
                a="";
                for(int i,j;(i=a.Length)<80;)
                    a+=(j=Array.FindIndex(c,d=>b.Substring(i).StartsWith(d)))%2==0
                        ?c[j+1]
                        :b.Substring(i,1);
            }
        }
    }
}

PHP, 175 octets

$i=sprintf("%-80s",$argv[1]);$p='preg_replace';do{echo($o=$i)."\r";$i=$p('(/\|\\\\(*SKIP)(?!)|(?|(/)\||\|(\\\\)))','$1$1',$p('(/ | \\\\)','__',$i));usleep(1e5);}while($i!=$o);

Non minifié:

$input = sprintf("%-80s",$argv[1]);
do {
  echo $input."\r";
  $old = $input;
  $input = preg_replace('(/ | \\\\)','__',$input);
  $input = preg_replace('(/\|\\\\(*SKIP)(?!)|(?|(/)\||\|(\\\\)))','$1$1',$input);
  usleep(100000);
}
while( $input != $old);

Golf regex fondamentalement. Aplatit d'abord tous les dominos tombants qui ont de l'espace (et en raison de l'ordre de correspondance de gauche à droite, le «vent» souffle). Vient ensuite la partie laide (maudissez-vous des barres obliques!)

• Match /|\, puis sautez-le.
• Associez (/)|et remplacez par//
• Associez |(\)et remplacez par\\

Cela fait tomber les dominos. Enfin, attendez 100 ms pour la prochaine étape.

L'utilisation ()comme délimiteurs sur l'expression régulière signifie que les /s n'ont pas besoin de s'échapper, ce qui aide très peu!

Coque POSIX + sed, 144

sed 's/^.\{1,79\}$/& /;s/.*/printf '"'&\\r'"';sleep .1/;h;:;s,/|\\,/:\\,g;s,\(/ \| \\\),__,g;s,/|,//,g;s,|\\,\\\\,g;H;t;x;y/:/|/;s/\\/\\\\/g'|sh

C'est en deux parties. Le travail principal de renversement des dominos est le sedremplacement de modèle standard , accumulant des lignes dans l'espace de cale. Nous nous transformons temporairement /|\en/:\ pour le protéger, récupérant à la fin.

s/^.\{0,79\}$/& /
h

:
s,/|\\,/:\\,g
s,\(/ \| \\\),__,g
s,/|,//,g
s,|\\,\\\\,g
H
t

x
y/:/|/

Puisque sed il n'y a aucun moyen d'insérer des retards (j'ai cherché dans terminfo / termcap, mais je n'ai pas trouvé de moyen standard), j'encapsule chaque ligne printf "...\r"; sleep .1 pour imprimer une ligne toutes les 100 ms. En fait, je le fais d'abord, lorsque nous n'avons qu'une seule ligne, car les caractères de la commande ne seront touchés par aucune des substitutions de basculement.

Tous testés en utilisant dashet GNU coreutils, avec POSIXLY_CORRECTensemble dans l'environnement.