Thử thách:

Một số ascii-art là một nỗi đau để thực hiện, nhưng làm cho các nhận xét mã dễ đọc hơn, đặc biệt là khi mã dày đặc. Thách thức là tạo ra một công cụ đơn giản để chuyển đổi nhận xét thành nghệ thuật đơn giản bằng mũi tên. Các ý kiến ​​để sửa đổi được phân định bởi các bình luận trống.

Ví dụ: giả sử cú pháp nhận xét Haskell, chuyển đổi này:

--
-- Here's a thing
-- Here's another thing
-- The most important thing
-- *    *     *
--
f x=x+1*x*1*1*0

Về điều này:

-- /------------< Here's a thing
-- |    /-------< Here's another thing
-- |    |     /-< The most important thing
-- |    |     |
-- v    v     v
f x=x+1*x*1*1*0

Quy tắc:

• Câu trả lời của bạn có thể là một chức năng hoặc chương trình đầy đủ
• Bạn có thể chọn ngôn ngữ được tạo để làm việc, thay thế "-" bằng hai hoặc nhiều ký tự phân định một nhận xét bằng một số ngôn ngữ
• Nếu sử dụng định dạng nhận xét khác yêu cầu dấu phân cách bắt đầu và kết thúc, mỗi dòng của các phần được định dạng lại phải là một nhận xét thích hợp
• Các phần được định dạng lại được phân định bởi chú thích trống "\ n - \ n"
• Bên cạnh việc thêm dòng mới, chương trình không được thay đổi bất kỳ đầu vào nào ngoại trừ các phần được phân tách
• Một nhận xét chứa đầy số lượng khoảng trắng tùy ý có thể xuất hiện ngay trước khi phần đầu ra được định dạng chính xác
• Các sơ hở tiêu chuẩn không được phép

Ví dụ khác:

(input)
--
--
(output)
nothing


(input)
[Code Here]
--
-- important
--    *
--
(output)
[Code Here]
--    /-< important
--    |
--    v


(input)
--
-- Do
-- Re
-- Mi
-- Fa
-- So
-- *****
--
(output)
-- /-----< Do
-- |/----< Re
-- ||/---< Mi
-- |||/--< Fa
-- ||||/-< So
-- |||||
-- vvvvv

Ghi điểm:

• Ít byte nhất sẽ thắng
• Đệ trình mà không có giải thích hoặc đầu vào / đầu ra ví dụ không tầm thường sẽ không được xem xét (mặc dù tôi sẽ để lại một khoảng thời gian ân hạn để cho phép thời gian để thêm như vậy)

Ruby, 160 ký tự

->c{c.gsub(/^--$(.+?)^--$/m){*t,a=$&.lines[1..-2]
a&&a.chop!&&(t.map{|l|a[?*]=?/
l[0,2]=a.gsub(/(?<=\/).*/){?-*$&.size}+'-<'
a[?/]=?|
l}<<a+$/+a.tr(?|,?v))*''}}

Chạy mẫu:

2.1.5 :001 > puts ->c{c.gsub(/^--$(.+?)^--$/m){*t,a=$&.lines[1..-2];a&&a.chop!&&(t.map{|l|a[?*]=?/;l[0,2]=a.gsub(/(?<=\/).*/){?-*$&.size}+'-<';a[?/]=?|;l}<<a+$/+a.tr(?|,?v))*''}}["
2.1.5 :002"> --
2.1.5 :003"> -- Here's a thing
2.1.5 :004"> -- Here's another thing
2.1.5 :005"> -- The most important thing
2.1.5 :006"> -- *    *     *
2.1.5 :007"> --
2.1.5 :008"> f x=x+1*x*1*1*0
2.1.5 :009"> "]

-- /------------< Here's a thing
-- |    /-------< Here's another thing
-- |    |     /-< The most important thing
-- |    |     |
-- v    v     v
f x=x+1*x*1*1*0
 => nil 

Mô tả ngắn gọn:

.lines splits the section to array items ─────────╮
                                                  ▽

.gsub extracts ⎧   --                             0         
these sections ⎪   -- Here's a thing              1   t[0]   
for processing ⎨   -- Here's another thing        2   t[1]   
and replaces   ⎪   -- The most important thing    ⋮   t[2]   
them with the  ⎪   -- *    *     *               -2   a      
pretty version ⎩   --                            -1          
rest untouched —   f x=x+1*x*1*1*0
                                                      △
only the needed lines get into variables ─────────────╯



a = "-- *    *     *" + "-<"           inside .gsub's block
        ↓↓                             the first 2 characters
t[0] = "-- Here's a thing"             of t's each item are
t[1] = "-- Here's another thing"       replaced with a's value
t[2] = "-- The most important thing"   and the the separator



not only t's items are transformed inside .gsub's block,
but a's value also gets changed in multiple small steps

                       change a's value    change the value    change a's value
   a's initial value   before insertion   being inserted now   after insertion
   ╭───────────────╮   ╭───────────────╮   ╭───────────────╮   ╭───────────────╮

0  "-- *    *     *" → "-- /    *     *" → "-- /-----------" → "-- |    *     *"
1  "-- |    *     *" → "-- |    /     *" → "-- |    /------" → "-- |    |     *"
2  "-- |    |     *" → "-- |    |     /" → "-- |    |     /" → "-- |    |     |"

                       ╰───────────────╯   ╰───────────────╯   ╰───────────────╯
                      change first * to /  change everything  change first / to |
                                          after / with string
                                          of - of same length

JavaScript (ES6), 418 , 237 , 233 , 236 byte

f=(s)=>(d='\n//',s.split(d+'\n').map((x,y)=>y%2?'//'+(l=x.slice(2).split(d),t=l.pop().split('*'),l.map((i,j)=>t.map((k,m)=>m==j?k+'/':m<j?k+'|':k.replace(/ /g,'-')+'-').join('')+'<'+i).join(d)+d+t.join('|')+d+t.join('v')):x).join('\n'))

Whew, đây là đệ trình đầu tiên của tôi về CG. Tôi nghĩ, một chiến thuật hoàn toàn khác với Washington Guedes. Đã kết thúc ngắn hơn 54 byte so với lần đầu tiên của anh ấy. Giảm thiểu tất cả điều này bằng tay là mệt mỏi. Một điều hối tiếc của tôi là chưa thể loại bỏ vòng lặp while, điều này cũng sẽ cho phép tôi cắt giảm lợi nhuận.

Viết lại toàn bộ, lấy cảm hứng một phần từ một vài câu trả lời khác. Tôi phải đóng toàn bộ mọi thứ trong bản đồ, khiến việc trở lại tốt hơn nhiều. Đoạn mã chứa phiên bản nhận xét.

Mất thêm một vài byte và làm cho ví dụ hoạt động trên chính nó. (Bạn sẽ cần một màn hình lớn hơn.) :)

Quên cả một lá thư trong thông số kỹ thuật! May mắn thay, việc thêm '<' hàng đầu là một sửa chữa nhỏ, tầm thường.

var comments = `
//
// New function, declare the comment delimiter
// Chop the string by the fancy comment delimiter
// Iterate over the array.
// Because of how it's delimited, and how JS splits strings, only the even elements will contain fancy comments.
// Add the original comment delimiter to the front of the first line, because join won't.
// we've got a single fancy comment, split it into lines.
// Take the last line, our asterisk template, and split it on the asterisks themselves. We were only gonna replace them anyway.
// Now we get to the real work. Iterate the remaining lines.
// For each chunk of whitespace in the template array, toss a different character on the end based on where we are in the series of lines.
// if we're at the matching asterisk, insert a slash
// Otherwise, if we're at a prior asterisk, add a pipe.
// Finally, replace anything afer the matching asterisk with dashes, join the template, and add it to the line text.
// Join the lines with the delimiter
// Add the pipe line...
// And the v line...
// For odd chunks, just return the chunk.
// Join all the code chunks and autoreturn.
//      *        *               *          *   *     *                     *                    *            *            *          *         *                                        *           *             *          *  *  
//
`
f=(s)=>(d='\n//',s.split(d+'\n').map((x,y)=>y%2?'//'+(l=x.slice(2).split(d),t=l.pop().split('*'),l.map((i,j)=>t.map((k,m)=>m==j?k+'/':m<j?k+'|':k.replace(/ /g,'-')+'-').join('')+'<'+i).join(d)+d+t.join('|')+d+t.join('v')):x).join('\n'))

str = `
//
// This is a test
// with two lines
// actually three
// *  *       *
//
var myCode = function () {

}
// This doesn't cause any trouble.

moreCode(stuff--)

//
// another test?
//  *
//

`
document.getElementById('before').textContent = str;
document.getElementById('after').textContent = f(str);
document.getElementById('self').textContent = f(comments)+'f='+f.toString();

Test cases before:
<pre id="before" style="background:#eef"></pre>
Test cases after:
<pre id="after" style="background:#eef"></pre>
Self-annotated:
<pre id="self"></pre>

Python 2, 299 byte

Yêu cầu một dòng mới trong đầu vào

i=input().split('--\n')
a=0
for j in i:
 a+=1
 if a%2:print j,;continue
 if''==j:continue
 l=j.split('\n');n=l[-2];r=l[:-2];R=[n.replace('*','v'),n.replace('*','|')];L=R[1]
 for x in range(len(l)-2)[::-1]:L=L[:L.rfind('|')]+'/';R+=[L.ljust(n.rfind('*')+2,'-')+'< '+r[x][3:]]
 print'\n'.join(R[::-1])

Giải thích / Ví dụ

Đầu vào:

[Code Here]
--
-- important
--    *
--

Chia đầu vào bằng --\n. Mỗi chuỗi thứ hai là một khối nhận xét phân định.

['[Code Here]\n',
'-- important\n-- stuff\n--    *  *\n',
'']

Chạy qua từng chuỗi. Nếu chuỗi không phải là một nhận xét, thì chỉ cần in chuỗi. Nếu không thì:

Tách từng dòng trong khối bình luận.

['-- important', '-- stuff', '--    *  *', '']

Làm cho hai dòng dưới cùng bằng cách thay thế các dòng của *s bằng vvà |.

['--    v  v', '--    |  |']

Đối với mỗi dòng bình luận (ngược), hãy xóa cột ngoài cùng bên phải, thêm /, đệm với -và thêm nhận xét.

'--    |  /'
'--    /'
'--    /----< important'

In mọi thứ

--    /----< important
--    |  /-< stuff
--    |  |
--    v  v

Ít chơi gôn hơn:

i=input().split('--\n')
a=0
for j in i:
 a+=1
 if a%2:print j,;continue # Not commment
 if''==j:continue # Empty comment
 l=j.split('\n') # Split comment into lines
 r=l[:-2]
 # Replace line of *s with v and | respectively
 R=[l[-2].replace('*','v'),l[-2].replace('*','|')]
 L=R[1][3:] # line of |
 for x in range(len(l)-2)[::-1]: # For each comment line
  L=L[:L.rfind('|')]+'/' #Remove rightmost column
  # Add a line with '-- ',columns, and comment
  R+=['-- '+L.ljust(n.rfind('*')-1,'-')+'< '+r[x][3:]]
 print'\n'.join(R[::-1]) #Print all comment lines

JavaScript (ES6), 253

Là một hàm ẩn danh, với mã để định dạng dưới dạng tham số chuỗi và trả về mã được định dạng.

Ghi chú

1. Cặp ý kiến ​​đánh dấu phải kèm theo đúng văn bản (dòng nhận xét, sau đó là dấu sao)
2. ... hoặc cặp phải không kèm theo gì (ví dụ bổ sung 1)

t=>(t=t.split`
`,t.map((r,i)=>r=='--'?(c++&&l.map((r,j)=>(p+=q[j],z+=~q[j].length,t[i-n+j]=p+`/${'-'.repeat(z+1)}<`+r.slice(3),p+=`|`),q=l.pop(c=p=``)||p,z=q.length,q=q.split`*`,t[i]=p+q.join`v`,t[i-1]=p+q.join`|`),l=[]):n=l.push(r),c=0,l=[]),t.join`
`)

Ít chơi gôn

f=t=>{
  t = t.split`\n`; // string to array of lines
  l = []; // special coment text
  c = 0; // counter of marker comment '--'
  t.forEach((r,i)=>{ // for each line of t - r: current line, i: index
    if (r == '--') // if marker comment
    {
       ++ c; // increment marker counter
       if (c > 1) // this is a closing marker
       {
          c = 0; // reset marker counter
          if (n > 0) // n is the length of array l
             q = l.pop(); // get last line from l, have to be the star line
          else
             q = ''; // no text comment, no star line 
          p = '';  // prefix for drawing the tree
          z = q.length; // length of star line, used to draw the tree horiz lines
          q = q.split('*'); // split to get star count and position
          // each element in q is the spaces between stars
          // modifiy the current and previous text line 
          t[i] = p + q.join`v`; // current row was '--', becomes the V line
          t[i-1] = p + q.join`|`; // previous row was the star line, becomes the last tree line
          l.forEach((r,j)=>{ // for each line in l, r: current line, j: index
             // each line in tree is: prefix("-- |  |"...) + ... "---< " + text
             p = p + q[j]; // adjust prefix
             z = z - q[j].length - 1 // adjust length of '---'
             // modify text in t
             t[i-n+j] = p // prefix
                + '/' + '-'.repeat(z+1) + '<'  // horiz line and <
                + r.slice(3); // text, removed '-- '
             p = p + '|'; // add vertical bar to prefix
          });
       } // end if closing comment
       l = []; // reset l
    }  
    else // not a special comment marker
       n = l.push(r) // add current line to l, set n to array size
  });
  return t.join`\n` // join to a single string
}

Kiểm tra

f=t=>(
  t=t.split`\n`,
  t.map((r,i)=>
    r=='--'
    ?(
      c++&&l.map((r,j)=>(
        p+=q[j],z+=~q[j].length,t[i-n+j]=p+`/${'-'.repeat(z+1)}<`+r.slice(3),p+=`|`),
        q=l.pop(c=p=``)||p,z=q.length,q=q.split`*`,t[i]=p+q.join`v`,t[i-1]=p+q.join`|`
      ),l=[]
    ):n=l.push(r)
    ,c=0,l=[]
  ),
  t.join`\n` 
)
        
function update(){O.textContent=f(C.value)}

update()

textarea, pre { width:50%; height: 200px }

Input<br>
<textarea id=C>
code line 1
--
-- Do
-- Re
-- Mi
-- Fa
-- So
-- *****
--
code to explain
--
--
code line n
code line n+1
--
-- important
--    *
--

</textarea><br>
Output <button onclick="update()">Update</button><br>
<pre id=O></pre>