18

पथ का अनुसरण करने के लिए चुनौती है:

^n - एन लाइनों द्वारा
vn - नीचे n लाइनों द्वारा
>n - n वर्ण पदों द्वारा सही
<n - n वर्ण पदों द्वारा छोड़ा गया

nएक पूर्णांक है, जो शून्य से अधिक है (अर्थात आप जैसा आदेश प्राप्त नहीं कर सकते हैं >-2)।
आदेशों के बीच कोई विभाजक नहीं है, अच्छी तरह से गठित इनपुट इस तरह दिखता है: >5v8<10^3इनपुट के किसी अन्य रूप की अनुमति नहीं है।
आदेशों की संख्या असीमित है।
कोई और वर्ण इनपुट में रेंगना माना जाता है।

उदाहरण।

इनपुट एक रिक्त स्ट्रिंग है, आउटपुट:
```
*
```
इनपुट >3या तो है <3: या ध्यान दें कि इससे आउटपुट पर कोई फर्क नहीं पड़ता:
```
****
```
इसके लिए समान ^3और v3:
```
*
*
*
*
```
इनपुट: >1v2आउटपुट:
```
**
 *
 *
```
इनपुट: ^4>3v2<1आउटपुट:
```
****
*  *
* **
*
*
```
यदि आप वापस जाते हैं और उसी रास्ते का उपयोग करते हैं, तो कुछ भी नया न बनाएं। उदाहरण के लिए>5<5
```
******
```
... हालाँकि आप कुछ भी नया नहीं बनाते हैं, लेकिन आप स्पष्ट रूप से स्थिति बदलते हैं। इसलिए, यदि आपका इनपुट इस तरह दिखता >4<2v3है: आउटपुट है:
```
*****
  *
  *
  *
```
यह एक अधिक जटिल उदाहरण है: 1) पथ 2 को पार कर सकता है) ध्यान दें कि अंतिम कमांड के अंतिम तीन चरण पूरे रास्ते को दाईं ओर स्थानांतरित करते हैं। इनपुट: v6>4^3<7आउटपुट:
```
   *
   *
   *
********
   *   *
   *   *
   *****
```

^2v2>3<3v3>4^5v5>3^5>4v2<4v3>4^3v3>3^5>4v2<4v3>7^5>4v2<4v3>9^3<2^2v2>4^2v2<2v3>8^5>2v4>2^4v5<3>6^5>5<5v2>5<5v2>5<4v1>8^3<1^2v2>1v2>2^3v3>2^2>1^2v2<1v3<3>11^3<2^2v2>4^2v2<2v3>5^5>5<5v2>5<5v2>5<4v1>7^5>4v2<4v3>4^3v3>3^5>4v2<3v1<1v2>3^1>1v1

आउटपुट:

*   *  *****  *****  *****  *   *     *** *  ******  *     *    *   *  ******  *****  *****
*   *  *   *  *   *  *   *  *   *     * * *  *       *  *  *    *   *  *       *   *  *   *
*****  *****  *****  *****  *****     * * *  ******  ** * **    *****  ******  *****  *****
*   *  *   *  *      *        *       * * *  *        * * *       *    *       *   *  **
*   *  *   *  *      *        *       * ***  ******   *****       *    ******  *   *  *  **
*******************************************************************************************

code-golf ascii-art

— nicael
स्रोत

6

जैसा कि आपने आज यह चुनौती दी है, मुझे लगता है कि यह एक उचित परीक्षण मामला होगा

^2v2>3<3v3>4^5v5>3^5>4v2<4v3>4^3v3>3^5>4v2<4v3>7^5>4v2<4v3>9^3<2^2v2>4^2v2<2v3>8^5>2v4>2^4v5<3>6^5>5<5v2>5<5v2>5<4v1>8^3<1^2v2>1v2>2^3v3>2^2>1^2v2<1v3<3>11^3<2^2v2>4^2v2<2v3>5^5>5<5v2>5<5v2>5<4v1>7^5>4v2<4v3>4^3v3>3^5>4v2<3v1<1v2>3^1>1v1

:।

— इंसुसरनामेहर

क्या आप संभवतः एक संदर्भ कार्यान्वयन प्रदान कर सकते हैं?

— लीजनमोनमल 978 15

हालांकि यह वास्तव में एक डुबकी नहीं है? कृपया तय करें: D

— nicael

@nicael: मैं कहूँगा कि यह नहीं है; I / O अलग है, और ऐसा लगता है कि पथ दूसरे में पार नहीं कर सकते हैं। मुझे लगता है कि यह एक तरह से सरल है जो विभिन्न गोल्फ रणनीतियों की अनुमति दे सकता है। हालांकि, मुझे नहीं पता था कि मैं अचानक इन सभी को अपने आप से फिर से खोल पा रहा था, मुझे लगा कि मैं केवल वोट डाल रहा हूं।

— मारिनस

@marinus ठीक है तो। तो, संबंधित: Yarr! छिपे खजाने का नक्शा! ।

— निकेल

2

MATL , 71 बाइट्स

1thj'.\d+'XX"@Z)XK6L)U:"K1)XK118=K94=-K62=K60=-hv]]YstY)X<1--lqg10*32+c

भाषा / संकलक के वर्तमान रिलीज़ (6.0.0) का उपयोग करता है । मतलाब में और ओक्टेव में काम करता है।

EDIT (21 जून, 2016): भाषा में बदलाव के कारण, कोड को वर्तमान रिलीज़ (16.0.0) में चलाने के लिए कुछ संशोधनों की आवश्यकता है। आप इसे आवश्यक संशोधनों सहित ऑनलाइन आज़मा सकते हैं ।

उदाहरण

>> matl
 > 1thj'.\d+'XX"@Z)XK6L)U:"K1)XK118=K94=-K62=K60=-hv]]YstY)X<1--lqg10*32+c
 > 
> ^4>3v2<1
    ****
    *  *
    * **
    *   
    *  

>> matl
 > 1thj'.\d+'XX"@Z)XK6L)U:"K1)XK118=K94=-K62=K60=-hv]]YstY)X<1--lqg10*32+c
 > 
> ^2v2>3<3v3>4^5v5>3^5>4v2<4v3>4^3v3>3^5>4v2<4v3>7^5>4v2<4v3>9^3<2^2v2>4^2v2<2v3>8^5>2v4>2^4v5<3>6^5>5<5v2>5<5v2>5<4v1>8^3<1^2v2>1v2>2^3v3>2^2>1^2v2<1v3<3>11^3<2^2v2>4^2v2<2v3>5^5>5<5v2>5<5v2>5<4v1>7^5>4v2<4v3>4^3v3>3^5>4v2<3v1<1v2>3^1>1v1
  *   *  *****  *****  *****  *   *     *** *  ******  *     *    *   *  ******  *****  *****
  *   *  *   *  *   *  *   *  *   *     * * *  *       *  *  *    *   *  *       *   *  *   *
  *****  *****  *****  *****  *****     * * *  ******  ** * **    *****  ******  *****  *****
  *   *  *   *  *      *        *       * * *  *        * * *       *    *       *   *  **   
  *   *  *   *  *      *        *       * ***  ******   *****       *    ******  *   *  *  **
  *******************************************************************************************

व्याख्या

कार्यक्रम के चार मुख्य चरण हैं:

इनपुट स्ट्रिंग पढ़ें और इसके घटकों में विभाजित करें।
एक 2-स्तंभ मैट्रिक्स बनाएँ जहां प्रत्येक पंक्ति उचित दिशा में एक इकाई विस्थापन का वर्णन करती है। उदाहरण के लिए, [0 -1]बाईं ओर एक कदम इंगित करता है। पहली पंक्ति पथ की उत्पत्ति है,[1 1]
पहले आयाम के साथ उस मैट्रिक्स की संचयी राशि की गणना करें। अब प्रत्येक पंक्ति एक के निर्देशांक का वर्णन करती है *। मिनिमम मान को सामान्य करें1
1चरण 3 से मैट्रिक्स द्वारा इंगित निर्देशांक में एक नया मैट्रिक्स बनाएं , और 0अन्यथा। इसके बाद इसे चार मैट्रिक्स में बदल दिया जाता है।

कोड:

1th                         % row vector [1 1]. Initiallize matrix of step 2
j                           % (step 1) read input string 
'.\d+'XX                    % split into components. Creates cell array of substrings
"                           % (step 2) for each component
   @Z)XK                    % unbox to obtain substring and copy
   6L)U:                    % obtain number and build vector of that size
   "                        % repeat as many times as that number
      K1)                   % paste substring. Get first character: '^', 'v', '>', '<'
      XK118=K94=-           % vertical component of unit displacement: -1, 0 or 1
      K62=K60=-             % horizontal component of unit displacement: -1, 0 or 1
      h                     % concatenate horizontally
      v                     % append vertically to existing matrix
   ]                        % end
]                           % end
Ys                          % (step 3) cumulative sum along first dimension
tY)X<1--                    % normalize to minimum value 1
lqg                         % (step 4) build matrix with 0/1
10*32+c                     % replace 0 by space and 1 by asterisk

— लुइस मेंडो
स्रोत

क्या यह अंतिम उदाहरण के लिए काम करता है?

— निकेल

कितना अच्छा है! हाँ यह करता है। मैंने इसे शामिल करने के लिए अपने उत्तर को संपादित किया है

— लुइस मेंडो

8

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

शून्य इनपुट के लिए 1 बग फिक्स - आउटपुट '*' संपादित करें
x और y के लिए दिशा के 2 सरल डिकोडिंग संपादित करें

यहां मेरा जवाब है खजाने का नक्शा , चश्मा पूरा करने के लिए संशोधित।

F=m=>(m.replace(/\D(\d+)/g,(d,z)=>{for(;z--;r=[...r],r[x]=m,p[y]=r.join``)for(d<'>'?--x:d<'^'?++x:d<'v'?--y:++y,p=~x?~y?p:[y=0,...p]:p.map(r=>' '+r,x=0),r=p[y]||'';!r[x];)r+=' '},x=y=0,p=[m='*']),p.join`
`)

कम गोल्फ और अधिक या कम समझाया

f=m=>(
  x=y=0, // starting position
  p=['*'], // output string array (initialized with minimum output)
  m.replace( /\D(\d+)/g, 
  (d,z) => // execute the following for each group direction/length. Length in z, direction in d[0]
  {
    while( z--)  // repeat for the len
    {
      // check d to change values of x and y
      // all the comparison are with > and <, not equal
      // so that they work with the whole d, not just d[0]
      d<'>'?--x:d<'^'?++x:d<'v'?--y:++y,
      // now if x or y are < 0 then p must be adjusted  
      p = ~x 
        ? ~y
          ? p // both x and y are >= 0, p is not changed
          : [y = 0, ...p] // y < 0, shift p by on adding a 0 element and set y to 0
        : p.map(r=> ' ' + r, x = 0); // x < 0, add a space to the left for each row in p and set x to 0
      r = p[y] || ''; // get current row in r
      for( ; !r[x]; ) // if the current row is empty or too short
        r += ' '; // ... add spaces up to position x
      // set character in x position
      r = [...r], // the shorter way is converting to array ...
      r[x] = '*', // setting the element
      p[y] = r.join`` // and the back to string using join
    }
  }),
  p.join`\n` // return output array as a newline separated string
}

परीक्षा

F=m=>(m.replace(/\D(\d+)/g,(d,z)=>{for(;z--;r=[...r],r[x]='*',p[y]=r.join``)for(d<'>'?--x:d<'^'?++x:d<'v'?--y:++y,p=~x?~y?p:[y=0,...p]:p.map(r=>' '+r,x=0),r=p[y]||'';!r[x];)r+=' '},x=y=0,p=['*']),p.join`
`)

// TEST
console.log = x => O.textContent += x + '\n';

console.log(F('')+'\n')

console.log(F('v6>4^3<7')+'\n')

console.log(F('^2v2>3<3v3>4^5v5>3^5>4v2<4v3>4^3v3>3^5>4v2<4v3>7^5>4v2<4v3>9^3<2^2v2>4^2v2<2v3>8^5>2v4>2^4v5<3>6^5>5<5v2>5<5v2>5<4v1>8^3<1^2v2>1v2>2^3v3>2^2>1^2v2<1v3<3>11^3<2^2v2>4^2v2<2v3>5^5>5<5v2>5<5v2>5<4v1>7^5>4v2<4v3>4^3v3>3^5>4v2<3v1<1v2>3^1>1v1'))

<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

पूरी तरह से काम करने लगता है।

— 19

केवल एक अपवाद के साथ: जब इनपुट खाली होता है, तो आवश्यकता लिखना होता है *।

— निकेल

उन लोगों के लिए जिनके ब्राउज़र में ES6 की व्याख्या करने में समस्या आ रही है: jsfiddle.net/2vrrd1wt ।

— निकेल

@nicael को धन्यवाद देने के लिए धन्यवाद। 1 बाइट के लिए निश्चित

— edc65

1

पर्ल, 174 बाइट्स

@M=(['*']);pop=~s/(.)(\d+)/($z=ord$1)&64?($y+=$z&8?-1:1)<0&&unshift@M,[$y++]:($x+=($z&2)-1)<0?@M=map{[$x=0,@$_]}@M:0,$M[$y][$x]='*'for1..$2/gre;print map{map{$_||$"}@$_,$/}@M

कमांडलाइन तर्क के रूप में इनपुट की अपेक्षा करता है। तर्क उद्धृत करना सुनिश्चित करें!
उदाहरण:perl 177.pl "<1^2>3v4<5^6>7v8<9^10>11"

कुछ पठनीय:

@M=(['*']);                                 # output origin/starting position

pop=~                                       # apply regex to cmdline arg
s!(.)(\d+)!                                 # match $1=direction, $2=count

    ($z=ord$1)                              # get ASCII code for char
    &64                                     # 'v^' have this bit set, '<>' don't

        ?                                   # adjust y:
            ($y += $z&8 ? -1 : 1)           # '^' has bit set, 'v' doesn't
            < 0 &&                          # negative y?
            unshift @M, [$y++]              # prepend row; abuse [] for $y++ saving 3 bytes

        :                                   # adjust x:
            ($x+= ($z&2) -1 )               # '>' has bit set: 2-1=1, '<' hasn't: 0-1=-1
            < 0 ?                           # negative x?
                @M = map{ [$x=0,@$_] } @M   # prepend column, reset x
                :0                          # '?:0' shorter than '&&()'
        ,                                   # oh, and also:
        $M[$y][$x]='*'                      # output current position.

    for 1..$2                               # iterate count
!grex;                                      

print map{ map{$_||$"} @$_, $/ } @M         # iterate rows/cols, print '*' or space

— केनी
स्रोत

0

05AB1E , 27 बाइट्स

">^v<"žCÍS1ú‡#¦εć)>}ø`'*s<Λ

इसे ऑनलाइन आज़माएं! (2020 काफी करीब है इसलिए क्यों नहीं)

— मिस्टर एक्सकोडर
स्रोत

मार्ग का अनुसरण करें

MATL , 71 बाइट्स

उदाहरण

व्याख्या

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

पर्ल, 174 बाइट्स

05AB1E , 27 बाइट्स