Viele Leute auf dieser Website verwenden esoterische Sprachen . Da diese Sprachen ungewöhnlich und schwer zu verstehen sind, werden sie häufig Erklärungen in einem bestimmten Format verfassen. Zum Beispiel, wenn der Code war

abcdefghijklmnop

Und diese Sprache verwendet #für Kommentare eine Erklärung wie diese:

a                #Explanation of what 'a' does
 bc              #Bc
   d             #d
    e            #Explanation of e
     fgh         #foobar
        ij       #hello world
          k      #etc.
           l     #so on
            mn   #and
              op #so forth

Ich mache das auch oft, aber jedes Mal, wenn ich das mache, habe ich das Gefühl, dass das Erstellen des Layouts von Text wirklich unangenehm und zeitaufwendig ist. Ich möchte, dass Sie einen "Esolang-Comment-Template-Generator" für mich erstellen. Wenn wir zum Beispiel die Kommentare ignorieren, hat der vorherige Code diese Vorlage:

a                #
 bc              #
   d             #
    e            #
     fgh         #
        ij       #
          k      #
           l     #
            mn   #
              op #

Die Herausforderung:

Sie müssen ein Programm oder eine Funktion schreiben, die zwei Zeichenfolgen als Eingabe verwendet und diese "Esolang-Kommentar-Vorlage" ausgibt. Die erste Eingabe ist der Code, jedoch mit |eingefügten Strichen ( ) an der Stelle, an der sich die Zeilenumbrüche befinden. Die zweite Eingabe wird für Kommentare verwendet. Unser letztes Beispiel hätte also Folgendes für die Eingabe:

"a|bc|d|e|fgh|ij|k|l|mn|op", "#"

Dies schließt leider aus, dass Balken Teil der Codeeingabe sind, aber das ist in Ordnung. Sie können davon ausgehen, dass die Kommentareingabe ein einzelnes Zeichen ist. Der Einfachheit halber wird das Kommentarzeichen kein Balken sein. Die Codeeingabe enthält nur druckbares ASCII und keine Zeilenumbrüche.

Hoffentlich können Sie den Testfällen entnehmen, was zu tun ist, aber ich werde versuchen, einige Dinge zu klären.

Sie müssen die Codeeingabe auf jeder Leiste in "Code-Abschnitte" aufteilen. Dann wird jeder Codeabschnitt in einer eigenen Zeile ausgegeben und mit der Länge des gesamten vorherigen Codes (ohne die Striche) links aufgefüllt. Dann wird jede Zeile mit genügend Leerzeichen rechts aufgefüllt, so dass die letzten beiden Zeichen in jeder Zeile "Ein zusätzliches Leerzeichen" + "Das Kommentarzeichen" sind.

Eine nachgestellte Zeile ist zulässig.

Hier ist ein weiteres Beispiel. Für die Eingabe

"Hello|World", "/"

Der erste Abschnitt des Codes ist „Hallo“ und die zweite ist „Welt“. So sollte es die Ausgabe geben:

Hello      /
     World /

Hier sind noch einige Beispiele:

Input:
"a|b|c|d|e|f|g", ","

Output:
a       ,
 b      ,
  c     ,
   d    ,
    e   ,
     f  ,
      g ,

Input:
"abcdefg", ":"

Output:
abcdefg :

Input:
"4|8|15|16|23|42", "%"

Output:
4          %
 8         %
  15       %
    16     %
      23   %
        42 %

Input:
"E|ac|h s|ecti|on is| one c|haracte|r longer| than the| last!", "!"

Output:
E                                                   !
 ac                                                 !
   h s                                              !
      ecti                                          !
          on is                                     !
                one c                               !
                     haracte                        !
                            r longer                !
                                     than the       !
                                              last! !

Input:
"This|Code|has||empty||sections", "@"

Output:
This                     @
    Code                 @
        has              @
                         @
           empty         @
                         @
                sections @

Regeln:

Sie können diese Ein- und Ausgaben in jedem vernünftigen Format verwenden. Zum Beispiel das Lesen / Schreiben einer Datei, STDIN / Stout, Funktionsargumente / Rückgabewert usw. Wie üblich, ist dies Code-Golf , so versuchen , Ihren Code so kurz wie möglich zu machen , und Sie gewinnen , wenn Sie die kürzeste Lösung bekommen in deiner Sprache! Ich werde auch die kürzeste Lösung als Gesamtsieger auswählen. Standardlücken sind verboten.

Pyth - 28 27 24 23 Bytes

Könnte ein bisschen Golf spielen können. Anscheinend viel weg!

jt+R+;zC.t.u+*lNdYcQ\|k

Probieren Sie es hier online aus .

Retina , 35 34 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

\|
·$'¶$`±
T0-2`·±|p`___ `.+±.|·.+

Die beiden Eingabezeichenfolgen werden durch ein Leerzeichen getrennt (was eindeutig ist, da wir wissen, dass der Kommentarbegrenzer immer ein einzelnes Zeichen ist).

Probieren Sie es online!

Java 10, 189 159 Bytes

s->c->{var r="";int p=0,i;for(var a:s.split("\\|")){for(i=p;i-->0;r+=" ");r+=a;for(p+=a.length();i++<s.replace("|","").length()-p;r+=" ");r+=c+"\n";}return r;}

-30 Bytes, die Java 7 in Java 10 konvertieren und die Schleifen optimieren.

Probieren Sie es online aus.

Erläuterung:

s->c->{                     // Method with String & char parameters and String return-type
  var r="";                 //  Result-String, starting empty
  int p=0,                  //  Position-integer, starting at 0
      i;                    //  Index integer
  for(var a:s.split("\\|")){//  Loop over the parts split by "|"
    for(i=p;i-->0;r+=" ");  //   Add `p` amount of spaces to the result-String
    r+=a;                   //   Add the current part to the result-String
    for(p+=a.length();      //   Add the length of the current part to the position-integer
        i++<s.replace("|","").length()-p;r+=" ");
                            //   Add the row's trailing spaces to the result-String
    r+=c+"\n";}             //   Add the character and a new-line to the result-String
  return r;}                //  Return the result-String

Pyke, 31 28 24 Bytes

\|cDslF2l-hd*Q+Zi:il?+ZK

Probieren Sie es hier aus!

JavaScript (ES6), 92 Byte

f=
(s,c)=>s.split`|`.map((_,i,a)=>a.map((e,j)=>i-j?e.replace(/./g,` `):e).join``+` `+c).join`
`
;

<div oninput=o.textContent=f(s.value,c.value)><input id=s placeholder=Code><input id=c size=1 maxlength=1 value=#><pre id=o>

GNU sed (85 + 1 für -r) 86

:s;h;:;s,\|( *)[^ \|](.),|\1 \2,;t;s,\|,,g
p;g;:l;s,^( *)[^ \|],\1 ,;tl;s,\|,,;/\S/bs

Die Eingaben sind durch ein Leerzeichen getrennte Zeichenfolgen.

Tests:
input.txt:

a|b|c|d|e|f|g ,
abcdefg :
4|8|15|16|23|42 %
E|ac|h s|ecti|on is| one c|haracte|r longer| than the| last! !
This|Code|has||empty||sections @

Ausgabe:

$ cat input.txt | sed -rf template
a       ,
 b      ,
  c     ,
   d    ,
    e   ,
     f  ,
      g ,

abcdefg :

4          %
 8         %
  15       %
    16     %
      23   %
        42 %

E                                                   !
 ac                                                 !
   h s                                              !
      ecti                                          !
          on is                                     !
                one c                               !
                     haracte                        !
                            r longer                !
                                     than the       !
                                              last! !

This                     @
    Code                 @
        has              @
                         @
           empty         @
                         @
                sections @

Haskell, 139.135 Bytes

s#p=j$foldl g("",0)s where g(a,n)c|c=='|'=(j(a,n)++"\n"++q n,n)|1>0=(a++[c],n+1);q m=' '<$[1..m];j(a,n)=a++q(sum[1|c<-s,c/='|']-n+1)++p

4 Bytes durch Inlining einer Definition gespart.

Ungolfed:

template :: String -> String -> String
template code comment = format $ foldl g ("", 0) code
    where g (acc, n) c
            | c == '|' = (format (acc, n) ++ "\n" ++ spaces n, n)
            | otherwise = (acc ++ [c], n+1)
          l = length $ filter (/= '|') code
          spaces n = replicate n ' '
          format (acc, n) = acc ++ spaces (l-n+1) ++ comment

Groovy, 120 113 111 Bytes

def m(s,c){s.split(/\|/).inject(0,{e,t->println((' '*e+t).padRight(s.replace('|','').size()+1)+c);e+t.size()})}

ungolfed *

def m(s,c){
  s.split(/\|/).inject(0, { e, t ->
    println((' '*e+t).padRight(s.replace('|','').size())+' '+c)
    e+t.size()
  })
}

(Erster Entwurf mit 120 Bytes)

def m(s,c){def l=0;s.split(/\|/).collect{l+=it.size();it.padLeft(l).padRight(s.replace('|','').size())+' '+c}.join('\n')}

ungolfed *

def m(s,c){
  def l=0 // minimized version needs a semicolon here
  s.split(/\|/).collect{
    l+=it.size() // minimized version needs a semicolon here
    it.padLeft(l).padRight(s.replace('|','').size())+' '+c
  }.join('\n')
}

Tests

%> m('a|bc|d|e|fgh|ij|k|l|mn|op', '#')
a                #
 bc              #
   d             #
    e            #
     fgh         #
        ij       #
          k      #
           l     #
            mn   #
              op #

%> m('Hello|World', '/')
Hello      /
     World /

%> m('a|b|c|d|e|f|g', ',')
a       ,
 b      ,
  c     ,
   d    ,
    e   ,
     f  ,
      g ,

%> m('abcdefg', ':')
abcdefg :

%> m('4|8|15|16|23|42', '%')
4          %
 8         %
  15       %
    16     %
      23   %
        42 %

%> m('E|ac|h s|ecti|on is| one c|haracte|r longer| than the| last!', '!')
E                                                   !
 ac                                                 !
   h s                                              !
      ecti                                          !
          on is                                     !
                one c                               !
                     haracte                        !
                            r longer                !
                                     than the       !
                                              last! !

%> m('This|Code|has||empty||sections', '@')
This                     @
    Code                 @
        has              @
                         @
           empty         @
                         @
                sections @

Python 2, 125 124 132 Bytes

-1 Byte dank @TuukkaX (vermisste den Raum von Golf i, v)

def g(s,c):x=s.split('|');print((' '+c+'\n').join(' '*len(''.join(x[:i]))+v+' '*len(''.join(x[i+1:]))for i,v in enumerate(x))+' '+c)

Alle Testfälle auf ideone

Python 2, 107 105 102 99 Bytes

Getestet mit allen obigen Testfällen

EDIT golfed aus 2 Bytes , die durch d Ändern = a.split ( "|"); i = 0 bis d, i = a.split ( "|"), 0 nicht sicher , wie ich das verpasst. Danke @Oliver Ni

Weitere 3 Bytes sind weg. Danke noch einmal.

Vorschlag von @Jonathan spart tatsächlich 3 Bytes und bringt es auf die magische 99. Vielen Dank.

def c(a,b):
 d,i=a.split("|"),0
 for e in d:j=i+len(e);print" "*i+e+" "*(len("".join(d))-j+1)+b;i=j

05AB1E , 29 38 31 29 Bytes

'|„ǝʒ:'ǝ¡'ʒмεD®>úsg®+©s}.Bεð²J,

Kann definitiv golfen werden, aber zumindest funktioniert es jetzt ..
+9 Bytes, da ¡(geteilt) leere Elemente automatisch entfernt, also musste ich '|„ǝʒ:'ǝ¡'ʒм..
-2 Bytes dank @MagicOctopusUrn hinzufügen, indem ich'|„ǝʒ:'ǝ¡'ʒм auf '|¶:.BεðÜ}(die aktuelle Lösung funktioniert nicht) Elemente mit nachgestellten Leerzeichen, aber ich habe angenommen, dass dies gemäß den Testfällen zulässig ist).

Probieren Sie es online aus.

Erläuterung:

'|¶:           # Take the first input, and replace every "|" with "¶"
               #  i.e. "abc|d|e||fg" → "abc¶d¶e¶¶fg" (¶ are new-lines in 05AB1E)
    .B         # Box all the items (appending trailing whitespace to make it a rectangle)
               #  i.e. "abc¶d¶e¶¶fg" → ['abc','d  ','e  ','   ','fg ']
      εðÜ}     # Remove all trailing spaces from each item
               #  i.e. ['abc','d  ','e  ','   ','fg '] → ['abc','d,'e','','fg']
               #  NOTE: `'|¡` would have resulted in ['abc','d','e','fd'], hence the use of
               #        Box which implicitly splits on new-lines to keep empty items
ε              # For-each:
 D             #  Duplicate the current item
  ®>ú          #  Prepend global_variable + 1 amount of spaces
               #  (+1 because the global_variable is -1 by default)
               #   i.e. "e" and 3+1 → "    e"
 sg            #  Swap so the duplicated item is at the top, and take its length
   ®+          #  Sum it with the global_variable
               #   i.e. "e" (→ 1) and 4 → 5
     ©         #  And store it as new global_variable
      s        #  Then swap so the space appended item is at the end again
       }       # And end the for-each loop
.B             # Box all the items (appending the appropriate amount of spaces)
               #  i.e. ['abc','   d','    e','     ','     fg']
               #   → ['abc    ','   d   ','    e  ','       ','     fg']
ε              # For-each again:
 ð             #  A space character
  I            #  The second input-character
   J           #  Join both together with the current item
    ,          #  And print the current row with trailing new-line

PowerShell v2 +, 103 bis 99 Byte

param($a,$b)$a-split'\|'|%{" "*$l+$_+" "*(($a-replace'\|').length+1-$_.length-$l)+$b;$l+=$_.Length}

Nimmt Eingaben als zwei Zeichenfolgen, -splits die erste in der Literal-Pipe (da bei der Aufteilung die Regex-Syntax verwendet wird), und fügt die Elemente in eine Schleife ein |%{...}.

Bei jeder Iteration erstellen wir eine Zeichenfolge als eine Anzahl von Leerzeichen, die durch $lVerketten mit dem aktuellen Element definiert werden. $lInitialisiert für die erste Schleife auf $null, die hier als ausgewertet wird 0.

Diese Zeichenfolge wird weiter mit einer anderen Anzahl von Leerzeichen verkettet (definiert durch die Länge, $ain der -replacejede Pipe ohne Leerzeichen ausgeführt wird , zuzüglich 1des zusätzlichen Auffüllens zwischen Code und Kommentaren abzüglich .lengthdes aktuellen Elements, abzüglich $lder Anzahl der von uns aufgefüllten Leerzeichen) Links auf dieser Iteration), verkettet mit unserem Kommentarzeichen $b. Das ist noch in der Pipeline.

Wir aktualisieren dann $lfür die nächste Iteration.

Die resultierenden Zeichenfolgen Write-Outputverbleiben alle in der Pipeline und werden implizit bei der Programmausführung ausgegeben , wobei standardmäßig eine neue Zeile dazwischen steht.

Beispiele

PS C:\Tools\Scripts\golfing> .\esolang-comment-template-generator.ps1 "This|Code|has||empty||sections" "@"
This                     @
    Code                 @
        has              @
                         @
           empty         @
                         @
                sections @

PS C:\Tools\Scripts\golfing> .\esolang-comment-template-generator.ps1 "a|bc|def|ghi|h" "|"
a          |
 bc        |
   def     |
      ghi  |
         h |

Vim, 39 38 Tastenanschläge

-1 Byte dank DJMcMayhem

Erwartet als Eingabe einen Puffer (z. B. eine Datei), dessen erstes Zeichen der Kommentarbegrenzer ist, gefolgt vom Code, z #foo|bar|baz.

"cxqaf|m`Yp<Ctrl+o>v$r jv0r x@aq@a$p<Ctrl+v>gg$C <Ctrl+r>c<Esc>

Erläuterung

(" _" bezeichnet ein wörtliches Leerzeichen.)

"cx          " Delete the first character (the comment delimiter) and store in register 'c'
qa           " Start recording macro 'a'
f|m`         " Advance to the first '|' on the line and set mark
Yp<Ctrl+o>   " Duplicate this line and return to mark
v$r_         " Replace everything after the cursor on this line (inclusive) with spaces
jv0r_x       " Go down a line and replace everything before the cursor on this line (inclusive) with
             "   spaces, then delete one space
@a           " Call macro recursively
q@a          " Stop recording and immediately call the macro
$p           " Paste the deleted space at the end of the last line
<Ctrl+v>gg$       " Highlight the column where the comment delimiters will go and all trailing spaces
C_<Ctrl+r>c<Esc>  " Replace the highlighted text on each line with a space and the contents of
                  "   register 'c' (the comment delimiter)

Floroid - 94 Bytes

Ah(a,b):c=a.fn("|");z(" "+b+"\n".y(' '*Z("".y(c[:j]))+l+" "*Z("".y(c[j+1:]))Kj,lIai(c))+' '+b)

Verwendet einen ähnlichen Ansatz wie die Python-Lösung von @ JonathanAllan .

Testfälle

Call: h("a|bc|d|e|fgh|ij|k|l|mn|op", "#")
Output: 
a                #
 bc              #
   d             #
    e            #
     fgh         #
        ij       #
          k      #
           l     #
            mn   #
              op #

C # 176 167 154 Bytes

string f(string s,char x){var c=s.Split('|');var d="";int i=0;foreach(var b in c)d+=b.PadLeft(i+=b.Length).PadRight(s.Length+2-c.Length)+x+"\n";return d;}

Ungolfed

string f(string s, char x)
{
    var c = s.Split('|');
    var d = "";
    int i = 0;
    foreach (var b in c)
        d += b.PadLeft(i += b.Length).PadRight(s.Length + 2 - c.Length) + x + "\n";
    return d;
}

Eine LINQ-Lösung wäre 146 gewesen, aber notwendig using System.Linq; auf 164 zurückgesetzt werden:

string f(string s,char x){var c=s.Split('|');int i=0;return c.Aggregate("",(g,b)=>g+b.PadLeft(i+=b.Length).PadRight(s.Length+2-c.Length)+x+"\n");}

Alte Lösungen:

167 Bytes:

string f(string s,char x){var c=s.Split('|');var d="";int i=0;foreach(var b in c){d+=b.PadLeft(i+b.Length).PadRight(s.Length+2-c.Length)+x+"\n";i+=b.Length;}return d;}

176 Bytes mit String-Interpolation

string f(string s,char x){var c=s.Split('|');var d="";int i=0;foreach(var b in c){d+=string.Format($"{{1,{i}}}{{0,-{s.Length+2-c.Length-i}}}{x}\n",b,"");i+=b.Length;}return d;}

PHP, 120 117 116 110 109 Bytes

foreach($a=split('\|',$argv[1])as$i=>$t){$c=preg_replace('#.#',' ',$a);$c[$i]=$t;echo join($c)," $argv[2]
";}

oder

foreach($a=split('\|',$argv[1])as$t){$c=preg_replace('#.#',' ',$a);$c[$i++|0]=$t;echo join($c)," $argv[2]
";}

MATL , 33 31 Bytes

'\|'0'|'hYXo8M&YbY:&YdtaZ)0ihYc

Probieren Sie es online!

Erläuterung

Die eingebaute Funktion Yd( blkdiag), die aus ihren Eingaben eine Blockdiagonalmatrix erstellt, erledigt den größten Teil der Arbeit. Die Füllwerte in der Matrix sind 0, und char 0 wird zu Anzeigezwecken als Leerzeichen behandelt. Der Code würde sich einfach aufteilen| , eine Matrix aus den resultierenden Blöcken erstellt, in char konvertiert und zwei Spalten mit Leerzeichen und Kommentarsymbol angehängt.

Die Möglichkeit von leeren Abschnitten in der Eingabezeichenfolge ist jedoch kompliziert macht das Problem noch interessanter: der resultierende Block leer sein würde und somit nicht in der resultierenden Matrix zeigen würde.

Um dies zu lösen, fügen wir vor jedem Zeichen ein Zeichen 0 ein |, damit kein Block leer ist. und dann entfernen wir in der resultierenden char-Matrix Spalten, die nur durch char 0 gebildet werden. Ein nicht leerer Codeabschnitt enthält druckbare ASCII-Zeichen, sodass die darin enthaltenen Spalten erhalten bleiben. Ein leerer Abschnitt trägt eine Zeile bei, führt jedoch keine zusätzliche Spalte ein.

'\|'    % Push this string: source for regexp matching. It's just | escaped
0'|'h   % Push a string formed by char 0 followed by | (no escaping needed)
YX      % Input string implicitly. Replace first of the above string by the second
o       % Convert from chars to code points. Gives a numeric vector
8M      % Push '|' again
&Yb     % Split numeric vector at occurences of | (the latter is automatically
        % converted  to its code point). This gives a cell array of numeric vectors
Y:      % Unbox cell array: pushes the numeric vectors it contains
&Yd     % Form a block-diagonal matrix from those vectors
ta      % Duplicate. Compute vector that equals true for columns that have some
        % nonzero value
Z)      % Used that as a logical index (mask) for the columns of the matrix.
        % This removes columns that contain only zeros
0ih     % Input comment symbol and prepend char 0 (which will be displayed as space)
Yc      % Append that to each row of the matrix. The matrix is automatically 
        % converted from code points to chars
        % Display implicitly

Pyth, 30 Bytes

VJcE\|s[*ZdN*h--lsJZlNdQ)=+ZlN

oder

jm+dQ.t.t+MC,.u*l+NYdJc+Ed\|kJ

Beide sind vollständige Programme, die die STDIN-Eingabe der Kommentarzeichenfolge und anschließend der durch Zeilenumbrüche getrennten Programmzeichenfolge übernehmen.

Probieren Sie die erste Version online aus

Probieren Sie die zweite Version online aus

Wie sie arbeiten

VJcE\|s[*ZdN*h--lsJZlNdQ)=+ZlN  Program. Inputs: E, Q
  cE\|                          Split E on "|"
 J                              Assign to J
                                Implicit Z=0
V                               For N in that:
       [                )        Create a list with elements:
        *Zd                       Z spaces
           N                      N
               -lsJZ              len(concatenate(J))-Z
              -     lN             -len(N)
             h                     +1
            *         d            spaces
                       Q          Q
      s                          Concatenate the list
                                 Implicitly print
                        =+ZlN    Z=Z+len(N)

jm+dQ.t.t+MC,.u*l+NYdJc+Ed\|kJ  Program. Inputs: E, Q
                       +Ed      Add a trailing space to E
                      c   \|    Split that on "|"
                     J          Assign to J
             .u                 Cumulatively reduce J with:
                            k    starting value empty string and
                                 function N, Y ->
                l+NY              len(N+Y)
               *    d             spaces
            ,                J  Two-element list of that and J
           C                    Transpose
         +M                     Map concatenation over that
       .t                       Transpose, padding with spaces
     .t                         Transpose again
 m+dQ                           Map concatenation with Q over that
j                               Join on newlines
                                Implicitly print

Dyalog APL 16.0 (nicht konkurrierend), 43 37 Bytes

Fordert zur Eingabe eines Kommentarzeichens und anschließend zur Eingabe von Code auf.

↑(↓↑((-(⍸'|'∘=),≢)↑¨'|'∘≠⊆⊢)⍞),¨⊂¯2↑⍞

Nicht konkurrierend, da Version 16.0 neuer ist als diese Herausforderung.

Perl, 63 Bytes

Beinhaltet +5 für -Xpi

Mit Eingabe von STDIN und Kommentarzeichen nach -i ausführen:

perl -Xpi% esolang.pl <<< "Ab|Cd||ef"

esolang.pl:

s/
/|/;s%(.*?)\|%$"x$`=~y/|//c.$1.$"x$'=~y/|//c." $^I
"%eg

Absolut langweilige, unkomplizierte Lösung

Turtlèd , 35 Bytes (nicht konkurrierend )

Nimmt eine Eingabe vor, das letzte Zeichen ist das Kommentarzeichen. Funktioniert nicht mit Kommentarzeichen als Leerzeichen, aber ich nehme an, dass das nicht notwendig ist.

!' [*.+(|' dl)r_]' r[*+.(|u)_][ .d]

Erläuterung:

!                                  take input into string variable
 '                                 write space over current cell
   [*           ]                  while cell is not *
     .+                            write pointed char of string, stringpointer+1 (starts 0)
       (|    )                     if current cell is |
         ' dl                      write space (over |), move down, left
              r_                   move right, write * if pointed char is
                                   last char, else space

                 ' r               write space, move right
                    [*       ]     while cell is not *
                      +.           increment pointer and write pointed char
                        (|u)       if cell is |, move up
                            _      write * if the pointed char is the last char

                              [   ] while cell is not space
                                .d  write the pointed char from string, move down 

Funky , 89 Bytes

s=>c=>{y=0forn inl=s::split"|"print((v=" "::rep)(y)+l[n]+v((#l::reduce@++1)-y+=#l[n])+c)}

Probieren Sie es online!

Scala, 123 Bytes

def?(i:String,c:String)={var b=0
i.split('|').map{s=>println(" "*b+s+" "*(i.replace("|","").size-b-s.size+1)+c)
b+=s.size}}

Testcode + Ausgabe:

?("a|b|c|d|e|f|g", ",")
a       ,
 b      ,
  c     ,
   d    ,
    e   ,
     f  ,
      g ,

?("abcdefg", ":")
abcdefg :

?("4|8|15|16|23|42", "%")
4          %
 8         %
  15       %
    16     %
      23   %
        42 %

?("E|ac|h s|ecti|on is| one c|haracte|r longer| than the| last!", "!")
E                                                   !
 ac                                                 !
   h s                                              !
      ecti                                          !
          on is                                     !
                one c                               !
                     haracte                        !
                            r longer                !
                                     than the       !
                                              last! !

?("This|Code|has||empty||sections", "@")
This                     @
    Code                 @
        has              @
                         @
           empty         @
                         @
                sections @

Ruby, 96 80 Bytes

->s,c{s.gsub(/(^|\|)([^|]*)/){" "*$`.count(t="^|")+$2+" "*(1+$'.count(t))+c+$/}}

Sehen Sie es auf eval.in: https://eval.in/639012

Ich sollte wirklich nur Retina lernen.

Jelly , 41 Bytes

Das sieht so aus, als hätte es viel zu viele Inkremente und wahrscheinlich zu viele Links ...

ṫø⁹‘‘µFL‘⁶ẋ
‘ị
ḣFL⁶ẋ$;ç@;1ŀ
J’ç@€
ṣ”|Ç;€Y

Testen Sie es bei TryItOnline

Wie?

ṫø⁹‘‘µFL‘⁶ẋ  - link 1: get the spaces for after the code, dyadic(split string, index)
 ø           - next chain as a nilad
  ⁹‘‘        - right argument incremented twice (the index we actually want)
ṫ            - tail (get the rest of the split string)
     µ       - next chain as a monad
      FL‘    - flatten, get its length and increment
         ⁶   - a space character " "
          ẋ  - repeat the space character that many times

‘ị           - Link 2: get the code for a line dyadic(index, split string)
‘            - increment the index
 ị           - retrieve the string at that index

ḣFL⁶ẋ$;ç@;1ŀ - Link 3: get the code and join with spaces, dyadic (index, split string)
ḣ            - head: split string[index:]
 FL          - flatten and get its length
     $       - previous two atoms as a monad
   ⁶         - a space character, " "
    ẋ        - repeat the space that many times
      ;      - concatenate with
       ç@    - the result of the previous link (the code) - reverse inputs
         ;   - concatenate with
          1ŀ - the result of Link 1 (the spaces after the code)

J’ç@€        - Link 3: a for loop, monadic(split string)
J’           - [0,...,Len(split string)-1]
  ç@€        - the result of the previous link, with revered inputs, for each

ṣ”|Ç;€Y      - Main Link: dyadic(code string, comment character)
ṣ”|          - split on "|"
   Ç         - the result of the previous link
    ;€       - concatenate each with the comment character
      Y      - join with line feeds
             - implicit print

CJam, 32 Bytes

l'|/_s,)L@{1$,S*\+}%@f{Se]}lN+f+

Erläuterung

l                                  get code string
 '|/                               split into code parts
    _s,)                           length of all the parts +1
        L@{1$,S*\+}%               left pad spaces to every part for the length of the previous parts
                    @f{Se]}        right pad spaces
                           lN+f+   add comment character and newline

Probieren Sie es online aus

GolfScript, 85 Bytes

{(;);}:r;", "%(r\(r n+:c;;.,\'|'%.,@\-)):l;0:m;{.,0>}{" "m*\(.,m+:m l\-" "\*+c@}while

Probieren Sie es online aus

Update 2017 - GolfScript - 71 Bytes

', '/~~:c;~1/.,\.{'|'=},,@\-):l;['|']/0:i;{.,i+:i l i-' '*c+\' '*"
"\}/

Erläuterung

', '/~~:c;~1/        # Parses input
.,\.{'|'=},,@\-):l;  # Computes string length without '|'
['|']/               # Splits the array
0:i;                 # Counter
{.,                  # Length of the substring
i+:i                 # Counter update
l i-' '*c+\          # Adds spaces after the substring 
' '*"\n"\            # Adds spaces before the next substring
}/                   # ...For each substring

Gelee , 10 Bytes

ṣ”|⁶ṁ;ɗ\pG

Probieren Sie es online!