ผู้คนจำนวนมากในไซต์นี้ใช้ภาษาที่ลึกลับและเนื่องจากภาษาเหล่านี้ผิดปกติและเข้าใจยากพวกเขามักจะเขียนคำอธิบายในรูปแบบที่แน่นอน ตัวอย่างเช่นถ้ารหัสคือ

abcdefghijklmnop

และภาษานี้ใช้#สำหรับความคิดเห็นพวกเขาจะเขียนคำอธิบายเช่นนี้:

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

ฉันทำสิ่งนี้บ่อยเช่นกัน แต่ทุกครั้งที่ทำสิ่งนี้ฉันรู้สึกว่าการสร้างเลย์เอาต์ของข้อความนั้นน่าสะพรึงกลัวและใช้เวลานาน ดังนั้นฉันต้องการให้คุณสร้าง "Esolang-Comment-Template-Generator" สำหรับฉัน ตัวอย่างเช่นหากเราไม่สนใจความคิดเห็นรหัสก่อนหน้ามีเทมเพลตนี้:

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

ความท้าทาย:

คุณต้องเขียนโปรแกรมหรือฟังก์ชั่นที่รับสองสายเป็นอินพุตและเอาต์พุต "Esolang-Comment-Template" นี้ การป้อนข้อมูลครั้งแรกจะเป็นรหัส แต่มีการ|แทรกแถบ ( ) ที่ขึ้นบรรทัดใหม่ อินพุตที่สองคือสิ่งที่เราจะใช้สำหรับความคิดเห็น ดังนั้นตัวอย่างสุดท้ายของเราจะมีสิ่งนี้สำหรับอินพุต:

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

น่าเสียดายที่นี่ไม่รวมแท่งจากการเป็นส่วนหนึ่งของการป้อนรหัส แต่ก็ไม่เป็นไร คุณสามารถสันนิษฐานได้ว่าอินพุตความคิดเห็นจะเป็นอักขระตัวเดียว เพื่อประโยชน์ของความเรียบง่ายถ่านความคิดเห็นจะไม่เป็นบาร์ การป้อนรหัสจะมีเฉพาะ ASCII ที่พิมพ์ได้และจะไม่มีการขึ้นบรรทัดใหม่

หวังว่าคุณสามารถสรุปสิ่งที่ต้องทำจาก testcase ได้ แต่ฉันจะพยายามอธิบายบางอย่าง

คุณต้องแบ่งการป้อนข้อมูลรหัสออกเป็น "ส่วนรหัส" ในทุกแถบ จากนั้นแต่ละส่วนของรหัสจะถูกส่งออกในบรรทัดของตัวเองและเบาะด้านซ้ายด้วยความยาวของรหัสก่อนหน้าทั้งหมด (ไม่รวมแถบ) จากนั้นแต่ละบรรทัดจะถูกเสริมด้วยพื้นที่ที่เพียงพอเพื่อให้อักขระสองตัวสุดท้ายในทุกบรรทัดเป็น "ช่องว่างเพิ่มเติมหนึ่งช่อง" + "อักขระข้อคิดเห็น"

อนุญาตให้ขึ้นบรรทัดใหม่ได้หนึ่งบรรทัด

นี่เป็นอีกตัวอย่างหนึ่ง สำหรับการป้อนข้อมูล

"Hello|World", "/"

ส่วนแรกของรหัสคือ "สวัสดี" และที่สองคือ "โลก" ดังนั้นควรให้ผลลัพธ์:

Hello      /
     World /

นี่คือตัวอย่างเพิ่มเติม:

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 @

กฎ:

คุณสามารถรับอินพุตและเอาต์พุตเหล่านี้ในรูปแบบที่สมเหตุสมผล ตัวอย่างเช่นการอ่าน / เขียนไฟล์ STDIN / STOUT ฟังก์ชันอาร์กิวเมนต์ / ค่าส่งคืนเป็นต้นตามปกตินี่คือcode-golfดังนั้นพยายามทำให้รหัสของคุณสั้นที่สุดเท่าที่จะเป็นไปได้และคุณจะชนะถ้าคุณได้วิธีแก้ปัญหาที่สั้นที่สุด ในภาษาของคุณ! ฉันจะเลือกทางออกที่สั้นที่สุดในฐานะผู้ชนะโดยรวม ช่องโหว่มาตรฐานถูกแบน

Pyth - 28 27 24 23 ไบต์

อาจจะสามารถเล่นกอล์ฟได้เล็กน้อย เห็นได้ชัดมาก!

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

ลองมันออนไลน์ได้ที่นี่

เรติน่า , 35 34 ไบต์

จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1

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

สตริงอินพุตสองสตริงคั่นด้วยช่องว่าง (ซึ่งไม่ชัดเจนเนื่องจากเรารู้ว่าตัวคั่นความคิดเห็นมักเป็นอักขระเดียว)

ลองออนไลน์!

Java 10, 189 159 ไบต์

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 ไบต์แปลง Java 7 เป็น Java 10 และปรับลูปให้เหมาะสม

ลองออนไลน์

คำอธิบาย:

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 ไบต์

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

ลองที่นี่!

JavaScript (ES6), 92 ไบต์

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 สำหรับ -r) 86

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

อินพุตเป็นสตริงที่คั่นด้วยช่องว่าง

การทดสอบ:
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 @

เอาท์พุท:

$ 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 ไบต์

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

บันทึกแล้ว 4 ไบต์โดยกำหนดนิยามไว้

Ungolfed:

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

Groovy, 120 113 111 Bytes

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

ungolfed *

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

(ร่างแรกที่มี 120 ไบต์)

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

การทดสอบ

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

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

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

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

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

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

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

Python 2, 125 124 132 bytes

-1 ไบต์ขอบคุณ @TuukkaX (พลาดการเล่นกอล์ฟในอวกาศ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)

กรณีทดสอบทั้งหมดในideone

Python 2, 107 105 102 99 ไบต์

ทดสอบกับกรณีทดสอบทั้งหมดข้างต้น

แก้ไขลบ 2 ไบต์โดยการเปลี่ยน d = a.split ("|"); i = 0 ถึง d, i = a.split ("|"), 0 ไม่แน่ใจว่าฉันพลาดมันไปได้อย่างไร ขอบคุณ @Oliver Ni

หายไปอีก 3 ไบต์ ขอบคุณอีกครั้ง.

คำแนะนำจาก @Jonathan จริง ๆ แล้วช่วยประหยัด 3 ไบต์และนำไปสู่เวทมนตร์ 99 ขอบคุณ

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 ไบต์

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

สามารถเล่นกอล์ฟได้ แต่อย่างน้อยก็ทำงานได้ในขณะนี้ ..
+9 ไบต์เนื่องจาก¡(แยก) ลบรายการว่างเปล่าโดยอัตโนมัติดังนั้นฉันจึงต้องเพิ่ม'|„ǝʒ:'ǝ¡'ʒм..
-2 ไบต์ขอบคุณ@MagicOctopusUrnโดยเปลี่ยน'|„ǝʒ:'ǝ¡'ʒмเป็น'|¶:.BεðÜ}(โซลูชันปัจจุบันไม่ทำงาน รายการที่มีช่องว่างต่อท้าย แต่ฉันคิดว่าเป็นสิ่งที่ได้รับอนุญาตตามกรณีทดสอบ)

ลองออนไลน์

คำอธิบาย:

'|¶:           # 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 ไบต์

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

จะเข้าเป็นสองสาย-splits ครั้งแรกในท่อที่แท้จริง (ตั้งแต่แยกใช้ไวยากรณ์ regex) |%{...}และฟีดองค์ประกอบลงห่วง

การวนซ้ำแต่ละครั้งเราสร้างสตริงเป็นจำนวนช่องว่างที่กำหนดโดยการ$lต่อกับองค์ประกอบปัจจุบัน สำหรับวงแรกที่$lเริ่มต้นในการที่ได้รับการประเมินที่นี่$null0

สตริงนั้นจะต่อกันอีกด้วยช่องว่างอีกจำนวนหนึ่ง (กำหนดโดยระยะเวลา$aถ้าเรา-replaceทุกไพพ์ไม่มีสิ่งใดบวก1กับการเสริมเพิ่มเติมระหว่างโค้ดและคอมเม้นท์ลบ.lengthองค์ประกอบปัจจุบันลบด้วย$lจำนวนช่องว่างที่เราเพิ่ม ด้านซ้ายบนซ้ำนี้) $bตัดแบ่งด้วยตัวอักษรที่แสดงความคิดเห็นของเรา ที่เหลืออยู่ในท่อ

จากนั้นเราอัปเดต$lสำหรับการทำซ้ำครั้งถัดไป

สตริงผลลัพธ์จะถูกทิ้งไว้บนไพพ์ไลน์และเอาต์พุตผ่านทาง implicit Write-Outputเกิดขึ้นที่การดำเนินการของโปรแกรมโดยมีการขึ้นบรรทัดใหม่ระหว่างบรรทัดนั้นเป็นค่าเริ่มต้น

ตัวอย่าง

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 |

เป็นกลุ่ม, 39 38 การกดแป้น

-1 ไบต์ขอบคุณ DJMcMayhem

คาดว่าเป็น input บัฟเฟอร์ (เช่นไฟล์) #foo|bar|bazที่มีตัวอักษรตัวแรกเป็นตัวคั่นความคิดเห็นตามด้วยรหัสเช่น

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

คำอธิบาย

(" _" หมายถึงพื้นที่ที่แท้จริง)

"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 ไบต์

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

ใช้วิธีการคล้ายกับโซลูชัน Python ของ@ JonathanAllan

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 ไบต์

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

โซลูชั่น LINQ น่าจะเป็น 146 แต่จำเป็นต้องusing System.Linq;นำมันกลับมาที่ 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");}

โซลูชั่นเก่า:

167 ไบต์:

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 ไบต์โดยใช้การแก้ไขสตริง

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 ไบต์

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

หรือ

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

MATL , 33 31 ไบต์

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

ลองออนไลน์!

คำอธิบาย

ฟังก์ชั่น builtin Yd( blkdiag) ซึ่งสร้างเมทริกซ์บล็อก - ทแยงจากอินพุตของมันทำหน้าที่ส่วนใหญ่ได้ ค่าการเติมในเมทริกซ์คือ 0 และถ่าน 0 ถือเป็นพื้นที่สำหรับแสดงวัตถุประสงค์ รหัสจะแบ่งบน|สร้างเมทริกซ์จากบล็อกผลลัพธ์แปลงเป็นอักขระและผนวกสองคอลัมน์ด้วยช่องว่างและสัญลักษณ์ความคิดเห็น

แต่เป็นไปได้ของส่วนที่ว่างเปล่าในสายป้อนความซับซ้อนทำให้ปัญหาที่น่าสนใจเพิ่มเติมได้ที่: บล็อกที่เกิดขึ้นจะเป็นที่ว่างเปล่าและจึงจะไม่แสดงในเมทริกซ์ที่เกิดขึ้น

ในการแก้ปัญหานี้เราแนะนำถ่าน 0 ตัวต่อหน้า|ดังนั้นบล็อกจะไม่ว่างเปล่า แล้วในเมทริกซ์ถ่านที่ได้เราจะลบคอลัมน์ที่เกิดขึ้นโดยถ่าน 0 เท่านั้น ส่วนรหัสที่ไม่ว่างเปล่าจะมีอักขระ ASCII ที่พิมพ์ได้บางส่วนและคอลัมน์ที่อยู่ในนั้นจะมีชีวิตรอด ส่วนที่ว่างจะมีส่วนร่วมในแถว แต่จะไม่แนะนำคอลัมน์เพิ่มเติม

'\|'    % 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 ไบต์

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

หรือ

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

ทั้งคู่เป็นโปรแกรมเต็มรูปแบบที่รับอินพุตบน STDIN ของสตริงความคิดเห็นจากนั้นสตริงโปรแกรมจะถูกคั่นด้วยบรรทัดใหม่

ลองรุ่นแรกออนไลน์

ลองรุ่นที่สองออนไลน์

พวกเขาทำงานอย่างไร

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 (ไม่แข่งขัน), 43 37 ไบต์

แสดงพร้อมต์สำหรับอักขระข้อคิดเห็นจากนั้นใส่โค้ด

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

ไม่แข่งขันเนื่องจากเวอร์ชั่น 16.0 นั้นใหม่กว่าความท้าทายนี้

Perl, 63 ไบต์

รวมถึง +5 สำหรับ -Xpi

รันด้วยอินพุตบน STDIN และแสดงความคิดเห็นหลังจาก -i:

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

esolang.pl:

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

โซลูชั่นที่ตรงไปตรงมาน่าเบื่อโดยสิ้นเชิง

Turtlèd , 35 ไบต์ (ไม่ใช่การแข่งขัน)

รับหนึ่งอินพุตอักขระตัวสุดท้ายคืออักขระข้อคิดเห็น ไม่ทำงานกับอักขระความคิดเห็นเป็นช่องว่าง แต่ฉันคิดว่าไม่จำเป็น

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

คำอธิบาย:

!                                  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 

ขี้ขลาด 89 ไบต์

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

ลองออนไลน์!

สกาลา 123 ไบต์

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

ทดสอบรหัส + ผลลัพธ์:

?("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 ไบต์

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

ดูได้ที่ eval.in: https://eval.in/639012

ฉันควรเรียนรู้เรื่องจอประสาทตาจริงๆ

เยลลี่ , 41 ไบต์

ดูเหมือนว่าจะมีจำนวนเพิ่มขึ้นมากและอาจมีลิงก์มากเกินไป ...

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

ทดสอบที่TryItOnline

อย่างไร?

ṫø⁹‘‘µ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 ไบต์

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

คำอธิบาย

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

ลองออนไลน์

GolfScript, 85 ไบต์

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

ลองออนไลน์

อัปเดต 2017 - GolfScript - 71 ไบต์

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

คำอธิบาย

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

เยลลี่ 10 ไบต์

ṣ”|⁶ṁ;ɗ\pG

ลองออนไลน์!