अवास्ट, तु scallywags!

Question

ब्लैकबर्ड 18 ^वीं शताब्दी की शुरुआत में एक अंग्रेजी समुद्री डाकू था। हालाँकि वह लूटपाट करने और जहाजों को लेने के लिए जाने जाते थे, फिर भी उन्होंने अपने दल की अनुमति से अपने जहाजों की कमान संभाली। उनके बंदियों को नुकसान पहुंचाने या उनकी हत्या करने का कोई हिसाब नहीं है।

यह चुनौती कुख्यात ब्लैकबर्ड के सम्मान में है और अंतर्राष्ट्रीय टॉक लाइक एक समुद्री डाकू दिवस (19 सितंबर) से प्रेरित है । पिरथा द्वारा इस चुनौती का उलटा भी है ।

---

चुनौती

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

---

इनपुट

सभी आदानों शामिल होंगे v, >, <, ^, खाली स्थान के, और एक एकल X।

आप निम्नलिखित मान सकते हैं:

• नक्शा कभी भी लूप या खुद को पार नहीं करेगा

• शुरुआती तीर हमेशा सबसे बाएं कॉलम में बॉटलमॉस्ट कैरेक्टर होगा

• वहाँ हमेशा एक खजाना ( X) होगा

एक नमूना इनपुट नीचे दिखाया गया है।

  >>v   >>>>>>v
  ^ v   ^     v
  ^ v   ^   v<<
  ^ v   ^   v
  ^ >>>>^   >>X
  ^
>>^

---

उत्पादन

आउटपुट ", "दिशाओं का -delimited स्ट्रिंग होना चाहिए । ऊपर दिए गए नक्शे से नीचे सही आउटपुट है।

E2, N6, E2, S4, E4, N4, E6, S2, W2, S2, E2

एक एकल अनुगामी न्यूलाइन या स्थान की अनुमति है।

---

उदाहरण

In:
>>>>>>>>>>>>>>>v
               v
               v
               >>>>X

Out:
E15, S3, E4

In:
>>>>>>v
^     v
^     >>>>X

Out:
N2, E6, S2, E4

In:
X
^
^
^

Out:
N3

In:
>>>>>>v
^     v
^     v
      v
      >>>>>>X

Out:
N2, E6, S4, E6

In:
 X
 ^
 ^
>^

Out:
E1, N3

In:
>X

Out:
E1

In:
v<<<<<
vX<<<^
>>>>^^
>>>>>^

Out:
E5, N3, W5, S2, E4, N1, W3

---

हैप्पी इंटरनेशनल टॉक लाइक ए पाइरेट डे!

Comments

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

— रेटो कोराडी

मैंने आपके अनुरोध के अनुसार एक उदाहरण जोड़ा है। मैंने यह विवरण भी जोड़ा है कि शुरुआती चरित्र कॉलम का सबसे बड़ा बिंदु होगा। @ रितोकोरदी

— जैच गेट्स

चूंकि मैंने पिछले सेगमेंट की लंबाई के बारे में संबंधित प्रश्न में कुछ चिंता जताई है, इसलिए मैं एक बार फिर से नाइटपिक करूंगा और कहूंगा कि यह बिल्कुल उल्टा सवाल नहीं है। कोई एक बार फिर से समुद्री डाकू को चकमा देने की कोशिश कर रहा है, मुझे लगता है।

— coredump

एकमात्र अंतर अंतिम दिशा की चरण गणना है। @ कम से कम, जहां तक ​​मैं बता सकता हूं।

— ज़च गेट्स

@ZachGates हां, बिल्कुल (और सिर्फ स्पष्ट होने के लिए, मैं यह नहीं कह रहा हूं कि प्रश्न को संशोधित किया जाना चाहिए, यह वर्तमान में अच्छा है)।

— coredump

Answer 1

सीजेएम, 78 बाइट्स

qN/_:,$W=:Tf{Se]}s:U,T-{_U="><^vX"#"1+'E1-'WT-'NT+'S0"4/=~_@\}g;;]e`{(+}%", "*

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

व्याख्या

यहां मुख्य विचार सबसे लंबी रेखा को खोजना है (हम इस लंबाई को कॉल करेंगे T), फिर सभी लाइनों को एक ही लंबाई में पैड करें और उन्हें (यह नया स्ट्रिंग U) संक्षिप्त करें । इस तरह से नक्शे में जाने के लिए केवल एक काउंटर की जरूरत होती है। जोड़ना / घटाना का 1अर्थ है एक ही पंक्ति में दाईं / बाईं ओर बढ़ना, जोड़ना / घटाना का Tअर्थ है एक रेखा से नीचे / ऊपर जाना।

qN/    e# Split the input on newlines
_:,    e# Push a list of the line lengths
$W=:T  e# Grab the maximum length and assign to T
f{Se]} e# Right-pad each line with spaces to length T
s:U    e# Concatenate lines and assign to U

अब लूप सेट करने का समय आ गया है।

,T-    e# Push len(U) - T
       e# i.e. position of first char of the last line
{...}g e# Do-while loop
       e# Pops condition at the end of each iteration

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

_U=      e# Push the character in the current position
"><^vx"# e# Find the index in "><^Vx"
"..."4/  e# Push the string and split every 4 chars
         e# This pushes the following list:
         e# [0] (index '>'): "1+'E" pos + 1, push 'E'
         e# [1] (index '<'): "1-'W" pos - 1, push 'W'
         e# [2] (index '^'): "T-'N" pos - T, push 'N'
         e# [3] (index 'v'): "T+'S" pos + T, push 'S'
         e# [4] (index 'X'): "0"    push 0
=~       e# Get element at index and eval
_@\      e# From stack: [old_directions position new_direction]
         e# To stack: [old_directions new_direction position new_direction]
         e# (You could also use \1$)
         e# new_direction becomes the while condition and is popped off

अब स्टैक इस तरह दिखता है [directions 0 position]:। आइए आउटपुट उत्पन्न करें।

;;    e# Pop position and 0 off the stack
]     e# Wrap directions in a list
e`    e# Run length encode directions
      e# Each element is [num_repetitions character]
{     e# For each element:
 (+   e#   Swap num_repetitions and character
}%    e# End of map (wraps in list)
", "* e# Join by comma and space

Answer 2

सीजेएम, 86 बाइट्स

qN/_,{1$=cS-},W=0{_3$3$==_'X-}{"^v<>"#_"NSWE"=L\+:L;"\(\ \)\ ( )"S/=~}w];Le`{(+}%", "*

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

स्पष्टीकरण:

qN/     Get input and split into rows.
_,      Calculate number of rows.
{       Loop over row indices.
  1$=     Get row at the index.
  c       Get first character.
  S-      Compare with space.
},      End of filter. The result is a list of row indices that do not start with space.
W=      Get last one. This is the row index of the start character.
0       Column number of start position. Ready to start tracing now.
{       Start of condition in main tracing loop.
  _3$3$   Copy map and current position.
  ==      Extract character at current position.
  _'X-    Check if it's the end character `X.
}       End of loop condition.
{       Start of loop body. Move to next character.
  "^v<>"  List of directions.
  #       Find character at current position in list of directions.
  _       Copy direction index.
  "NSWE"  Matching direction letters.
  =       Look up direction letter.
  L\+:L;  Append it to directions stored in variable L.
  "\(\ \)\ ( )"
          Space separated list of commands needed to move to next position for each of
          the 4 possible directions.
  S/      Split it at spaces.
  =       Extract the commands for the current direction.
  ~       Evaluate it.
}w      End of while loop for tracking.
];      Discard stack content. The path was stored in variable L.
Le`     Get list of directions in variable L, and RLE it.
{       Loop over the RLE entries.
  (+      Swap from [length character] to [character length].
}%      End of loop over RLE entries.
", "*   Join them with commas.

Answer 3

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

a=>(b=a.split`
`,b.reverse().some((c,d)=>c[0]!=' '&&((e=d)||1)),j=[],eval("for(g=b[e][f=0];b[e][f]!='X';g=b[e][f],j.push('NSEW'['^v><'.indexOf(i)]+h))for(h=0;g==b[e][f];e+=((i=b[e][f])=='^')-(i=='v'),f+=(i=='>')-(i=='<'),h++);j.join`, `"))

स्पष्टीकरण:

a=>(
    b = a.split('\n'),
    // loops through list from bottom to find arrow
    b.reverse().some(
        (c, d)=>
            // if the leftmost character is not a space, saves the index and exit
            // the loop
            // in case d == 0, the ||1 makes sure the loop is exited
            c[0] != ' ' && ((e = d) || 1)
    ),
    j = [], // array that will hold the instructions
    eval("  // uses eval to allow a for loop in a lambda without 'return' and {}

        // loops through all sequences of the same character
        // e is the first coordinate of the current character being analyzed
        // f is the second coordinate
        // defines g as the character repeated in the sequence
        // operates on reversed b to avoid using a second reverse
        // flips ^ and v to compensate

        for(g = b[e][f = 0];
            b[e][f] != 'X'; // keep finding sequences until it finds the X
            g = b[e][f],    // update the sequence character when it hits the start of a
                            // new sequence
            j.push('NSEW'['^v><'.indexOf(i)] + h)) // find the direction the sequence is
                                                   // pointing to and add the
                                                   // instruction to j

            // loops through a single sequence until it hits the next one
            // counts the length in h
            for(h = 0;
                g == b[e][f]; // loops until there is a character that isn't part of
                              // the sequence
                // updates e and f based on which direction the sequence is pointing
                // sets them so that b[e][f] is now the character being pointed toward
                e += ((i = b[e][f]) == '^') - (i == 'v'),
                f += (i == '>') - (i == '<'),
                // increments the length counter h for each character of the sequence
                h++);

            // return a comma separated string of the instructions
            j.join`, `
    ")
)

Answer 4

जावास्क्रिप्ट (ईएस 6), 189

एक EcmaScript 6 अनुरूप ब्राउज़र में नीचे स्निपेट का परीक्षण करें।

f=m=>{(m=m.split`
`).map((r,i)=>r[0]>' '?y=i:0);for(x=o=l=k=p=0;p!='X';++l,y+=(k==1)-(k<1),x+=(k>2)-(k==2))c=m[y][x],c!=p?(o+=', '+'NSWE'[k]+l,l=0):0,k='^v<>'.search(p=c);alert(o.slice(7))}

// Testable version, no output but return (same size)
f=m=>{(m=m.split`
`).map((r,i)=>r[0]>' '?y=i:0);for(x=o=l=k=p=0;p!='X';++l,y+=(k==1)-(k<1),x+=(k>2)-(k==2))c=m[y][x],c!=p?(o+=', '+'NSWE'[k]+l,l=0):0,k='^v<>'.search(p=c);return o.slice(7)}


// TEST
out = x => O.innerHTML += x+'\n';

test = 
[[`>>>>>>>>>>>>>>>v
               v
               v
               >>>>X`,'E15, S3, E4']
,[`>>>>>>v
^     v
^     >>>>X`,'N2, E6, S2, E4']
,[`X
^
^
^`,'N3']
,[`>>>>>>v
^     v
^     v
      v
      >>>>>>X`,'N2, E6, S4, E6']
,[` X
 ^
 ^
>^`,'E1, N3']
,[`>X`,'E1']
,[`v<<<<<
vX<<<^
>>>>^^
>>>>>^`,'E5, N3, W5, S2, E4, N1, W3']];

test.forEach(t=>{
  var k = t[1];
  var r = f(t[0]);
  out('Test ' + (k==r ? 'OK' : 'Fail')
      +'\n'+t[0]+'\nResult: '+r
      +'\nCheck:  '+k+'\n');
})

<pre id=O></pre>

कम गोल्फ वाला

f=m=>{
  m=m.split('\n'); // split in rows

  x = 0; // Starting column is 0
  m.forEach( (r,i) => r[0]>' '? y=i : 0); // find starting row

  o = 0; // output string
  p = 0; // preceding character
  l = 0; //  sequence length (this starting value is useless as will be cutted at last step)
  k = 0; //  direction (this starting value is useless as will be cutted at last step)
  while(p != 'X') // loop until X found
  {
    c = m[y][x]; // current character in c
    if (c != p) // changing direction
    {  
      o +=', '+'NSWE'[k]+l; // add current direction and length to output
      l = 0 // reset length
    );
    p = c;
    k = '^v<>'.search(c); // get new current direction
    // (the special character ^ is purposedly in first position)
    ++l; // increase sequence length
    y += (k==1)-(k<1); // change y depending on direction
    x += (k>2)-(k==2); // change x depending on direction
  }
  alert(o.slice(7)); // output o, cutting the useless first part
}