दुर्घटनाग्रस्त कारों का अनुकरण

Question

परिचय

मेरे पास कुछ ASCII कारें हैं जिनमें वेग और दिशा है। उनके वेग को उनकी संख्या द्वारा दर्शाया गया है। अगर कोई कार है <>तो उसे रोक दिया गया है। उदाहरण के लिए:

<>
1>
2>
3>

एक सेकंड के बाद, मैं मिलता हूं

<>
 1>
  2>
   3>

दो के बाद, मुझे मिलता है

<>
  1>
    2>
      3>

यदि दो कारें बहुत पास हैं, तो वे दुर्घटनाग्रस्त हो जाती हैं।

1> <1
1> <2

एक सेकंड के बाद, यह बन जाता है

 ###
 ##

अगर दो कारों को काटते हैं, तो वे हैशटैग बन जाते हैं।

यदि एक कार तेजी से दूसरे पर 'हॉप' करने के लिए पर्याप्त है, तो यह दुर्घटना में नहीं होता है।

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

हो जाता है

 <13>   ###     <>4>

यदि कोई कार बाएं स्क्रीन पर चली जाती है, तो वह गायब हो जाती है (जब तक कि कोई दुर्घटना न हो)। कार के लिए राइट-ऑफ स्क्रीन जाने का कोई रास्ता नहीं है।

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

स्कोरिंग

ये है कोड गोल्फ, इसलिए बाइट्स की सबसे छोटी संख्या के साथ कोड जीतता है!

Comments

<22> <1 3> <2 2 ### ## 2 नहीं होना चाहिए - आउटपुट के साथ अन्य समस्याएं हैं

— डैनियलइंडी

मैं आपको "<> <1 <2 <3 <4 <5" "### <2 <3 <4 <5 <" जोड़ने का सुझाव दूंगा - टेस्टकेस में मामला - क्रश होता था लेकिन और अन्य कारों "टचिंग" लेकिन भाग नहीं इसमें से

— DanielIndie

@DanielIndie यह एक दिलचस्प है। मैंने आगे बढ़कर चुनौती का संपादन किया।

— अरनुलद

यह मुझे पता करने के लिए कुछ समय खर्च करता है <>जिसका मतलब है वेग 0

— l4m2

माफ़ करना! मैंने कहा कि सब कुछ लिखने के बाद मैं इसे समझाना भूल गया।

— नाथन वुड

Answer 1

जावास्क्रिप्ट (ईएस 6), 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

Answer 2

जावास्क्रिप्ट (Node.js) , 259 बाइट्स

254 से 259 क्योंकि मैंने टेस्ट केस को जोड़ा था जो मेरे परिणाम regex खोजक को जटिल करने वाले टेस्टकेस में नहीं था

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)

इसे ऑनलाइन आज़माएं!

Answer 3

रेटिना , 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

परिणाम में एक दुर्घटनाग्रस्त कार जोड़ें।