Erfolgreiche Code-Golf-Einsendungen sind von Natur aus überall mit verrückten Symbolen gefüllt. Um ihre Einsendung verständlicher zu machen, geben viele Code-Golfer eine Erklärung ihres Codes an. In ihrer Erklärung wird die Codezeile in ein vertikal aufgelöstes Diagramm umgewandelt.

Zum Beispiel, wenn dies mein Code wäre:

1_'[3:~2@+]`

Eines der vielen möglichen Diagramme, die ich erstellen könnte, sieht folgendermaßen aus:

1           
 _'         
   [      ] 
   [3:    ] 
   [  ~   ] 
   [   2@ ] 
   [     +] 
           `

Das Ziel

In dieser Herausforderung schreiben Sie ein Tool zur automatischen Formatierung von Erklärungen, das eine Codezeile verwendet und ein Diagramm erstellt, zu dem leicht erklärender Text hinzugefügt werden kann.

Um dies zu einer nützlicheren Herausforderung zu machen , kann der Benutzer den Inhalt jeder Zeile angeben, indem er eine Formatierungszeichenfolge bereitstellt. Die Formatierungszeichenfolge ist eine zweite Zeile, die nur Buchstaben enthält A-Za-zund dieselbe Länge wie das Programm hat. Die Buchstaben geben die Reihenfolge an, in der die Zeichen des Programms in der Erläuterung gedruckt werden sollen.

Hier ist ein Beispiel für E / A ohne eckige Formatierung :

123423
AabcBC

1     
    2 
     3
 2    
  3   
   4  

Klammern

Wenn mehr als ein Zeichen im Programm dieselbe Prioritätsstufe hat, fungiert dieser Zeichensatz als ein einzelner Codeblock (wenn sie eine Gruppe bilden) oder als ein Satz von Klammern (wenn sie dazwischen andere Zeichen enthalten). Die allgemeinen Regeln sind einfach:

1. Zeichen werden in einer Zeile des Diagramms erst angezeigt, wenn alle anderen Zeichen mit höherer Priorität bereits in den darüber liegenden Zeilen des Diagramms angezeigt wurden.

2. Zeichen gleicher Priorität werden immer in die gleichen Zeilen gedruckt. Wenn ein bestimmtes Zeichen in einer Zeile erscheint, erscheinen alle anderen Zeichen gleicher Priorität in der Zeile.

3. In jeder Zeile wird weiterhin eine Reihe von Zeichen mit gleicher Priorität angezeigt, bis alle anderen von ihr eingeschlossenen Zeichen mindestens einmal vorgekommen sind. Dies ermöglicht "klammerartige" Konstruktionen. Wenn bceabes sich um die Prioritäten handelt, berscheinen die Zeichen in der zweiten Zeile (sie haben die zweithöchste Priorität) und werden so lange angezeigt, bis alle ceaZeichen erschienen sind. Wenn die Prioritätszeichenfolge "" ist abcadeafga, werden alle bcdefgals darin enthalten betrachtet, und alle 4 aSekunden werden weiterhin angezeigt, bis die Zeichenfolge "" gangezeigt wurde.

Weitere Formatierungsanforderungen

Alle Ausgabezeilen sollten gleich lang sein (die Länge der Eingabezeilen) und bei Bedarf mit Leerzeichen aufgefüllt werden. Die Eingabeprogrammzeile kann Leerzeichen enthalten, diese Leerzeichen erhalten jedoch auch einen Prioritätsbuchstaben. Nachgestellte Zeilenumbrüche bei der Ausgabe / Eingabe sind optional.

Wertung

Das ist Codegolf, die wenigsten Bytes gewinnen.

Beispiele

Hier ist ein kommentiertes Beispiel für einen Code mit komplexerer Formatierung.

1_'[3:~2@+]`
abbcddeffgch

1            #highest priority is denoted by the lowercase letter a
 _'          #priority b
   [      ]  #all characters with priority c
   [3:    ]  #priority d, but priority c still printed because it encloses more
   [  ~   ]  #priority e
   [   2@ ]  #priority f
   [     +]  #priority g, last line of c because all enclosed characters have appeared
           ` #priority h

Ein Beispiel in Perl:

$_=<>;s/[^aeiou\W]/$&o$&/gi;print
aaaaaabbccccccccccbdddddbbbbeeeee

$_=<>;                           
      s/          /     /gi;     
      s/[^aeiou\W]/     /gi;     
      s/          /$&o$&/gi;     
                            print

Hier einige Beispiele in CJam mit freundlicher Genehmigung von Martin Büttner:

l~2*{_2%{3*)}{2/}?_p_(}g;
aabbcdddefffeeggeehhiiccj

l~                       
  2*                     
    {                 }g 
    {_2%              }g 
    {   {   }{  }?    }g 
    {   {3*)}{  }?    }g 
    {   {   }{2/}?    }g 
    {             _p  }g 
    {               _(}g 
                        ;

q{_eu'[,66>"EIOU"-#)g{'o1$}*}/
abcccddddddeeeeeeefgghiijjhhbb

q                             
 {                          }/
 {_eu                       }/
 {   '[,66>                 }/
 {         "EIOU"-          }/
 {                #         }/
 {                 )g       }/
 {                   {    }*}/
 {                   {'o  }*}/
 {                   {  1$}*}/

Hier ist ein verrücktes Beispiel, um sich mit dir herumzuschlagen:

1_'[3:~2@+]`
azTABACBDCAT

   [ :    ] 
   [3: 2  ] 
   [3:~2 +] 
   [ :~ @+] 
  '        `
1           
 _          

Hier ist ein expliziteres Beispiel dafür, was passiert, wenn sich Klammern überlappen abab. (Normalerweise ist dies nicht die Art und Weise, wie Sie Ihre Erklärung formatieren würden.)

aabbccddaaeebb
aabbccddaaeebb

aa      aa    
aabb    aa  bb
aabbcc  aa  bb
aabb  ddaa  bb
  bb      eebb #"aa" no longer appears because all of "bbccdd" have already appeared.

Pyth, 33 bis 40 Bytes

JwFHS{Js.e?@zk&gHYsm&gdH}d>_>JxJYx_JYJdJ

Probieren Sie es online aus: Pyth Compiler / Executor

Erläuterung:

Mit dem String generiert aabbbbbzccdeeegfffqhjiiikkpnmmllloooohec:

                                          implicit: z = first input line
Jw                                        J = second input line
  FHS{J                                   for H in sorted(set(J)):
        .e                             J    map each k,Y of enumerate(J) to:
        .e?                            J      .... if ... else ...
        .e @zk                        dJ      z[k] if ... else " "
                                              condition: 
        .e @zk gHY                    dJ        H >= Y
        .e @zk&                       dJ        and
        .e @zk     m                 JdJ        map each d of J to:
        .e @zk     m gdH             JdJ          d >= H
        .e @zk     m&                JdJ          and
        .e @zk     m    }d           JdJ          d in ...
        .e @zk     m          xJY    JdJ          index of Y in J
        .e @zk     m        >J       JdJ          substring of J (from index to end)
        .e @zk     m       _         JdJ          reverse substring
        .e @zk     m             x_JYJdJ          index of Y in reversed J
        .e @zk     m      >          JdJ          substring of reversed (from index to end)
        .e @zk    s                   dJ       sum up the booleans (acts as any)
       s                                    sum up the chars and print

Die erste Eingabezeile ist also zdie zweite Eingabezeile J.

Die Schleife durchläuft alle Zeichen von J in sortierter Reihenfolge und ohne Duplikate. Das aktuelle Zeichen wird aufgerufen H.

Dann gilt für jedes Yvon JI drucken Sie die entsprechenden Zeichen von zoder ein Leerzeichen, je nachdem , ob die beiden folgenden Bedingungen erfüllt sind:

• Y <= H (Ein Buchstabe erscheint zuerst in der Zeile H )
• Es gibt ein Zeichen d >= H, das in einem Block erscheint, der mit beginnt und endetY (Klammern) .

Beispiele

Dies zeigt , wie die vierte Zeile der Eingabe abcdaeb, abcdaebgedruckt wird. Die vierte Zeile ist eine gute Darstellung, da die meisten möglichen Fälle vorkommen:

code input:  "abcdaeb"
order input: "abcdaeb"

printing the fourth line, H = "d":

   "a" is printed, because "a" <= "d" and ("d" >= "d" and "d" is in "abcda")
   "b" is printed, because "b" <= "d" and ("d" >= "d" and "d" is in "bcdaeb")
   "c" are not printed, because neither "d" nor "e" (chars >= "d") are not in "c"
   "d" is printed, because "d" <= "d" and ("d" >= "d" and "d" is in "d")
   "a" is printed, because "a" <= "d" and ("d" >= "d" and "d" is in "abcda")
   "e" is not printed, because "e" > "d"
   "b" is printed, because "b" <= "d" and ("d" >= "d" and "d" is in "bcdaeb")

therefore the fourth line is: aabb__ddaa__bb

Und ein weiteres Beispiel, das auf einem Testfall basiert, hat mir @Optimizer gegeben. (was meine 33 Lösung zerstört hat).

code input:  "acab"
order input: "acab"

printing the second line, H = "b":

   "a" is printed, because "a" <= "b" and ("c" >= "b" and "c" is in "aca")
   "c" is not printed, because "c" > "b"
   "a" is printed, because "a" <= "b" and ("c" >= "b" and "c" is in "aca")
   "b" is printed, because "b" <= "b" and ("b" >= "b" and "b" is in "b")

therefore the second line is: a_ab

Alte Version: 58 57 52 Bytes

JwKNFHS{J=K.e?eS>_>JxJHx_JHqYH@KkJs.e?@zknYNdK=KXKHN

Probieren Sie es online aus: Pyth Compiler / Executor

Dadurch wird eine Maske erstellt, die vor und nach dem Drucken jeder Zeile geändert wird. Weitere Informationen finden Sie im Bearbeitungsverlauf.

CJam, 82 Bytes

Ziemlich lange und ich denke, ich kann ein paar Bytes mehr rasieren.

leel:F]z::+F$_&\f{{W=1$=},\;}{]_{0f=_W=),\0=>Lf&Ra#)},F,S*\:+{~;1$L+:L;t}%oNo~}%];

Algorithmus

Der grundlegende Algorithmus lautet wie folgt:

• leel:F]z::+ : Gruppieren Sie den Code, die Formatierung und den Index jedes Zeichens
• F$_&\f{{W=1$=},\;}: Gruppieren Sie die obigen Drillinge mit Hilfe der Formatierungszeichenfolge nach Druckpriorität. Dieser Code stellt auch sicher, dass die Prioritäten sortiert sind.
• ]_{0f=_W=),\0=>Lf&Ra#)},: Ermitteln Sie für jede Prioritätsgruppe von Triplets den begrenzenden Indexbereich und prüfen Sie, ob noch kein Index gedruckt wurde. Wenn ein nicht gedruckter Index vorhanden ist, fügen Sie diese Prioritätsgruppe in die Gruppe "In diesem Schritt zu drucken" ein.
• F,S*\:+{~;1$L+:L;t}%oNo~}%: Wenn Sie in diesem Schritt alle zu druckenden Gruppen erhalten haben, geben Sie den Code in den korrekten Index einer Leerzeichenfolge ein und drucken Sie diese Zeichenfolge aus. Aktualisieren Sie auch das Array mit der Liste der gedruckten Indizes.

Code-Erklärung, die ich befolgen muss, wenn ich damit fertig bin.

Beispiel

Hier ist der Code, der auf dem Code selbst ausgeführt wird:

Eingang:

leel:F]z::+F$_&\f{{W=1$=},\;}{]_{0f=_W=),\0=>Lf&Ra#)},F,S*\:+{~;1$L+:L;t}%oNo~}%];
aaabbbcccccdddddeefgghhiffggejkklmmmnoooopppqrrrssssllttttuuuvwwxxxxxxxyvvzzzzjjjj

Ausgabe:

lee                                                                               
   l:F                                                                            
      ]z::+                                                                       
           F$_&\                                                                  
                f{          }                                                     
                f{{     },  }                                                     
                f{{W=   },\;}                                                     
                f{{W=1$ },\;}                                                     
                f{{W=  =},\;}                                                     
                             {                                                }%];
                             {]_                                              }%];
                             {  {                   },                        }%];
                             {  {0f=                },                        }%];
                             {  {   _               },                        }%];
                             {  {    W=),           },                        }%];
                             {  {        \0=        },                        }%];
                             {  {           >       },                        }%];
                             {  {            Lf&    },                        }%];
                             {  {               Ra#)},                        }%];
                             {                        F,S*                    }%];
                             {                            \:+                 }%];
                             {                               {          }%    }%];
                             {                               {~;        }%    }%];
                             {                               {  1$L+:L; }%    }%];
                             {                               {         t}%    }%];
                             {                                            oNo~}%];

Probieren Sie es hier online aus

CJam, 48 Bytes

ll:i:T.{___T#TW%@#~T<>+:e>)1$-@*123Se]m>}z_|(;N*

Erläuterung

l                                                Code.
 l                                               Priority.
  :i                                             Convert priority to integer.
    :T                                           Save to T.
      .{                                }        For corresponding items:
      .{___                             }        Copy the current priority 3 times.
      .{   T#                           }        First position with this priority.
      .{     TW%                        }        Reverse T.
      .{        @#                      }        First (last) position with this priority.
      .{          ~T<                   }        Cut T at the end of this priority.
      .{             >                  }        Cut at the beginning of this priority.
      .{              +                 }        Insert the current priority to
                                                 prevent the array being empty.
      .{               :e>              }        Array maximum.
      .{                  )1$-          }        Count of integers between the current
                                                 priority and the maximum, inclusive.
      .{                      @*        }        That number of the current character.
      .{                        123Se]  }        Fill irrelevant priorities with spaces.
      .{                              m>}        Rotate the array to make non-spaces
                                                 starting at the current priority.
                                                 Returns a column containing 123 items.
                                         z       Zip to get the rows from columns.
                                          _|     Remove duplicate rows, including
                                                 unused priorities and all-space rows.
                                            (;   Remove the first row (an all-space row).
                                              N* Insert newlines.

IDL 8,4, 316 318 304 Bytes

Neue Version, immer noch zu lang, aber kürzer! Und im wahren Sinne von IDL vollständig vektorisiert, was bedeutet (da es keine for-Schleife gibt), dass ich es jetzt als eine Zeile ausführen und auf sich selbst ausführen kann, sobald ich meine Version vollständig auf 8.4 aktualisiert habe. Das wird später bearbeitet.

Einzeilige Version:

c=(f='')&read,c,f&l=[0:strlen(f)-1]&c=strmid(c,l,1)&s=strmid(f,l,1)&u=s.uniq()&k=value_locate(u,s)&n=[0:max(k)]&d=hash(n,u.map(lambda(x,y,z:max(z[(r=stregex(y,'('+x+'(.*))?'+x,len=w)):r+w-1])),f,k))&print,n.map(lambda(n,l,c,d,i:i.reduce(lambda(x,i,l,c,d,n:x+(d[l[i]]ge n?c[i]:' ')),l,c,d,n)),k,c,d,l)&end

Mit Zeilenumbrüchen (gleiche Anzahl von Bytes, Subbing \ n vs &) und Kommentaren:

c=(f='') ;initialize code and format as strings
read,c,f ;read two lines of input from the prompt
l=[0:strlen(f)-1] ;index array for the strings
c=strmid(c,l,1) ;split the code string into an array, via substrings of length 1
s=strmid(f,l,1) ;same for the format string, saving f for regex later
u=s.uniq() ;get the sorted unique values in the format string (sorts A->a)
k=value_locate(u,s) ;assign layer values to the format characters
n=[0:max(k)] ;index array for the unique format characters
d=hash(n,u.map(lambda(x,y,z:max(z[(r=stregex(y,'('+x+'(.*))?'+x,len=w)):r+w-1])),f,k))
print,n.map(lambda(n,l,c,d,i:i.reduce(lambda(x,i,l,c,d,n:x+(d[l[i]]ge n?c[i]:' ')),l,c,d,n)),k,c,d,l)
end ;end the script

Hier ist eine algorithmische Aufschlüsselung für Zeile 9:

r=stregex(y,'('+x+'(.*))?'+x,len=w) ; r, w = starting position & length of substring in y {format string} bracketed by x {character} (inclusive)
z[(r=...):r+w-1] ; grab a slice of z {layer array} from r to r+w-1 -> layer values for each character in the substring
max(z[...]) ; max layer (depth) of any characters in that slice
u.map(lambda(x,y,z:max(...)),f,k) ;map an inline function of the above to every element of the unique-formatting-character array
d=hash(n,u.map(...)) ; create a hash using the unique indices, the result is a hash of (character:max_substring_depth)

... und 10:

x+(d[l[i]]ge n?c[i]:' ')) ; ternary concatenation: if maxdepth for this character >= current depth, add the character, otherwise add ' '
i.reduce(lambda(x,i,c,d,l,n:...)),,l,c,d,n) ;accumulate elements of i {code/format index array} by passing them through the inline ternary concatenation function
print,n.map(lambda(n,l,c,d,i:i.reduce(...)),k,c,d,l) ;map the depth index through the reduction, ending up with a string for each depth layer, then print it

Die Zeilen 9 und 10 erledigen die eigentliche Arbeit, der Rest legt die Variablen fest, die Sie für das Ende benötigen. Ich denke, das ist ungefähr so ​​gut wie es nur geht. Ich kann nirgendwo anders etwas finden, um es besser zu machen.

Alte Version (hier ist alles veraltet):

Dies ist bei weitem nicht kurz genug, um zu gewinnen, denn dies ist eine schreckliche Golfsprache, aber niemand antwortet jemals in IDL, also werde ich es einfach versuchen.

a=(b='')
read,a,b
c=[0:strlen(b)-1]
d=strmid(b,c,1)
a=strmid(a,c,1)
e=d[uniq(d,sort(d))]
f=list(value_locate(e,d),/e)
s=hash()
for i=0,max(f)do begin
g=stregex(b,'('+e[i]+'(.*))?'+e[i],l=l)
s[i]=max(f[g:g+l-1])
print,f.reduce(lambda(x,y,z:x+(s.haskey(y)?z[y]:' '),s,a)
s=s.filter(lambda(x,y:x[1]gt y),i)
endfor
end

Ich bin mir nicht sicher, ob es eine Möglichkeit gibt, es weiter zu reduzieren ... Ich könnte strmid gleichzeitig für a und b aufrufen, aber dann gebe ich mehr Bytes für die Indizierung von d aus und es funktioniert genauso. Ich werde aber weiter daran arbeiten! (Und morgen bearbeite ich in einer Erklärung den Algorithmus.)