소개

속도와 방향을 가진 ASCII 자동차가 있습니다. 그들의 속도는 숫자로 표시됩니다. 차가 <>멈 추면 멈췄습니다. 예를 들면 다음과 같습니다.

<>
1>
2>
3>

1 초 후

<>
 1>
  2>
   3>

두 후, 나는 얻는다

<>
  1>
    2>
      3>

두 대의 자동차가 너무 가까이 있으면 충돌합니다.

1> <1
1> <2

잠시 후, 이것은

 ###
 ##

두 대의 자동차가 교차하면 해시 태그가됩니다.

한 차량이 다른 차량을 '홉'할만큼 빠르면 충돌이 발생하지 않습니다.

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

된다

 <13>   ###     <>4>

차가 화면 밖으로 나오면 충돌이없는 한 사라집니다. 자동차가 화면 밖으로 바로 갈 수는 없습니다.

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

도전

주어진 자동차 물리학을 기반으로, 당신은 미래에 1 초의 시간을 걸 수있는 프로그램을 만들어야합니다. 입력 값은 공간이 있고 최대 속도가 5 (정합 일치 (<[1-5]|[1-5]>|<>| )+) 인 자동차입니다. 시뮬레이션은 한 줄에서 이루어 지지만 해당 줄의 크기는 고정되어 있지 않습니다.

테스트 사례

<> 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

채점

이것은 코드 골프바이트 수가 가장 적은 코드가 승리합니다!

자바 스크립트 (ES6), 140 바이트

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``

온라인으로 사용해보십시오!

댓글

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

자바 스크립트 (Node.js) , 259 바이트

254에서 259까지 나는 결과 정규 표현식 찾기를 복잡하게하는 테스트 케이스에 없었던 테스트 케이스를 추가했기 때문에

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)

온라인으로 사용해보십시오!

레티 나 178 바이트

^\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

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 설명:

^\d([^>])
 $1

차가 왼쪽으로 이동하는 경우를 처리하십시오.

T`5-1`d`<.

왼쪽으로 이동하는 자동차의 숫자를 일시적으로 보완합니다.

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

각 차량을 자체 라인에 놓고 ( $.`* $&¶) 차량 속도에 따라 약간의 들여 쓰기를 추가하십시오. 왼쪽으로 움직이는 자동차는 보완 된 속도를 얻는 반면, 비 움직이는 자동차는 속도보다 5를 더 많이 얻습니다.

T`d`5-1`<.

왼쪽으로 이동하는 자동차 숫자를 보완합니다.

m`^.{0,5}

모든 차량 5를 왼쪽으로 이동하십시오. 이것은 모든 자동차의 들여 쓰기를 수정합니다.

G`.

왼쪽으로 이동 한 모든 차량을 삭제하십시오.

N^$`
$.&

나머지 차량은 역순으로 정렬하십시오.

{

모든 자동차가 처리 될 때까지 나머지 단계를 반복하십시오.

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

다음 차가 고장 나지 않는 한 결과에 추가하십시오.

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

결과에 충돌하는 자동차를 추가하십시오.