Bu sitedeki pek çok insan ezoterik diller kullanıyor ve bu diller sıra dışı ve anlaşılması zor olduğu için sık sık belli bir biçimde bir açıklama yazacaklar. Örneğin, kod açıksa

abcdefghijklmnop

Ve bu diller #yorumlar için kullanır , şöyle bir açıklama yazarlar:

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

Bunu da sık sık yapıyorum, ancak bunu her yaptığımda, metin düzenini oluşturmak gerçekten iğrenç ve zaman alıcı gibi hissediyorum. Bu yüzden benim için bir "Esolang-Yorum-Şablon-Jeneratör" oluşturmanızı istiyorum. Örneğin, yorumları görmezden gelirsek, önceki kod şu şablona sahiptir:

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

Meydan okuma:

Giriş olarak iki dizgiyi alan ve bu "Esolang-Comment-Template" çıktısını alan bir program veya işlev yazmalısınız. İlk girdi kod olacak, ancak |yeni satırların gittiği yere eklenen çubuklarla ( ). İkinci girdi, yorumlar için kullanacağımız şeydir. Yani son örneğimizde girdi için bu olurdu:

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

Ne yazık ki bu, kod girişinin bir parçası olarak çubukları hariç tutar, ancak sorun değil. Yorum girişinin tek bir karakter olacağını varsayabilirsiniz. Sadelik uğruna, yorum char bir bar olmayacak. Kod girişi yalnızca yazdırılabilir ASCII içerecek ve herhangi bir yeni satır içermeyecek.

Umarım testislerden ne yapacağını çıkarırsın, ama bazı şeyleri açıklığa kavuşturmaya çalışacağım.

Kod girişini her çubukta "kod bölümlerine" bölmelisiniz. Ardından, kodun her bir bölümü kendi satırında çıkarılır ve önceki tüm kodların uzunluğu ile sol çubuklarla doldurulur (çubuklar dahil değil). Ardından, her satır yeterli boşlukla sağa doldurulur, böylece her satırdaki son iki karakter "Ek bir boşluk" + "Yorum karakteri" olur.

Sondaki bir satırsonuna izin verilir.

İşte başka bir örnek. Giriş için

"Hello|World", "/"

Kodun ilk bölümü "Merhaba", ikincisi "Dünya". Bu yüzden çıktı vermelidir:

Hello      /
     World /

İşte bazı örnekler:

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 @

Kurallar:

Bu giriş ve çıkışları herhangi bir makul formatta alabilirsiniz. Örneğin, vb zamanki gibi / bir dosya yazma, STDIN / STOUT, fonksiyon argümanları / dönüş değeri, okuma, bu kod golf , bu nedenle mümkün olduğunca kısa kodunuzu yapmaya ve en kısa çözümü alabilirsiniz eğer kazanmak kendi dilinizde Ayrıca genel kazanan olarak en kısa çözümü seçeceğim. Standart boşluklar yasaklandı.

Pyth - 28 27 24 23 bayt

Biraz golf oynayabilirsin. Görünüşe göre çok kapalı!

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

Burada çevrimiçi deneyin .

Retina , 35 34 bayt

Bayt sayısı, ISO 8859-1 kodlamasını varsayar.

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

İki giriş dizesi bir boşlukla ayrılır (yorum sınırlayıcısının her zaman tek bir karakter olduğunu bildiğimiz için açıktır).

Çevrimiçi deneyin!

Java 10, 189 159 bayt

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

Java 7'yi Java 10'a dönüştüren ve döngüleri optimize eden -30 bayt.

Çevrimiçi deneyin.

Açıklama:

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 bayt

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

Burada dene!

JavaScript (ES6), 92 bayt

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 (-r için 85 + 1) 86

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

Girişler boşlukla ayrılmış dizelerdir.

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

Çıktı:

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

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

Bir tanım girerek 4 bayt kaydedildi.

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 Bayt

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

(120 Baytlık İlk Taslak)

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

Testler

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

@TuukkaX sayesinde -1 bayt (boşluğu kaçırdı 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)

İdeone üzerindeki tüm test vakaları

Python 2, 107 105 102 99 bayt

Yukarıdaki tüm test durumlarıyla test edilmiştir

EDIT d = a.split ("|"); i = 0 - d, i = a.split ("|"), 0 değiştirilerek Golf atıldı. 0 Bunu nasıl kaçırdığımdan emin değilim. Teşekkürler @Oliver Ni

3 bayt daha gitti. Tekrar teşekkürler.

@Jonathan'dan gelen öneri aslında 3 byte tasarruf sağlar ve onu 99 sihirine indirir. Teşekkürler.

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 bayt

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

Kesinlikle golfed olmak, ama en azından onun şimdi çalışıyor Can ..
9 bayt çünkü ¡(ayrık) otomatik olarak boş öğeleri kaldırır, söylemek zorunda '|„ǝʒ:'ǝ¡'ʒм..
-2 sayesinde bayt @MagicOctopusUrn değiştirerek '|„ǝʒ:'ǝ¡'ʒмiçin '|¶:.BεðÜ}(geçerli bir çözüm çalışmaz boşlukları olan öğeler, ancak bunun test durumlarına göre izin verildiğini varsaydım).

Çevrimiçi deneyin.

Açıklama:

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

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

Girdiyi iki karakter dizisi olarak alır, -splitilk bilgi satırında ilk olan budur (bölünme düzenli ifade sözdizimini kullandığından beri) ve öğeleri bir döngüye besler |%{...}.

Her yinelemede, $lgeçerli elemanla birleştirilerek tanımlanmış bir dizi boşluk olarak bir dize oluştururuz . İlk döngü $liçin $null, burada olarak değerlendirilen olanı başlatır 0.

Bu dize başka bir boşlukla daha da birleştirilir ( her boru hattını hiçbir şey olmadan $ageçirmemizin ne kadar süreceği -replace, artı 1kod ve yorumlar arasındaki ek dolgu için .length, geçerli elemanın eksi, eksi $lhangi boşluk doldurduğumuz ile tanımlanır) Bu yinede bıraktı), yorum karakterimizle birleştirdi $b. Boru hattında kaldı.

Ardından bir $lsonraki yineleme için güncelleme yaparız .

Sonuçta ortaya çıkan dizgilerin tümü boru hattında bırakılır ve örtük yoluyla çıktı Write-Output, program yürütmesinde varsayılan olarak aralarında yeni bir satır olacak şekilde gerçekleşir.

Örnekler

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 tuş vuruşlarını

DJMcMayhem sayesinde -1 bayt

İlk karakteri yorum sınırlayıcı olan bir arabellek (örn. Bir dosya) girdi bekliyor, ardından kod geliyor #foo|bar|baz.

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

açıklama

(" _" değişmez alanı belirtir.)

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

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

@ JonathanAllan ın Python çözümüne benzer bir yaklaşım kullanır .

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 bayt

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

Bir LINQ çözümü 146 olurdu ancak using System.Linq;164'e geri getirilmesi gerekiyordu:

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

Eski çözümler:

167 bayt:

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

String enterpolasyonu kullanarak 176 bayt

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 bayt

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

veya

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

MATL , 33 31 bayt

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

Çevrimiçi deneyin!

açıklama

Girişlerinden blok çapraz bir matris oluşturan yerleşik işlev Yd( blkdiag), işin çoğunu yapar. Matristeki dolum değerleri 0'dır ve char 0, görüntüleme amaçları için boşluk olarak değerlendirilir. Kod basitçe bölünür |, sonuçta elde edilen bloklardan bir matris oluşturur, char'e dönüştürür ve boşluk ve yorum sembolüyle iki sütun eklerdi.

Bununla birlikte, giriş dizgisindeki boş bölümlerin olasılığı sorunu karmaşıklaştırmaktadır : sonuçta ortaya çıkan blok boş olacak ve sonuçta ortaya çıkan matriste gösterilmeyecektir.

Bunu çözmek için, her birinden önce bir char 0 tanıtıyoruz |, böylece hiçbir blok boş olmayacak; ve daha sonra ortaya çıkan char matrisinde, sadece char 0 tarafından oluşturulan sütunları kaldırırız. Boş olmayan bir kod bölümü bazı yazdırılabilir ASCII karakterlerine sahip olacak ve böylece yaydıkları sütunlar hayatta kalacaktır. Boş bir bölüm bir satırda katkıda bulunur, ancak fazladan bir sütun oluşturmaz.

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

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

veya

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

Her ikisi de yorum dizesinin STDIN'sine girdi alan tam programlardır ve daha sonra newline ile ayrılmış program dizesidir.

Çevrimiçi ilk sürümü deneyin

İkinci versiyonu çevrimiçi olarak deneyin

Onlar nasıl çalışır

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 (yarışmayan), 43 37 bayt

Yorum karakteri, ardından kod için ister.

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

Rekabetçi değil, çünkü sürüm 16.0 bu zorluktan daha yeni.

Perl, 63 bayt

İçin +5 içerir -Xpi

STDIN'de giriş ile çalıştırın ve -i'den sonra karakter yazın:

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

esolang.pl:

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

Tamamen sıkıcı basit çözüm

Turtlèd , 35 bayt (rekabetçi değil)

Bir giriş alır, son karakter yorum karakteridir. Boşluk olarak yorum karakteri ile çalışmaz, ancak bunun gerekli olmadığını varsayıyorum.

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

Açıklama:

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

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

Çevrimiçi deneyin!

Scala, 123 bayt

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

Test kodu + Çıkış:

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

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

Eval.in üzerinde görün: https://eval.in/639012

Gerçekten sadece Retina'yı öğrenmeliyim.

Jöle , 41 bayt

Bu, pek çok artışa ve muhtemelen çok fazla bağlantıya sahip gibi görünüyor ...

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

TryItOnline'da test edin

Nasıl?

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

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

açıklama

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

Çevrimiçi deneyin

GolfScript, 85 bayt

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

Çevrimiçi deneyin

2017 Güncellemesi - GolfScript - 71 bayt

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

açıklama

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

Jöle , 10 bayt

ṣ”|⁶ṁ;ɗ\pG

Çevrimiçi deneyin!