introduction

J'ai des voitures ASCII qui ont de la vitesse et de la direction. Leur vitesse est représentée par leur nombre. Si une voiture l'est, <>elle s'est arrêtée. Par exemple:

<>
1>
2>
3>

Après une seconde, je reçois

<>
 1>
  2>
   3>

Après deux, je reçois

<>
  1>
    2>
      3>

Si deux voitures sont trop proches, elles s'écrasent.

1> <1
1> <2

Après une seconde, cela devient

 ###
 ##

Si deux voitures se croisent, elles deviennent des hashtags où elles le seraient.

Si une voiture est assez rapide pour «sauter» sur l'autre, cela n'entraîne pas de crash.

3><1   2><1   4><>

devient

 <13>   ###     <>4>

Si une voiture disparaît hors écran, elle disparaît (sauf en cas d'accident). Il n'y a aucun moyen pour une voiture de sortir directement de l'écran.

 <11>
<1  1>
1    1>
      1>

Défi

Sur la base de la physique de la voiture donnée, vous devez créer un programme qui peut avancer d'une seconde dans le temps. L'entrée sera des voitures avec des espaces et une vitesse maximale de 5 (correspondant à l'expression régulière (<[1-5]|[1-5]>|<>| )+). La simulation se fera sur une seule ligne, mais cette ligne n'a pas de taille fixe.

Cas de test

<> 1> 2> 3> 4> 5>
<>  1>  2>  3>  4>  5>

1><1   1> <1   1>  <1
 ##     ###     1><1

2><2   2> <2   2>  <2   2>   <2   2>    <2
<22>    ###      ##       ###       2><2

<22>  <1 3>   <2
    ###     ##

<><>     1><>     2><>     3><>     4><>     5><>
<><>      ###       ##       ###      <>4>     <> 5>

<><1 <2 <3 <4 <5
###<2<3<4<5

Notation

C'est du code-golf , donc le code avec le plus petit nombre d'octets gagne!

JavaScript (ES6), 140 octets

s=>[...s.replace(/\S./g,([a,b],i)=>r[r[i+=+b?-b:~~a]=r[i]?C:a,++i]=r[i]?C:b,r=[],C='#')&&r].map((c,i)=>c?r[i-1]==C|r[i+1]==C?C:c:' ').join``

Essayez-le en ligne!

Commenté

s =>                      // given the input string s
  [ ...s.replace(         // search in s ...
    /\S./g,               //   ... all substrings consisting of 2 non-whitespace characters
    ([a, b], i) =>        //   let a be the 1st character, b the 2nd one and i the position
      r[                  //   update r[]:
        r[i +=            //     apply the car velocity to i:
          +b ? -b         //       if b is a digit, then move b cells backwards
                  : ~~a   //       else: use a to move forwards (or don't move at all)
        ] = r[i] ? C : a, //     if r[i] is set, overwrite it with '#'; otherwise, insert a
        ++i               //     increment i for the 2nd character
      ] = r[i] ? C : b,   //     if r[i] is set, overwrite it with '#'; otherwise, insert b
      r = [],             //   initialize r[] to an empty array
      C = '#'             //   define C as the 'crash' character
  ) && r ]                // end of replace(); return a fully iterable copy of r[]
  .map((c, i) =>          // for each entry c at position i in this array:
    c ?                   //   if c is defined:
      r[i - 1] == C |     //     if either the previous
      r[i + 1] == C ?     //     or the next cell is '#' (in the original array):
        C                 //       replace the current cell with '#'
      :                   //     else:
        c                 //       let c unchanged
    :                     //   else:
      ' '                 //     insert a space
  ).join``                // end of map(); join the result

JavaScript (Node.js) , 259 octets

254 à 259 parce que j'ai ajouté un cas de test qui n'était pas dans les cas de test, ce qui a compliqué mon résultat regex finder

s=>{
c=[]
n=[S=""]
s.replace(/<?\d>?|<>/g,([d,D],i)=>d>0?g(i+ +d,d)+g(i-~d,D):g(i-~~D,d)+g(i-~~D+1,D))
for(i of n)S+=i||" "
return S.replace(/1?[2-9]*1?/g,(d,i)=>d>"1".repeat(l=d.length)?"#".repeat(l):c.slice(i,i+l).join``)}
g=(x,p)=>x<0||(n[x]=-~n[x],c[x]=p)

Essayez-le en ligne!

Rétine , 178 octets

^\d([^>])
 $1
T`5-1`d`<.
 *(<(\d)|((\d)>|<>))
$2* $#3*5* $4* $.`* $&¶
T`d`5-1`<.
m`^.{0,5}

G`.
N^$`
$.&
{+m`\A( *)  (.*)¶\1(..?)$
$1$3$2
m`^\A( *)( *)..(.*)¶\1(..?)$
$1##$.2*#$3

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

^\d([^>])
 $1

Manipulez le cas d'une voiture se déplaçant vers la gauche.

T`5-1`d`<.

Complétez temporairement les chiffres des voitures se déplaçant vers la gauche.

 *(<(\d)|((\d)>|<>))
$2* $#3*5* $4* $.`* $&¶

Mettez chaque voiture sur sa propre ligne ( $.`* $&¶) et ajoutez un retrait en fonction de la vitesse de la voiture; les voitures qui se déplacent vers la gauche obtiennent la vitesse complémentaire, tandis que les voitures qui ne bougent pas obtiennent 5 de plus que la vitesse.

T`d`5-1`<.

Ne complétez pas les chiffres de la voiture qui se déplace vers la gauche.

m`^.{0,5}

Déplacez toutes les voitures 5 vers la gauche. Cela corrige le retrait pour toutes les voitures.

G`.

Supprimez toutes les voitures qui se sont déplacées vers la gauche.

N^$`
$.&

Triez les voitures restantes dans l'ordre horizontal inverse.

{

Répétez les étapes restantes jusqu'à ce que toutes les voitures aient été traitées.

+m`\A( *)  (.*)¶\1(..?)$
$1$3$2

Tant que la prochaine voiture ne tombe pas en panne, ajoutez-la au résultat.

m`^\A( *)( *)..(.*)¶\1(..?)$
$1##$.2*#$3

Ajoutez une voiture qui s'écrase au résultat.