Thách thức là đi theo (vẽ) đường dẫn:

• ^n - lên bởi n dòng
• vn - xuống bởi n dòng
• >n - đúng bởi n vị trí nhân vật
• <n - còn lại bởi vị trí n ký tự

• nlà một số nguyên, lớn hơn 0 (tức là bạn không thể nhận lệnh như thế nào >-2).
• Không có dấu phân cách giữa các lệnh, đầu vào được tạo tốt trông như thế này : >5v8<10^3, không có hình thức đầu vào nào được phép.
• Số lượng lệnh là không giới hạn.
• Không có nhiều nhân vật được cho là leo vào đầu vào.

Ví dụ.

1. Đầu vào là một chuỗi rỗng, đầu ra:

   *
   

2. Đầu vào là một trong hai >3hoặc <3: lưu ý rằng điều này không tạo ra bất kỳ sự khác biệt nào đối với đầu ra:

   ****
   

3. Tương tự cho ^3và v3:

   *
   *
   *
   *
   

4. Đầu vào : >1v2, đầu ra:

   **
    *
    *
   

5. Đầu vào : ^4>3v2<1, đầu ra:

   ****
   *  *
   * **
   *
   *
   

6. Nếu bạn quay lại và sử dụng cùng một đường dẫn, đừng vẽ bất cứ điều gì mới. Ví dụ>5<5

   ******
   

7. ... mặc dù bạn không vẽ bất cứ điều gì mới, rõ ràng bạn thay đổi vị trí. Do đó, nếu đầu vào của bạn trông như thế này : >4<2v3, đầu ra là:

   *****
     *
     *
     *
   

8. Đây là một ví dụ phức tạp hơn: 1) đường dẫn có thể tự vượt qua 2) lưu ý rằng ba bước cuối cùng của lệnh cuối cùng sẽ dịch chuyển toàn bộ đường dẫn sang phải. Đầu vào : v6>4^3<7, đầu ra:

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

9. Đầu vào :

   ^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
   

   Đầu ra:

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

MATL , 71 byte

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

Sử dụng bản phát hành hiện tại (6.0.0) của ngôn ngữ / trình biên dịch. Hoạt động trong Matlab và Octave.

EDIT (ngày 21 tháng 6 năm 2016): do thay đổi ngôn ngữ, mã yêu cầu một vài sửa đổi để chạy trong bản phát hành hiện tại (16.0.0). Bạn có thể thử nó trực tuyến bao gồm các sửa đổi cần thiết.

Ví dụ

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

Giải trình

Chương trình có bốn bước chính:

1. Đọc chuỗi đầu vào và phân chia thành các thành phần của nó.
2. Xây dựng ma trận 2 cột trong đó mỗi hàng mô tả một chuyển vị đơn vị theo hướng thích hợp. Ví dụ, [0 -1]chỉ ra một bước ở bên trái. Hàng đầu tiên là nguồn gốc của đường dẫn,[1 1]
3. Tính tổng tích lũy của ma trận đó dọc theo chiều thứ nhất. Bây giờ mỗi hàng mô tả tọa độ của a *. Bình thường hóa thành giá trị tối thiểu1
4. Tạo một ma trận mới chứa 1tại tọa độ được chỉ định bởi ma trận từ bước 3, và 0nếu không. Điều này sau đó được chuyển thành một ma trận char.

Mã số:

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

JavaScript (ES6), 204 211 210

Chỉnh sửa 1 Sửa lỗi - đầu ra '*' cho khoảng trống đầu vào
Chỉnh sửa 2 Giải mã đơn giản hướng sang x và y diff

Đây là câu trả lời của tôi cho Bản đồ kho báu , được sửa đổi để hoàn thành các thông số kỹ thuật.

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

Ít chơi gôn và giải thích nhiều hay ít

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
}

Kiểm tra

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>

Perl, 174 byte

@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

Dự kiến ​​đầu vào là đối số dòng lệnh. Hãy chắc chắn để trích dẫn lập luận!
Thí dụ:perl 177.pl "<1^2>3v4<5^6>7v8<9^10>11"

Một chút có thể đọc được:

@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

05AB1E , 27 byte

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

Hãy thử trực tuyến! (2020 là đủ gần vậy tại sao không)