रन-लेंथ रेसर्स

Question

आपको इनपुट के दो टुकड़े दिए जाएंगे: रन-लेंथ एन्कोडेड प्रारूप में एक स्ट्रिंग जो कि रनिंग ट्रैक को परिभाषित करता है, और एक कैपिटल लेटर जिसमें लेन शुरू करने का प्रतिनिधित्व करता है। उदाहरण के लिए, स्ट्रिंग "3a4A6b5B" का विस्तार "आआआआआआआआआआआबबबबबबबब" होता है। आप ट्रैक बनाने के लिए विस्तारित स्ट्रिंग का उपयोग करते हैं, जैसे:

 A) aaaAAAA
 B) bbbbbbBBBBB

यह दो लेन वाला ट्रैक है। लोअरकेस अक्षर हवा का प्रतिनिधित्व करते हैं। आप हवा पर नहीं चल सकते! अपरकेस अक्षर उस सड़क का प्रतिनिधित्व करते हैं जिस पर आप चल सकते हैं। इस चुनौती के लिए आपका लक्ष्य, एक बड़े अक्षर को देखते हुए, आउटपुट है कि उस लेन पर शुरू होने वाला एक रेसर कितनी दूर तक चल सकता है। यदि सड़क का एक टुकड़ा सीधे उनके ऊपर या नीचे है, तो रेसरों को लेन को बदलने की अनुमति है। उन्हें पीछे की तरफ दौड़ने की भी अनुमति है! इस विशेष ट्रैक पर किसी भी पत्र इनपुट के लिए आउटपुट 0 है , क्योंकि किसी भी ट्रैक पर स्थिति 1 पर चलने योग्य सड़क नहीं है।

उदाहरण:

इनपुट: "4A5B4c3C", "ए"

यह कोड इस तरह दिखने वाले एक ट्रैक में फैलता है:

A) AAAA
B) BBBBB
C) ccccCCC

इस उदाहरण के लिए आउटपुट 7 है , क्योंकि लेन ए पर शुरू होने वाला धावक बी बी, और फिर लेन सी तक नीचे जा सकता है, और 7 वें स्थान पर समाप्त हो सकता है।

इनपुट: "4A2B3D", "D"

धावन पथ:

A) AAAA
B) BB
C)
D) DDD

आउटपुट 3 है , क्योंकि लेन डी पर शुरू होने वाले धावक के पास लेन बी या ए पर जाने का कोई रास्ता नहीं है

इनपुट: "4 ए 4 ए 4 ए 3 बी 6 बी 5 सी", "ए"

धावन पथ:

A) AAAAaaaaAAAA
B) bbbBBBBBB
C) CCCCC

आउटपुट 12 है , क्योंकि ए पर धावक बी पर स्विच कर सकता है, और फिर अंत में ए पर वापस आ सकता है। "C" के लिए अधिकतम दूरी भी 12. "B" के लिए 0 है।

इनपुट: "12M4n10N11O", "M"

धावन पथ:

M) MMMMMMMMMMMM
N) nnnnNNNNNNNNNN
O) OOOOOOOOOOO

बहु-अंक रन-लंबाई के साथ सरल उदाहरण। आउटपुट 14 है ।

इनपुट: "4A5B1b2B4c3C", "ए"

धावन पथ:

A) AAAA
B) BBBBBbBB
C) ccccCCC

आउटपुट 8 है , क्योंकि A पर धावक B से नीचे जा सकता है, फिर C से नीचे, फिर B से वापस आ सकता है (इस उदाहरण के लिए FryAmTheEggman को धन्यवाद।)

इनपुट: "1 ए 2 ए 2 ए 2 बी 1 सी 1 सी 1 डी 3 डी", "बी"

धावन पथ:

A)aAAaa
B)BB
C)cC
D)dDDD

आउटपुट 4 है । रनर को दोनों रास्तों की जाँच करनी होती है दो देखें जो आगे जाता है। (इस उदाहरण के लिए user81655 का धन्यवाद।)

इनपुट: "2A1b1B2C1D3E", "A"

धावन पथ:

A) AA
B) bB
C) CC
D) D
E) EEE

आउटपुट 3 है । सबसे दूर गंतव्य तक पहुंचने के लिए आपको पीछे की ओर भागना होगा। (एक बार फिर, इस उदाहरण के लिए user81655 का धन्यवाद।)

टिप्पणियाँ:

• यदि किसी ट्रैक पर एक निश्चित स्थान पर एक अक्षर नहीं है, तो वह हवा के रूप में भी गिना जाता है। जैसे, यदि इनपुट "क्यू" है और लेन "क्यू" पर कोई सड़क नहीं रखी गई है तो आउटपुट 0 होना चाहिए ।
• इनपुट के दो टुकड़े हैं। पहला रन-लेंथ एन्कोडेड स्ट्रिंग है। दूसरा एक कैपिटल लेटर है (आप इसके लिए स्ट्रिंग या चार डेटेटाइप का उपयोग कर सकते हैं।) पठनीयता के लिए, इन इनपुट्स (स्पेस, नई लाइन, टैब, अल्पविराम, सेमी-कॉलन) के बीच कुछ उचित विभाजक होना चाहिए।
• रन-लंबाई एन्कोडेड स्ट्रिंग हमेशा वर्णमाला क्रम में तत्वों को सूचीबद्ध करेगा
• सबसे लंबी एक लेन की पूरी लंबाई 1000 हो सकती है। इसलिए, सबसे बड़ा संभव उत्पादन 1000 है।

ट्रैक जेनरेटर:

हमारे पहले उत्तर के सम्मान में, यहां एक ट्रैक जनरेटर है। वर्तमान उत्तरों को स्टम्प करने के लिए कुछ के साथ आने की कोशिश करें! (नोट: सिर्फ इसलिए कि जनरेटर एक त्रुटि संदेश नहीं दिखाता है, इसका मतलब यह नहीं है कि आपका ट्रैक कोड आवश्यक रूप से वैध है। उचित फ़ॉर्म के लिए उपरोक्त उदाहरण देखें।)

function reset() {
    var t = document.getElementById("track");
    t.innerHTML = "";
    for(var i = 0;i<26;i++) {
      var c = String.fromCharCode(i+65);
      t.innerHTML += "<div><span>"+c+") </span><span id='"+c+"'></span></div>";
      
    }
  }

function rand() {
  var track = "";
  for(var i = 0;i<26;i++) {
  var blocks = Math.floor(Math.random()*4);
  var start = Math.floor(Math.random()*2);
  for(var j = 0;j<blocks;j++) {
    var letter = String.fromCharCode(65+i+32*((start+j)%2));
    var length = Math.floor(Math.random()*4)+1;
    track += length+letter;
  }
  }
  document.getElementById("code").value = track;
}

  function gen() {
  var s = document.getElementById("code").value;
    var check = s.match(/(\d+[A-Za-z])+/);
    if(check == null || check[0]!=s) {
      alert("Invalid Track");
      return false;
    }
    reset();
  var n = s.match(/\d+/g);
    var o = s.match(/[A-Za-z]/g);
    for(var i = 0;i<n.length;i++) {
      var c = o[i].toUpperCase();
      document.getElementById(c).textContent += o[i].repeat(n[i]);
    }
    return true;
    }

<body onload="reset()">
Track: <input type="text" id="code" size="75%" /><input type="submit" onclick="gen()" /><input type="button" value="Random Track" onclick="rand()" /><code id="track"/>
  </body>

Comments

स्विच के फैसले और पीछे की ओर दौड़ने के साथ यह अब एक ट्रैक की तुलना में अधिक भूलभुलैया है: P

— user81655

क्या केवल एक ही मार्ग है - जैसा कि परीक्षण मामलों में है?

— रिचीहाब

@ रीछबाह एक से अधिक मार्ग हो सकते हैं।

— जियोकॉवेल

बस सोच रहा था कि शायद लापता सी को संभालने की जटिलता को 4A2B3Dहटाया जा सकता है? उदाहरण के लिए, जोड़ना 0c? यदि नहीं, तो क्या यह उम्मीद की जाती है जब कहा 1A1Zगया था, गलियों को अस्तित्व में माना जाता है (लेकिन खाली हैं)?

— केनी

साथ ही, बैकवर्ड रनिंग एक बहुत बड़ी समस्या है। 12M4n10N11Oउदाहरण के लिए, उत्पादन 14 है, तो गलत है: एम 0 में सबसे लंबे समय तक पथ शुरू होता है और C0 पर समाप्त होता है, की 25 लंबाई के लिए

— केनी

Answer 1

पर्ल, 231 219 203 192 189 बाइट्स

के लिए +1 शामिल है -p

sub f{my($l,$p,$m)=@_;map{$m=$_>$m?$_:$m}f($l,$p+1)+1,f($l-1,$p),f($l+1,$p),f($l,$p-1)-1if$L[$l][$p]&&!$V{$l}{$p}++;$m}s/(\d+)(.)\s*/push@{$L[ord$2&~32]},(0|$2lt'a')x$1;()/ge;$_=0|f(ord,0)

कम गोल्फ वाला:

sub f{                          # this is a recursive function, so we need locals.
    my($l,$p,$m)=@_;            # in: lane, position; local: max path length

    map{
      $m = $_ > $m ? $_ : $m    # update max
    }
    f( $l,   $p+1 )+1,          # same lane, forward
    f( $l-1, $p   ),            # left lane, same pos
    f( $l+1, $p   ),            # right lane, same pos
    f( $l,   $p-1 )-1           # same lane, backtrack
    if
        $L[$l][$p]              # check if there's road here
    && !$V{$l}{$p}++            # and we've not visited this point before.
    ;

    $m                          # return the max
}

s/(\d+)(.)\s*/                  # Parse RLE pattern, strip starting lane separator
  push@{ $L[ord$2&~32] }        # index @L using uppercase ascii-code, access as arrayref
  ,(0|$2lt'a')x$1               # unpack RLE as bitstring
  ;()                           # return empty list for replacement
/gex;                           # (x for ungolfing)
                                # $_ now contains trailing data: the start lane.

$_ =                            # assign output for -p
   0|                           # make sure we print 0 instead of undef/nothing
   f(ord,0)                     # begin calculation at start of current lane

चल रहा है

स्टोर ऊपर कोड एक फ़ाइल में (जैसे 231.pl)। के रूप में इनपुट (\d+\w)+ *\w। उदाहरण: इनपुट ट्रैक 4A5B4c3Cऔर लेन A:

echo 4A5B4c3C A | perl -p 231.pl

परीक्षण सूट

(गोल्फ नहीं है)

printf "==== Testing %s\n", $file = shift // '231.pl';

sub t{
    my($input,$expect) = @_;
#   $input =~ s/\s//g;
    printf "TEST %-20s -> %-3s: ", $input, $expect;

    $output = `echo $input | perl -p $file`;

    printf "%-3s  %s\n", $output,
    $output == $expect
    ? " PASS"
    : " FAIL: $output != $expect";

}

t("4A5B4c3C A", 7);
t("4A5B4c3C C", 0);
t("4A2B3D D", 3);
t("4A4a4A3b6B5C A", 12);
t("4A4a4A3b6B5C B",  0);
t("4A4a4A3b6B5C C", 12);
t("12M4n10N11O M", 14 );
t("4A5B1b2B4c3C A", 8);
t("1a2A2a2B1c1C1d3D B", 4 );
t("2A1b1B2C1D3E A", 3 );
t("10A9b1B8c2C9D1E11F A", 11);

• 219 अद्यतन 12 बाइट्स को पुनः क्रमबद्ध सरणी सूचकांकों द्वारा सहेजें।
• अद्यतन 203 पुनरावर्तन को पुन: सक्रिय करके 16 बाइट्स सहेजें।
• अपडेट 192@L=map{[/./g]}@L पोस्टप्रोसेसिंग को खत्म करके 11 बाइट्स बचाएं ।
• इसके बजाय का ifउपयोग करके पोस्टफ़िक्स करके 189 सेव 3 बाइट्स को अपडेट करें ।mapfor

Comments

मैं नहीं अगर यह एक पर्ल बात है, लेकिन यह तेजी से चलाता है।

— जियोकॉवेल

Answer 2

जावास्क्रिप्ट (ईएस 6), 298 334 बाइट्स

(t,s)=>[a=[],t.match(/\d+(.)(\d+\1)*/gi).map(l=>a[c=l.match`[A-Z]`+"",n=c.charCodeAt(),c==s?i=n:n]=l[r="replace"](/\d+./g,p=>(p.slice(-1)<"a"?"1":"0").repeat(parseInt(p))),i=o=-1),...a.join``,a[i]?a[i]=a[i][r](/^1/,2):0].map(_=>a.map((l,y)=>a[y]=l[r](/1/g,(c,x)=>((a[y-1]||s)[x]|(a[y+1]||s)[x]|l[x-1]|l[x+1])>1?(x>o?o=x:0,2):c)))&&o+1

व्याख्या

मूल रूप से यह समाधान ट्रैक को भूलभुलैया के रूप में मानता है। यह पाता है कि धावक के लिए कहाँ तक पहुँचना संभव है और उसके द्वारा पाए गए एक्स इंडेक्स का सबसे बड़ा मूल्य लौटाता है।

पहली चीज जो इनपुट स्ट्रिंग को एक सरणी रेखा में डिकोड करती है। हालांकि अक्षरों का उपयोग करने के बजाय, यह एक कैपिटल लेटर को एक 1और एक लोअरकेस अक्षर को एक में बदल देता है 0। परिणामी नक्शा कुछ इस तरह दिखाई देगा:

11100011
0011100
100111

इसके बाद यह शुरुआती ट्रैक की पहली टाइल बनाता है 2(केवल अगर यह पहले से ही है 1) और प्रत्येक टाइल के माध्यम से छोरों के लिए आसन्न टाइल की जाँच करता है 2। यदि एक 1पास है तो 2यह एक हो जाता है 2। उपर्युक्त नक्शा पहली पंक्ति पर शुरू होने पर यह नक्शा बन जाएगा:

22200011
0022200
100222

उच्चतम X सूचकांक 2परिणाम बन जाता है।

जब मैंने इसका आरंभिक संस्करण किया था, तो मैंने बहुत मामूली ओवरसाइट बनाया और इस पर काम करने तक मुझे 36 बाइट्स खर्च करने पड़े, इसलिए संभवत: इसमें बहुत सुधार हुए हैं। * विलाप *

Ungolfed

(t,s)=>
  [

    // Decode run-length encoded string into an array of track lanes
    a=[],                           // a = array of track line strings, 0 = air, 1 = tiles
    t.match(/\d+(.)(\d+\1)*/gi)     // regex magic that separates pairs by their letter
    .map(l=>                        // for each line of pairs
      a[                            // add the tiles to the array
        c=l.match`[A-Z]`+"",        // c = pair character
        n=c.charCodeAt(),           // n = index of line
        c==s?i=n:n                  // if this line is the starting line, set i
      ]=l[r="replace"](/\d+./g,p=>  // match each pair, p = pair
        (p.slice(-1)<"a"
          ?"1":"0").repeat(         // repeat 0 for air or 1 for ground
            parseInt(p)             // cast of match would return NaN because of the
          )                         //     letter at the end but parseInt works fine
      ),
        i=                          // i = index of starting line, initialise as invalid
          o=-1                      // o = output (max value of x)
    ),

  // Find all positions that are possible for the runner to get to
    ...a.join``,                   // add every letter of the track lines to an array
    a[i]?a[i]=a[i][r](/^1/,2):0    // set the starting tile to 2 if it is already 1
  ].map(_=>                        // loop for the amount of tiles, this is usually way
                                   //     more than necessary but allows for hard to reach
                                   //     tiles to be parsed
    a.map((l,y)=>                  // for each line l at index y
      a[y]=l[r](/1/g,(c,x)=>       // for each character c at index x

        // Replace a 1 with 2 if there is a 2 to above, below, left or right of it
        ((a[y-1]||s)[x]|(a[y+1]||s)[x]|l[x-1]|l[x+1])>1?
          (x>o?o=x:0,2):c          // set o to max value of x for a 2 tile
      )
    )
  )
  &&o+1                            // return o + 1

परीक्षा

बोनस: आउटपुट में पार्स मैप शामिल है!

var solution = (t,s)=>[a=[],t.match(/\d+(.)(\d+\1)*/gi).map(l=>a[c=l.match`[A-Z]`+"",n=c.charCodeAt(),c==s?i=n:n]=l[r="replace"](/\d+./g,p=>(p.slice(-1)<"a"?"1":"0").repeat(parseInt(p))),i=o=-1),...a.join``,a[i]?a[i]=a[i][r](/^1/,2):0].map(_=>a.map((l,y)=>a[y]=l[r](/1/g,(c,x)=>((a[y-1]||s)[x]|(a[y+1]||s)[x]|l[x-1]|l[x+1])>1?(x>o?o=x:0,2):c)))&&o+1
function generateMap() { var start = 0; a.some((l, i) => l ? start = i : 0); var end = 0; a.map((l, i) => l && i <= 90 ? end = i : 0); for(var output = "", i = start; i < end + 1; i++) output += String.fromCharCode(i) + ") " + (a[i] || "") + "\n"; return output; }

Track = <input type="text" id="track" value="2A1b1B2C1D3E" /><br />
Starting Letter = <input type="text" id="start" value="A" /><br />
<button onclick="result.textContent=solution(track.value,start.value)+'\n\n'+generateMap()">Go</button>
<pre id="result"></pre>