Beaucoup de personnes sur ce site utilisent des langages ésotériques , et comme ces langages sont inhabituels et difficiles à comprendre, ils écriront souvent une explication dans un certain format. Par exemple, si le code était

abcdefghijklmnop

Et cette langue utilise #pour les commentaires, ils écriraient une explication comme celle-ci:

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

Je le fais souvent aussi, mais chaque fois que je le fais, j'ai l'impression que créer une mise en page de texte est vraiment désagréable et prend du temps. Je souhaite donc que vous créiez un "Générateur de modèles de commentaires" pour moi. Par exemple, si nous ignorons les commentaires, le code précédent contient ce modèle:

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

Le défi:

Vous devez écrire un programme ou une fonction prenant deux chaînes en entrée et générer ce "Esolang-Comment-Template". La première entrée sera le code, mais avec des barres ( |) insérées à l'emplacement des nouvelles lignes. La deuxième entrée est ce que nous allons utiliser pour les commentaires. Donc, notre dernier exemple aurait ceci pour entrée:

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

Malheureusement, cela exclut les barres de la saisie de code, mais ce n'est pas grave. Vous pouvez supposer que le commentaire sera un seul caractère. Par souci de simplicité, le caractère de commentaire ne sera pas un obstacle. Le code saisi ne contiendra que du code ASCII imprimable et ne contiendra aucune nouvelle ligne.

J'espère que vous pourrez déduire quoi faire à partir des cas de test, mais je vais essayer de clarifier certaines choses.

Vous devez diviser le code saisi en "sections de code" sur chaque barre. Ensuite, chaque section de code est sortie sur sa propre ligne et complétée à gauche avec la longueur de tout le code précédent (sans les barres). Ensuite, chaque ligne est complétée à droite avec suffisamment d'espaces pour que les deux derniers caractères de chaque ligne soient "Un espace supplémentaire" + "Le caractère de commentaire".

Une nouvelle ligne est autorisée.

Voici un autre exemple. Pour l'entrée

"Hello|World", "/"

La première section de code est "Hello" et la seconde est "World". Donc, il devrait donner la sortie:

Hello      /
     World /

Voici quelques exemples supplémentaires:

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 @

Règles:

Vous pouvez prendre ces entrées et sorties dans n’importe quel format raisonnable. Par exemple, lire / écrire un fichier, STDIN / STOUT, arguments de fonction / renvoyer, etc. Comme d’habitude, il s’agit de code-golf , essayez donc de rendre votre code le plus court possible et vous gagnerez si vous pouvez obtenir la solution la plus courte. dans ta langue! Je choisirai également la solution la plus courte en tant que gagnant. Les échappatoires standard sont interdites.

Pyth - 28 27 24 23 octets

Pourrait être capable de jouer au golf un peu. Beaucoup, apparemment!

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

Essayez-le en ligne ici .

Retina , 35 à 34 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Les deux chaînes d'entrée sont séparées par un espace (ce qui est sans ambiguïté puisque nous savons que le délimiteur de commentaire est toujours un caractère unique).

Essayez-le en ligne!

Java 10, 189 159 octets

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 octets convertissant Java 7 en Java 10 et optimisant les boucles.

Essayez-le en ligne.

Explication:

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 octets

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

Essayez-le ici!

JavaScript (ES6), 92 octets

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

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

Les entrées sont des chaînes séparées par un espace.

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 @

Sortie:

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

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

Sauvegardé 4 octets en insérant une définition.

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 octets

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

non golfé *

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

(Premier brouillon avec 120 octets)

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

non golfé *

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

Des 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 octets

-1 octet grâce à @TuukkaX (manque de jouer au golf dans l'espace 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)

Tous les cas de test sur ideone

Python 2, 107 105 102 99 octets

Testé avec tous les cas de test ci-dessus

EDIT Golfed off 2 octets en changeant d = a.split ("|"); i = 0 à d, i = a.split ("|"), 0 Je ne sais pas comment j'ai raté celui-ci. Merci @ Oliver Ni

Encore 3 octets partis. Merci encore.

La suggestion de @ Jonathan économise en réalité 3 octets et la ramène à la magie 99. Merci.

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 octets

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

Peut certainement être golfed, mais au moins son travail maintenant ..
+9 octets car ¡(split) supprime les éléments vides automatiquement, donc je devais ajouter '|„ǝʒ:'ǝ¡'ʒм..
-2 octets grâce à @MagicOctopusUrn en changeant '|„ǝʒ:'ǝ¡'ʒмà '|¶:.BεðÜ}(solution actuelle ne fonctionne pas éléments avec des espaces de fin, mais je suppose que cela est autorisé selon les cas de test).

Essayez-le en ligne.

Explication:

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

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

Prend les entrées sous forme de deux chaînes, -splits la première sur un tube littéral (puisque split utilise la syntaxe regex) et insère les éléments dans une boucle |%{...}.

À chaque itération, nous construisons une chaîne comme étant un nombre d'espaces définis par $lconcaténation avec l'élément en cours. Pour la première boucle, $linitialise à $null, qui est évalué ici comme 0.

Cette chaîne est encore concaténé avec un autre nombre d'espaces (définis par combien de temps $aserait si nous -replaced tous les tuyaux avec rien, plus 1pour le rembourrage supplémentaire entre le code et les commentaires, moins le .lengthde l'élément courant, moins ce $lqui est combien de places nous rembourrés laissé sur cette itération), concaténé avec notre caractère de commentaire $b. Cela reste sur le pipeline.

Nous mettons ensuite à jour $lpour la prochaine itération.

Les chaînes résultantes sont toutes laissées sur le pipeline et la sortie via implicite Write-Outputse produit lors de l'exécution du programme, avec une nouvelle ligne entre elles par défaut.

Exemples

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 frappes

-1 octet grâce à DJMcMayhem

Attend en entrée un tampon (par exemple, un fichier) dont le premier caractère est le délimiteur de commentaire, suivi du code, par exemple #foo|bar|baz.

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

Explication

(" _" désigne un espace littéral.)

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

Floroïde - 94 octets

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

Utilise une approche similaire à la solution @ JonathanAllan s Python.

Testcases

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 octets

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

Non Golfé

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

Une solution LINQ aurait été de 146 mais il fallait la using System.Linq;ramener à 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");}

Anciennes solutions:

167 octets:

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 octets en interpolation de chaîne

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 octets

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

ou

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

MATL , 33 31 octets

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

Essayez-le en ligne!

Explication

La fonction intégrée Yd( blkdiag), qui construit une matrice bloc-diagonale à partir de ses entrées, effectue la majeure partie du travail. Les valeurs de remplissage dans la matrice sont 0 et le caractère 0 est traité comme un espace pour l'affichage. Le code serait simplement scindé |, construit une matrice à partir des blocs résultants, converti en caractères et ajouté deux colonnes avec un espace et un symbole de commentaire.

Cependant, la possibilité de sections vides dans la chaîne d'entrée complique le problème: le bloc résultant serait vide et ne s'afficherait donc pas dans la matrice résultante.

Pour résoudre ce problème, nous introduisons un caractère 0 avant chaque caractère |, ainsi aucun bloc ne sera vide; puis, dans la matrice de caractères obtenue, nous supprimons les colonnes formées par le caractère 0 uniquement. Une section de code non vide aura un caractère imprimable ASCII et les colonnes qu'elle contient survivront. Une section vide contribuera à une ligne, mais n'introduira pas de colonne supplémentaire.

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

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

ou

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

Les deux sont des programmes complets qui prennent une entrée sur STDIN de la chaîne de commentaire, puis la chaîne de programme, séparée par une nouvelle ligne.

Essayez la première version en ligne

Essayez la deuxième version en ligne

Comment ils travaillent

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 compétitif), 43 37 octets

Invite le caractère de commentaire, puis le code.

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

Non compétitif car la version 16.0 est plus récente que ce défi.

Perl, 63 octets

Comprend +5 pour -Xpi

Exécuter avec une entrée sur STDIN et un caractère de commentaire après -i:

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

esolang.pl:

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

Solution simple et totalement ennuyeuse

Turtlèd , 35 bytes (non compétitif)

Prend une entrée, le dernier caractère est le caractère de commentaire. Ne fonctionne pas avec le caractère de commentaire comme espace, mais je suppose que ce n'est pas nécessaire.

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

Explication:

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

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

Essayez-le en ligne!

Scala, 123 octets

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

Code de test + sortie:

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

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

Voir sur eval.in: https://eval.in/639012

Je devrais vraiment apprendre la rétine.

Gelée , 41 octets

Cela semble avoir beaucoup trop progressé, et probablement trop de liens ...

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

Testez-le sur TryItOnline

Comment?

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

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

Explication

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

Essayez-le en ligne

GolfScript, 85 octets

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

Essayez-le en ligne

Mise à jour 2017 - GolfScript - 71 octets

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

Explication

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

Gelée , 10 octets

ṣ”|⁶ṁ;ɗ\pG

Essayez-le en ligne!