Meydan okuma:

Bazı ascii-art yapmak bir acıdır, ancak özellikle kod yoğun olduğunda kod yorumlarının okunmasını kolaylaştırır. Zor olan, yorumları oklarla basit ascii-art'a dönüştüren basit bir araç yapmaktır. Değiştirilecek yorumlar boş yorumlar ile sınırlandırılır.

Örneğin, Haskell yorum sözdizimini varsayalım, şunu dönüştürün:

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

Buna:

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

Kurallar:

• Cevabınız bir işlev veya tam program olabilir
• "-" karakterini, bir dilde bir açıklamayı sınırlayan iki veya daha fazla karakterle değiştirerek, bununla çalışmak için yapılmış dili seçebilirsiniz.
• Sınırlayıcıların başlangıcını ve bitişini gerektiren başka bir yorum biçimi kullanılıyorsa, yeniden biçimlendirilmiş bölümlerin her satırı uygun bir yorum olmalıdır
• Yeniden biçimlendirilecek bölümler "\ n - \ n" boş yorumuyla sınırlandırılmıştır.
• Yeni satır eklemenin yanı sıra, program sınırlandırılmış bölümler dışında hiçbir girdiyi değiştirmemelidir
• Rasgele sayıda boşlukla dolu bir yorum, düzgün biçimlendirilmiş bir çıktı bölümünden hemen önce gelebilir
• Standart boşluklara izin verilmiyor

Ek Örnekler:

(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

puanlama:

• En az bayt kazanır
• Açıklamaları olmayan veya önemsiz olmayan örnek girdi / çıktıları kabul edilmeyecektir (buna ek olarak zaman ayırmak için yetkisiz bir süre bırakacağım)

Ruby, 160 karakter

->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))*''}}

Örnek çalışma:

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 

Kısa açıklama:

.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 bayt

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

Vay be, bu benim CG ile ilgili ilk sunumum. Sanırım Washington Guedes'ten tamamen farklı bir yol aldı. İlk baytından 54 bayt daha kısa sürede sona erdi. Bütün bunları elle küçültmek yorucuydu. Bir pişmanlığım henüz while döngüsünü ortadan kaldıramıyor, bu da dönüşü kesmeme izin verecek.

Toplam yeniden yazma, diğer birkaç cevaptan kısmi ilham alıyor. Haritadaki her şeyi kapatmam gerekiyor, geri dönüşü çok daha iyi hale getiriyorum. Kod snippet'i yorum yapılan sürümü içeriyor.

Birkaç bayt daha aldı ve örneğin kendi kendine çalışmasını sağladı. (Daha büyük bir monitöre ihtiyacınız olacak.) :)

Spesifikasyondaki tüm mektubu unuttum! Neyse ki, önde gelen '<' ifadesini eklemek küçük, önemsiz bir düzeltmeydi.

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 bayt

Girdide bir satırsonu beklenir

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

Açıklama / Örnek

Giriş:

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

Girişi böler --\n. Her ikinci dize, sınırlandırılmış bir yorum bloğudur.

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

Her dizeden geçer. Dize bir yorum değilse, yalnızca dizeyi yazdırır. Aksi takdirde:

Yorum satırındaki her satırı böler.

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

Çizgilerini değiştirerek iki alt satır yapar *ile s vve |.

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

Her yorum satırı için (geriye doğru) en sağdaki sütunu kaldırın, ekleyin /, işaretleyin -ve yorum ekleyin.

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

Her Şeyi Yazdır

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

Daha az golf:

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

Anonim bir işlev olarak, kodun bir string parametresi olarak biçimlendirilmesi ve biçimlendirilmiş kodun döndürülmesi.

notlar

1. İşaretçi yorumları çifti doğru metni içermelidir (yorum satırları, ardından yıldızlar)
2. ... veya parite hiçbir şey içermemelidir (ek örnek 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`
`)

Daha az golf

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
}

Ölçek

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>