Rất nhiều người trên trang này sử dụng các ngôn ngữ bí truyền , và vì những ngôn ngữ này khác thường và khó hiểu, họ sẽ thường xuyên viết một lời giải thích theo một định dạng nhất định. Ví dụ: nếu mã là

abcdefghijklmnop

Và ngôn ngữ này sử dụng #cho ý kiến, họ sẽ viết một lời giải thích như thế này:

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

Tôi cũng thường xuyên làm điều này, nhưng mỗi lần tôi làm điều này, tôi cảm thấy việc tạo bố cục của văn bản thực sự đáng ghét và tốn thời gian. Vì vậy, tôi muốn bạn tạo một "Esolang-Comment-Template-Generator" cho tôi. Ví dụ: nếu chúng tôi bỏ qua các nhận xét, mã trước đó có mẫu này:

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

Các thách thức:

Bạn phải viết một chương trình hoặc hàm lấy hai chuỗi làm đầu vào và xuất ra "Esolang-Comment-Template" này. Đầu vào đầu tiên sẽ là mã, nhưng với các thanh ( |) được chèn vào nơi dòng mới đi. Đầu vào thứ hai là những gì chúng tôi sẽ sử dụng cho ý kiến. Vì vậy, ví dụ cuối cùng của chúng tôi sẽ có điều này cho đầu vào:

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

Thật không may, điều này loại trừ các thanh là một phần của đầu vào mã, nhưng điều đó không sao. Bạn có thể giả định rằng đầu vào bình luận sẽ là một ký tự đơn. Để đơn giản, char bình luận sẽ không phải là một thanh. Đầu vào mã sẽ chỉ chứa ASCII có thể in và nó sẽ không chứa bất kỳ dòng mới nào.

Hy vọng rằng bạn có thể suy luận phải làm gì từ các bản thử nghiệm, nhưng tôi sẽ cố gắng làm rõ một số điều.

Bạn phải chia mã đầu vào thành "phần mã" trên mỗi thanh. Sau đó, mỗi phần của mã được xuất ra trên dòng riêng và được đệm trái với độ dài của tất cả các mã trước đó (không bao gồm các thanh). Sau đó, mỗi dòng được đệm đúng với đủ khoảng trắng sao cho hai ký tự cuối cùng trên mỗi dòng là "Một khoảng trắng bổ sung" + "Ký tự nhận xét".

Một dòng mới được cho phép.

Đây là một ví dụ khác. Đối với đầu vào

"Hello|World", "/"

Đầu tiên phần của mã là "Hello" và thứ hai là "thế giới". Vì vậy, nó sẽ cung cấp cho đầu ra:

Hello      /
     World /

Dưới đây là một số mẫu khác:

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 @

Quy tắc:

Bạn có thể lấy những đầu vào và đầu ra ở bất kỳ định dạng hợp lý. Ví dụ: đọc / ghi tệp, STDIN / STOUT, đối số hàm / giá trị trả về, v.v. Như thường lệ, đây là mã golf , vì vậy hãy cố gắng làm cho mã của bạn càng ngắn càng tốt và bạn sẽ thắng nếu bạn có thể nhận được giải pháp ngắn nhất trong ngôn ngữ của bạn! Tôi cũng sẽ chọn giải pháp ngắn nhất là người chiến thắng chung cuộc. Sơ hở tiêu chuẩn bị cấm.

Pyth - 28 27 24 23 byte

Có thể chơi golf một chút. Rất nhiều, rõ ràng!

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

Hãy thử trực tuyến tại đây .

Võng mạc , 35 34 byte

Số lượng byte giả định mã hóa ISO 8859-1.

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

Hai chuỗi đầu vào được phân tách bằng một khoảng trắng (không rõ ràng vì chúng ta biết rằng dấu phân cách nhận xét luôn là một ký tự đơn).

Hãy thử trực tuyến!

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 chuyển đổi Java 7 sang Java 10 và tối ưu hóa các vòng lặp.

Hãy thử trực tuyến.

Giải trình:

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

Hãy thử nó ở đây!

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

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

Các đầu vào là các chuỗi ngăn cách bởi một khoảng trắng.

Kiểm tra:
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 @

Đầu ra:

$ 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

Đã lưu 4 byte bằng cách đặt một định nghĩa.

Ung dung:

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

vô dụng *

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

(Bản nháp đầu tiên với 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')}

vô dụng *

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

Xét nghiệm

%> 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 nhờ @TuukkaX (bỏ lỡ khoảng trống từ 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)

Tất cả các trường hợp thử nghiệm trên ideone

Python 2, 107 105 102 99 byte

Đã thử nghiệm với tất cả các trường hợp thử nghiệm ở trên

EDIT đã loại bỏ 2 byte bằng cách thay đổi d = a.split ("|"); i = 0 thành d, i = a.split ("|"), 0 Không chắc chắn tôi đã bỏ lỡ cái đó như thế nào. Cảm ơn @Oliver Ni

Thêm 3 byte nữa. Cảm ơn một lần nữa.

Gợi ý từ @Jonathan thực sự tiết kiệm 3 byte và đưa nó xuống phép thuật 99. Cảm ơn.

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,

Chắc chắn có thể được chơi gôn, nhưng ít nhất nó vẫn hoạt động ..
+9 byte vì ¡(tách) tự động xóa các mục trống, vì vậy tôi phải thêm '|„ǝʒ:'ǝ¡'ʒм..
-2 byte nhờ @MagicOctopusUrn bằng cách thay đổi '|„ǝʒ:'ǝ¡'ʒмthành '|¶:.BεðÜ}(giải pháp hiện tại không hoạt động các mục có dấu cách, nhưng tôi cho rằng điều đó được cho phép theo các trường hợp thử nghiệm).

Hãy thử trực tuyến.

Giải trình:

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

Lấy đầu vào là hai chuỗi, -splitlà chuỗi đầu tiên trên đường dẫn bằng chữ (vì phân tách sử dụng cú pháp regex) và đưa các phần tử vào một vòng lặp |%{...}.

Mỗi lần lặp, chúng ta xây dựng một chuỗi là một số khoảng trắng được xác định bằng cách $lnối với phần tử hiện tại. Đối với vòng lặp đầu tiên, $lkhởi tạo $null, được đánh giá ở đây là 0.

Chuỗi đó được nối tiếp với một số khoảng trắng khác (được xác định bằng khoảng thời gian $anếu -replacemỗi ống không có gì, cộng 1với phần đệm bổ sung giữa mã và nhận xét, trừ .lengthphần tử hiện tại, trừ đi $lsố lượng khoảng trống chúng ta đã đệm còn lại trên lần lặp này), nối với ký tự nhận xét của chúng tôi $b. Đó là trái trên đường ống.

Sau đó chúng tôi cập nhật $lcho lần lặp tiếp theo.

Các chuỗi kết quả là tất cả còn lại trên đường ống và đầu ra thông qua ẩn Write-Outputxảy ra khi thực hiện chương trình, với một dòng mới giữa chúng theo mặc định.

Ví dụ

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 tổ hợp phím

-1 byte nhờ DJMcMayhem

Mong đợi như là một bộ đệm (ví dụ: một tệp) có ký tự đầu tiên là dấu phân cách nhận xét, theo sau là mã, vd #foo|bar|baz.

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

Giải trình

(" _" biểu thị một không gian theo nghĩa đen.)

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

Sử dụng một cách tiếp cận tương tự như giải pháp Python của @ Jonathan ALLan.

Tủ thử

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

Vô duyên

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

Một giải pháp LINQ sẽ là 146 nhưng cần using System.Linq;đưa nó trở lại lên tới 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");}

Giải pháp cũ:

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 sử dụng phép nội suy chuỗi

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

hoặc là

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

Hãy thử trực tuyến!

Giải trình

Hàm dựng sẵn Yd( blkdiag), xây dựng ma trận khối chéo từ đầu vào của nó, thực hiện hầu hết công việc. Các giá trị điền vào ma trận là 0 và char 0 được coi là khoảng trắng để hiển thị mục đích. Mã chỉ đơn giản là phân tách |, xây dựng một ma trận từ các khối kết quả, chuyển đổi thành char và nối hai cột với dấu cách và ký hiệu nhận xét.

Tuy nhiên, khả năng các phần trống trong chuỗi đầu vào phức tạp làm cho vấn đề trở nên thú vị hơn: khối kết quả sẽ trống và do đó sẽ không hiển thị trong ma trận kết quả.

Để giải quyết điều này, chúng tôi giới thiệu một char 0 trước mỗi |, vì vậy sẽ không có khối nào trống; và sau đó trong ma trận char kết quả, chúng ta loại bỏ các cột được hình thành bởi char 0. Một phần mã không trống sẽ có một số char ASCII có thể in được, và do đó các cột mà nó kéo dài sẽ tồn tại. Một phần trống sẽ đóng góp một hàng, nhưng sẽ không giới thiệu thêm một cột.

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

Bình thường, 30 byte

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

hoặc là

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

Cả hai đều là các chương trình đầy đủ lấy đầu vào trên STDIN của chuỗi nhận xét và sau đó là chuỗi chương trình, phân tách dòng mới.

Hãy thử phiên bản đầu tiên trực tuyến

Hãy thử phiên bản thứ hai trực tuyến

Chúng hoạt động như thế nào

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 (không cạnh tranh), 43 37 byte

Nhắc cho ký tự nhận xét, sau đó cho mã.

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

Không cạnh tranh vì phiên bản 16.0 mới hơn thử thách này.

Perl, 63 byte

Bao gồm +5 cho -Xpi

Chạy với đầu vào trên STDIN và nhận xét ký tự sau -i:

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

esolang.pl:

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

Giải pháp đơn giản nhàm chán

Turtlèd , 35 byte (không lọc )

Có một đầu vào, ký tự cuối cùng là ký tự nhận xét. Không hoạt động với ký tự nhận xét là không gian, nhưng tôi cho rằng điều đó là không cần thiết.

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

Giải trình:

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

Hãy thử trực tuyến!

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

Mã kiểm tra + Đầu ra:

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

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

Xem nó trên eval.in: https://eval.in/639012

Tôi thực sự nên học Retina.

Thạch , 41 byte

Điều này có vẻ như có nhiều gia tăng và có thể có quá nhiều liên kết ...

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

Kiểm tra nó tại TryItOnline

Làm sao?

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

Giải trình

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

Dùng thử trực tuyến

GolfScript, 85 byte

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

Dùng thử trực tuyến

Cập nhật 2017 - GolfScript - 71 byte

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

Giải trình

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

Thạch , 10 byte

ṣ”|⁶ṁ;ɗ\pG

Hãy thử trực tuyến!