Erstellen Sie ein einfaches Tool für hübsche Kommentare

14

Herausforderung:

Etwas ASCII-Kunst ist mühsam, erleichtert aber das Lesen von Codekommentaren, insbesondere wenn der Code dicht ist. Die Herausforderung besteht darin, ein einfaches Tool zu erstellen, das Kommentare mit Pfeilen in einfache ASCII-Grafiken umwandelt. Die zu ändernden Kommentare werden durch leere Kommentare begrenzt.

Wenn Sie beispielsweise die Haskell-Kommentarsyntax annehmen, konvertieren Sie Folgendes:

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

Dazu:

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

Regeln:

  • Ihre Antwort kann entweder eine Funktion oder ein vollständiges Programm sein
  • Sie können die Sprache auswählen, mit der gearbeitet werden soll, indem Sie das "-" durch zwei oder mehr Zeichen ersetzen, die einen Kommentar in einer bestimmten Sprache abgrenzen
  • Wenn Sie ein anderes Kommentarformat verwenden, für das Anfangs- und Endbegrenzer erforderlich sind, muss jede Zeile der neu formatierten Abschnitte ein richtiger Kommentar sein
  • Die neu zu formatierenden Abschnitte werden durch den leeren Kommentar "\ n - \ n" begrenzt.
  • Abgesehen vom Hinzufügen von Zeilenumbrüchen darf das Programm keine der Eingaben außer den begrenzten Abschnitten ändern
  • Ein Kommentar, der mit einer beliebigen Anzahl von Leerzeichen gefüllt ist, kann unmittelbar vor einem ordnungsgemäß formatierten Ausgabeabschnitt stehen
  • Standardlücken sind nicht zulässig

Zusätzliche Beispiele:

(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

Wertung:

  • Wenigste Bytes gewinnt
  • Einsendungen ohne Erklärungen oder nicht triviale Beispieleingabe / -ausgabe werden nicht berücksichtigt (obwohl ich eine Nachfrist einhalten werde, um Zeit für das Hinzufügen solcher Beispiele zu haben).
Michael Klein
quelle
2
Was ist, wenn nur ein Zeichen erforderlich ist, um einen Kommentar abzugrenzen?
Adám
Solange es ein gültiger Kommentar in der Sprache ist, ist es in Ordnung
Michael Klein
Wir können davon ausgehen, dass jeder Kommentarbereich, der neu formatiert werden muss, genau eine Zeile mit Positionsmarkierungssternchen enthält, oder? Wird diese Zeile immer die letzte sein?
Handarbeit
Ja, genau eins und immer das letzte (Kommentar vor dem Endbegrenzer)
Michael Klein
Und die Anzahl der Sternchen entspricht der Anzahl der vorhergehenden Zeilen in diesem Abschnitt, oder?
Manatwork

Antworten:

4

Ruby, 160 Zeichen

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

Probelauf:

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 

Kurze Beschreibung:

.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
Mann bei der Arbeit
quelle
5

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

Puh, das ist mein erster Beitrag zu CG. Hat, glaube ich, eine ganz andere Richtung eingeschlagen als Washington Guedes. Endete 54 Bytes kürzer als sein erster Durchgang. Das alles mit der Hand abzubauen war anstrengend. Mein einziges Bedauern ist, dass ich die while-Schleife noch nicht beseitigen kann, wodurch ich auch die Rendite kürzen könnte.

Vollständiges Umschreiben, teilweise inspiriert von einigen anderen Antworten. Ich musste das Ganze in Karten festhalten, um die Rückkehr zu verbessern. Das Code-Snippet enthält die kommentierte Version.

Hat ein paar Bytes mehr Zeit gekostet und das Beispiel für sich arbeiten lassen. (Du brauchst einen größeren Monitor.) :)

Ich habe einen ganzen Buchstaben in der Spezifikation vergessen! Glücklicherweise war das Hinzufügen des führenden '<' eine winzige, triviale Korrektur.

Emmett R.
quelle
3

Python 2, 299 Bytes

Erwartet eine nachgestellte Zeile in der Eingabe

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

Erklärung / Beispiel

Eingang:

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

Teilt die Eingabe durch --\n. Jede zweite Zeichenfolge ist ein Kommentarblock mit Trennzeichen.

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

Läuft durch jede Zeichenfolge. Wenn die Zeichenfolge kein Kommentar ist, wird sie nur gedruckt. Andernfalls:

Teilt jede Zeile im Kommentarblock.

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

Ergibt die beiden unteren Zeilen, indem die Zeilen von *s durch vund ersetzt werden |.

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

Entfernen Sie für jede Kommentarzeile (rückwärts) die Spalte ganz rechts, fügen Sie sie hinzu /, füllen Sie sie mit einem Pad auf -und fügen Sie einen Kommentar hinzu.

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

Alles drucken

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

Weniger golfen:

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
TFeld
quelle
1

JavaScript (ES6), 253

Als anonyme Funktion, mit dem Code als String-Parameter zu formatieren und den formatierten Code zurückzugeben.

Anmerkungen

  1. Das Markierungskommentarpaar muss den richtigen Text enthalten (Kommentarzeilen, dann Sterne)
  2. ... oder das Paar darf nichts einschließen (zusätzliches Beispiel 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`
`)

Weniger golfen

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
}

Prüfung

edc65
quelle
Damit fehlt mir der zweite Kommentarblock auf Chrome 47 ohne Fehler. Außerdem, Mist, habe ich vorher nicht gesehen, dass Sie irgendeine Kommentarsyntax mit irgendeiner Sprache verwenden können .
Emmett R.
Äh, ja, du hast recht. @EmmettR. Vielen Dank. Ich werde versuchen, es zu beheben
edc65