Molte persone su questo sito usano lingue esoteriche e poiché queste lingue sono insolite e difficili da capire, scriveranno spesso una spiegazione in un determinato formato. Ad esempio, se il codice fosse

abcdefghijklmnop

E questa lingua usa #per i commenti, scriverebbero una spiegazione come questa:

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

Faccio spesso anche questo, ma ogni volta che lo faccio, sento che creare il layout del testo è davvero odioso e richiede molto tempo. Quindi voglio che tu crei un "Generatore di modelli di commenti Esolang" per me. Ad esempio, se ignoriamo i commenti, il codice precedente ha questo modello:

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

La sfida:

È necessario scrivere un programma o una funzione che accetta due stringhe come input e genera questo "Esolang-Comment-Template". Il primo input sarà il codice, ma con le barre ( |) inserite dove vanno le newline. Il secondo input è quello che useremo per i commenti. Quindi il nostro ultimo esempio dovrebbe avere questo per l'input:

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

Purtroppo questo esclude le barre dall'essere parte dell'input del codice, ma va bene. Puoi presumere che l'input del commento sarà un singolo carattere. Per semplicità, il carattere di commento non sarà una barra. L'input del codice conterrà solo ASCII stampabile e non conterrà nuove righe.

Spero che tu possa dedurre cosa fare dai testcase, ma cercherò di chiarire alcune cose.

È necessario dividere il codice inserito in "sezioni di codice" su ogni barra. Quindi, ogni sezione di codice viene emessa su una riga separata e riempita a sinistra con la lunghezza di tutto il codice precedente (escluse le barre). Quindi, ogni riga viene riempita a destra con spazi sufficienti in modo che gli ultimi due caratteri su ogni riga siano "Uno spazio aggiuntivo" + "Il carattere di commento".

È consentita una nuova riga finale.

Ecco un altro esempio. Per l'input

"Hello|World", "/"

La prima sezione del codice è "Hello" e la seconda è "World". Quindi dovrebbe dare l'output:

Hello      /
     World /

Ecco alcuni altri esempi:

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 @

Regole:

Puoi prendere questi ingressi e uscite in qualsiasi formato ragionevole. Ad esempio, leggere / scrivere un file, STDIN / STOUT, argomenti di funzione / valore restituito, ecc. Come sempre, questo è code-golf , quindi cerca di rendere il tuo codice il più corto possibile e vinci se riesci a ottenere la soluzione più breve nella tua lingua! Selezionerò anche la soluzione più breve come vincitore assoluto. Le scappatoie standard sono vietate.

Pyth - 28 27 24 23 byte

Potrebbe essere in grado di giocare a golf un po 'fuori. Molto fuori, a quanto pare!

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

Provalo online qui .

Retina , 35 34 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

Le due stringhe di input sono separate da uno spazio (che è inequivocabile poiché sappiamo che il delimitatore di commento è sempre un singolo carattere).

Provalo online!

Java 10, 189 159 byte

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 byte convertendo Java 7 in Java 10 e ottimizzando i loop.

Provalo online.

Spiegazione:

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 byte

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

Provalo qui!

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 per -r) 86

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

Gli input sono stringhe separate da uno spazio.

Test:
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 @

Produzione:

$ 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 byte

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

Salvato 4 byte incorporando una definizione.

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 byte

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()
  })
}

(Prima bozza con 120 byte)

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

test

%> 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 byte

-1 byte grazie a @TuukkaX (mancato golf nello spazio da 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)

Tutti i casi di test su ideone

Python 2, 107 105 102 99 byte

Testato con tutti i casi di test sopra

MODIFICA Scollegata di 2 byte modificando d = a.split ("|"); i = 0 in d, i = a.split ("|"), 0 Non sono sicuro di come mi sia perso. Grazie @Oliver Ni

Altri 3 byte andati. Grazie ancora.

Il suggerimento di @Jonathan in realtà salva 3 byte e lo porta alla magia 99. Grazie.

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 byte

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

Può sicuramente essere giocato a golf, ma almeno ora funziona ..
+9 byte perché ¡(diviso) rimuove automaticamente gli oggetti vuoti, quindi ho dovuto aggiungere '|„ǝʒ:'ǝ¡'ʒм..
-2 byte grazie a @MagicOctopusUrn cambiando '|„ǝʒ:'ǝ¡'ʒмin '|¶:.BεðÜ}(la soluzione corrente non funziona su elementi con spazi finali, ma ho ipotizzato che sia consentito in base ai casi di test).

Provalo online.

Spiegazione:

'|¶:           # 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 99 byte

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

Prende input come due stringhe, -splitè il primo su pipe letterali (poiché split utilizza la sintassi regex) e inserisce gli elementi in un loop |%{...}.

Ogni iterazione, costruiamo una stringa come un numero di spazi definiti da $lconcatenati con l'elemento corrente. Per il primo ciclo, $linizializza su $null, che viene valutato qui come 0.

Quella stringa è ulteriormente concatenata con un altro numero di spazi (definito da quanto tempo $asarebbe se -replaced ogni pipe senza nulla, più 1per il riempimento aggiuntivo tra codice e commenti, meno l' .lengthelemento dell'elemento corrente, meno $lche è quanti spazi abbiamo riempito lasciato su questa iterazione), concatenato con il nostro personaggio di commento $b. È rimasto sulla pipeline.

Aggiorniamo quindi $lper la prossima iterazione.

Le stringhe risultanti vengono tutte lasciate sulla pipeline e l'output tramite implicito Write-Outputavviene all'esecuzione del programma, con una nuova riga tra loro per impostazione predefinita.

Esempi

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 sequenze di tasti

-1 byte grazie a DJMcMayhem

Si aspetta come input un buffer (ad esempio un file) il cui primo carattere è il delimitatore di commento, seguito dal codice, ad es #foo|bar|baz.

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

Spiegazione

(" _" indica uno spazio letterale.)

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

Floroide - 94 byte

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

Utilizza un approccio simile alla soluzione Python di @ JonathanAllan .

Casi test

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 byte

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;
}

Una soluzione LINQ sarebbe stata 146 ma avrebbe dovuto using System.Linq;riportarla a 164:

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");}

Vecchie soluzioni:

167 byte:

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 byte usando l'interpolazione di stringhe

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 byte

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

o

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

MATL , 33 31 byte

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

Provalo online!

Spiegazione

La funzione builtin Yd( blkdiag), che crea una matrice diagonale a blocchi dai suoi input, svolge gran parte del lavoro. I valori di riempimento nella matrice sono 0 e char 0 viene trattato come uno spazio a scopo di visualizzazione. Il codice si sarebbe semplicemente diviso |, creato una matrice dai blocchi risultanti, convertito in carattere e aggiunto due colonne con spazio e simbolo di commento.

Tuttavia, la possibilità di sezioni vuote nella stringa di input complica il problema più interessante: il blocco risultante sarebbe vuoto e quindi non mostrerebbe nella matrice risultante.

Per risolvere questo, introduciamo un carattere 0 prima di ciascuno |, quindi nessun blocco sarà vuoto; e quindi nella matrice di caratteri risultante rimuoviamo le colonne formate solo da char 0. Una sezione di codice non vuota avrà alcuni caratteri ASCII stampabili, e quindi le colonne che attraversa sopravviveranno. Una sezione vuota contribuirà con una riga, ma non introdurrà una colonna aggiuntiva.

'\|'    % 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 byte

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

o

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

Entrambi sono programmi completi che accettano input su STDIN della stringa di commento e quindi sulla stringa di programma, separati da nuova riga.

Prova la prima versione online

Prova la seconda versione online

Come funzionano

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 (non competitivo), 43 37 byte

Richiede il carattere di commento, quindi il codice.

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

Non competitiva perché la versione 16.0 è più recente di questa sfida.

Perl, 63 byte

Include +5 per -Xpi

Esegui con input su STDIN e commenta il carattere dopo -i:

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

esolang.pl:

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

Soluzione semplice e totalmente noiosa

Turtlèd , 35 byte (non competitivo)

Accetta un input, l'ultimo carattere è il commento. Non funziona con il carattere di commento come spazio, ma presumo che non sia necessario.

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

Spiegazione:

!                                  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 byte

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

Provalo online!

Scala, 123 byte

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}}

Codice test + Uscita:

?("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 @

Rubino, 96 80 byte

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

Guardalo su eval.in: https://eval.in/639012

Dovrei davvero solo imparare Retina.

Gelatina , 41 byte

Sembra che abbia molti incrementi e probabilmente troppi collegamenti ...

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

Provalo su TryItOnline

Come?

ṫø⁹‘‘µ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 byte

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

Spiegazione

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

Provalo online

GolfScript, 85 byte

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

Provalo online

Aggiornamento 2017 - GolfScript - 71 byte

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

Spiegazione

', '/~~: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

Gelatina , 10 byte

ṣ”|⁶ṁ;ɗ\pG

Provalo online!