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

ตัวอย่างเช่นหากนี่เป็นรหัสของฉัน:

1_'[3:~2@+]`

หนึ่งในไดอะแกรมที่เป็นไปได้มากมายที่ฉันสามารถสร้างได้จะเป็นดังนี้:

1           
 _'         
   [      ] 
   [3:    ] 
   [  ~   ] 
   [   2@ ] 
   [     +] 
           `

เป้าหมาย

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

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

นี่คือตัวอย่างของ I / O โดยไม่มีการจัดรูปแบบเหมือนวงเล็บ :

123423
AabcBC

1     
    2 
     3
 2    
  3   
   4  

วงเล็บ

หากมีอักขระมากกว่าหนึ่งตัวในโปรแกรมที่มีระดับความสำคัญเท่ากันชุดของอักขระนั้นจะทำหน้าที่เป็นบล็อกเดียวของโค้ด (หากเป็นกลุ่ม) หรือชุดของวงเล็บ (หากมีอักขระอื่นอยู่ระหว่าง) กฎทั่วไปนั้นง่าย:

1. อักขระจะไม่ปรากฏในบรรทัดของไดอะแกรมจนกว่าอักขระอื่น ๆ ที่มีลำดับความสำคัญมากกว่าทั้งหมดจะปรากฏในบรรทัดด้านบนในไดอะแกรม

2. อักขระที่มีลำดับความสำคัญเท่ากันจะพิมพ์บนบรรทัดเดียวกันเสมอ หากอักขระบางตัวปรากฏบนบรรทัดอักขระอื่นทั้งหมดที่มีลำดับความสำคัญเท่ากันจะปรากฏขึ้นบนบรรทัด

3. ชุดอักขระที่มีลำดับความสำคัญเท่ากันจะยังคงปรากฏในแต่ละบรรทัดจนกว่าอักขระอื่นทั้งหมดที่อยู่ในนั้นจะปรากฏขึ้นอย่างน้อยหนึ่งครั้ง สิ่งนี้อนุญาตสำหรับการก่อสร้าง "เหมือนวงเล็บ" หากbceabมีลำดับความสำคัญbอักขระนั้นจะปรากฏในบรรทัดที่สอง (เป็นลำดับความสำคัญสูงสุดลำดับที่สอง) และจะปรากฏต่อไปจนกว่าceaอักขระทั้งหมดจะปรากฏขึ้น หากสตริงลำดับความสำคัญคือabcadeafgaทั้งหมดbcdefgจะถูกพิจารณาว่าอยู่ภายในสตริงนั้นทั้ง 4 aวินาทีจะยังคงปรากฏจนกว่าจะgมีปรากฏ

ข้อกำหนดการจัดรูปแบบเพิ่มเติม

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

เกณฑ์การให้คะแนน

นี่คือการแข่งขันกอล์ฟรหัสไบต์น้อยที่สุดชนะ

ตัวอย่าง

นี่คือตัวอย่างที่ถูกคอมเม้นต์ของโค้ดที่มีการจัดรูปแบบที่ซับซ้อนมากขึ้น

1_'[3:~2@+]`
abbcddeffgch

1            #highest priority is denoted by the lowercase letter a
 _'          #priority b
   [      ]  #all characters with priority c
   [3:    ]  #priority d, but priority c still printed because it encloses more
   [  ~   ]  #priority e
   [   2@ ]  #priority f
   [     +]  #priority g, last line of c because all enclosed characters have appeared
           ` #priority h

ตัวอย่างใน Perl:

$_=<>;s/[^aeiou\W]/$&o$&/gi;print
aaaaaabbccccccccccbdddddbbbbeeeee

$_=<>;                           
      s/          /     /gi;     
      s/[^aeiou\W]/     /gi;     
      s/          /$&o$&/gi;     
                            print

นี่คือตัวอย่างบางส่วนใน CJam ซึ่งได้รับความอนุเคราะห์จาก Martin Büttner:

l~2*{_2%{3*)}{2/}?_p_(}g;
aabbcdddefffeeggeehhiiccj

l~                       
  2*                     
    {                 }g 
    {_2%              }g 
    {   {   }{  }?    }g 
    {   {3*)}{  }?    }g 
    {   {   }{2/}?    }g 
    {             _p  }g 
    {               _(}g 
                        ;

q{_eu'[,66>"EIOU"-#)g{'o1$}*}/
abcccddddddeeeeeeefgghiijjhhbb

q                             
 {                          }/
 {_eu                       }/
 {   '[,66>                 }/
 {         "EIOU"-          }/
 {                #         }/
 {                 )g       }/
 {                   {    }*}/
 {                   {'o  }*}/
 {                   {  1$}*}/

นี่เป็นตัวอย่างที่บ้าคลั่งที่จะยุ่งกับคุณ:

1_'[3:~2@+]`
azTABACBDCAT

   [ :    ] 
   [3: 2  ] 
   [3:~2 +] 
   [ :~ @+] 
  '        `
1           
 _          

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

aabbccddaaeebb
aabbccddaaeebb

aa      aa    
aabb    aa  bb
aabbcc  aa  bb
aabb  ddaa  bb
  bb      eebb #"aa" no longer appears because all of "bbccdd" have already appeared.

Pyth, 33 40 ไบต์

JwFHS{Js.e?@zk&gHYsm&gdH}d>_>JxJYx_JYJdJ

ลองใช้งานออนไลน์: Pyth Compiler / Executor

คำอธิบาย:

สร้างด้วยสตริงaabbbbbzccdeeegfffqhjiiikkpnmmllloooohec:

                                          implicit: z = first input line
Jw                                        J = second input line
  FHS{J                                   for H in sorted(set(J)):
        .e                             J    map each k,Y of enumerate(J) to:
        .e?                            J      .... if ... else ...
        .e @zk                        dJ      z[k] if ... else " "
                                              condition: 
        .e @zk gHY                    dJ        H >= Y
        .e @zk&                       dJ        and
        .e @zk     m                 JdJ        map each d of J to:
        .e @zk     m gdH             JdJ          d >= H
        .e @zk     m&                JdJ          and
        .e @zk     m    }d           JdJ          d in ...
        .e @zk     m          xJY    JdJ          index of Y in J
        .e @zk     m        >J       JdJ          substring of J (from index to end)
        .e @zk     m       _         JdJ          reverse substring
        .e @zk     m             x_JYJdJ          index of Y in reversed J
        .e @zk     m      >          JdJ          substring of reversed (from index to end)
        .e @zk    s                   dJ       sum up the booleans (acts as any)
       s                                    sum up the chars and print

ดังนั้นสายการป้อนข้อมูลแรกคือสายการป้อนข้อมูลที่สองคือzJ

วนซ้ำทุกตัวอักษรJในลำดับที่เรียงและไม่ซ้ำกัน Hถ่านปัจจุบันเรียกว่า

แล้วสำหรับแต่ละYของJฉันพิมพ์ถ่านผู้สื่อข่าวของzหรือช่องว่างขึ้นอยู่กับถ้าทั้งสองเงื่อนไขต่อไปนี้มีความพึงพอใจ:

• Y <= H(อักขระตัวแรกปรากฏในบรรทัดH)
• มีถ่านd >= Hซึ่งจะปรากฏในบล็อกเริ่มต้นและลงท้ายด้วยY(วงเล็บ)

ตัวอย่าง

นี้แสดงให้เห็นว่าเส้นมาของอินพุตabcdaeb, abcdaebถูกพิมพ์ บรรทัดที่สี่เป็นการแสดงที่ดีเนื่องจากกรณีที่เป็นไปได้ส่วนใหญ่เกิดขึ้น:

code input:  "abcdaeb"
order input: "abcdaeb"

printing the fourth line, H = "d":

   "a" is printed, because "a" <= "d" and ("d" >= "d" and "d" is in "abcda")
   "b" is printed, because "b" <= "d" and ("d" >= "d" and "d" is in "bcdaeb")
   "c" are not printed, because neither "d" nor "e" (chars >= "d") are not in "c"
   "d" is printed, because "d" <= "d" and ("d" >= "d" and "d" is in "d")
   "a" is printed, because "a" <= "d" and ("d" >= "d" and "d" is in "abcda")
   "e" is not printed, because "e" > "d"
   "b" is printed, because "b" <= "d" and ("d" >= "d" and "d" is in "bcdaeb")

therefore the fourth line is: aabb__ddaa__bb

และอีกตัวอย่างหนึ่งจากกรณีทดสอบ @Optimizer ให้ฉัน (ซึ่งทำลาย 33 โซลูชั่นของฉัน)

code input:  "acab"
order input: "acab"

printing the second line, H = "b":

   "a" is printed, because "a" <= "b" and ("c" >= "b" and "c" is in "aca")
   "c" is not printed, because "c" > "b"
   "a" is printed, because "a" <= "b" and ("c" >= "b" and "c" is in "aca")
   "b" is printed, because "b" <= "b" and ("b" >= "b" and "b" is in "b")

therefore the second line is: a_ab

รุ่นเก่า: 58 57 52 ไบต์

JwKNFHS{J=K.e?eS>_>JxJHx_JHqYH@KkJs.e?@zknYNdK=KXKHN

ลองใช้งานออนไลน์: Pyth Compiler / Executor

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

CJam, 82 ไบต์

ตอนนี้ค่อนข้างนานแล้วและฉันคิดว่าฉันสามารถโกนได้อีกไม่กี่ไบต์

leel:F]z::+F$_&\f{{W=1$=},\;}{]_{0f=_W=),\0=>Lf&Ra#)},F,S*\:+{~;1$L+:L;t}%oNo~}%];

ขั้นตอนวิธี

อัลกอริทึมพื้นฐานดังต่อไปนี้:

• leel:F]z::+ : จัดกลุ่มรหัสการจัดรูปแบบและดัชนีของอักขระแต่ละตัวพร้อมกัน
• F$_&\f{{W=1$=},\;}: จัดกลุ่ม Triplets ด้านบนให้เป็นลำดับความสำคัญของการพิมพ์โดยใช้สตริงการจัดรูปแบบ รหัสนี้ยังทำให้แน่ใจว่ามีการเรียงลำดับความสำคัญ
• ]_{0f=_W=),\0=>Lf&Ra#)},: สำหรับแต่ละกลุ่มลำดับความสำคัญของ triplets ให้รับช่วงดัชนีขอบเขตและดูว่าดัชนีใดที่ยังไม่ได้พิมพ์ หากมีดัชนีที่ไม่ได้พิมพ์ให้รวมกลุ่มลำดับความสำคัญนี้ลงในกลุ่ม "ที่จะพิมพ์ในขั้นตอนนี้"
• F,S*\:+{~;1$L+:L;t}%oNo~}%: หลังจากได้รับกลุ่มทั้งหมดที่จะพิมพ์ในขั้นตอนนี้ให้กรอกรหัสลงในดัชนีที่ถูกต้องของสตริงที่ว่างแล้วพิมพ์สตริงนั้น อัพเดตอาร์เรย์ที่มีรายการดัชนีที่พิมพ์ด้วย

คำอธิบายเกี่ยวกับโค้ดที่ต้องติดตามเมื่อฉันเล่นกอล์ฟเสร็จ

ตัวอย่าง

นี่คือโค้ดที่รันบนโค้ดเอง:

การป้อนข้อมูล:

leel:F]z::+F$_&\f{{W=1$=},\;}{]_{0f=_W=),\0=>Lf&Ra#)},F,S*\:+{~;1$L+:L;t}%oNo~}%];
aaabbbcccccdddddeefgghhiffggejkklmmmnoooopppqrrrssssllttttuuuvwwxxxxxxxyvvzzzzjjjj

เอาท์พุท:

lee                                                                               
   l:F                                                                            
      ]z::+                                                                       
           F$_&\                                                                  
                f{          }                                                     
                f{{     },  }                                                     
                f{{W=   },\;}                                                     
                f{{W=1$ },\;}                                                     
                f{{W=  =},\;}                                                     
                             {                                                }%];
                             {]_                                              }%];
                             {  {                   },                        }%];
                             {  {0f=                },                        }%];
                             {  {   _               },                        }%];
                             {  {    W=),           },                        }%];
                             {  {        \0=        },                        }%];
                             {  {           >       },                        }%];
                             {  {            Lf&    },                        }%];
                             {  {               Ra#)},                        }%];
                             {                        F,S*                    }%];
                             {                            \:+                 }%];
                             {                               {          }%    }%];
                             {                               {~;        }%    }%];
                             {                               {  1$L+:L; }%    }%];
                             {                               {         t}%    }%];
                             {                                            oNo~}%];

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

CJam, 48 ไบต์

ll:i:T.{___T#TW%@#~T<>+:e>)1$-@*123Se]m>}z_|(;N*

คำอธิบาย

l                                                Code.
 l                                               Priority.
  :i                                             Convert priority to integer.
    :T                                           Save to T.
      .{                                }        For corresponding items:
      .{___                             }        Copy the current priority 3 times.
      .{   T#                           }        First position with this priority.
      .{     TW%                        }        Reverse T.
      .{        @#                      }        First (last) position with this priority.
      .{          ~T<                   }        Cut T at the end of this priority.
      .{             >                  }        Cut at the beginning of this priority.
      .{              +                 }        Insert the current priority to
                                                 prevent the array being empty.
      .{               :e>              }        Array maximum.
      .{                  )1$-          }        Count of integers between the current
                                                 priority and the maximum, inclusive.
      .{                      @*        }        That number of the current character.
      .{                        123Se]  }        Fill irrelevant priorities with spaces.
      .{                              m>}        Rotate the array to make non-spaces
                                                 starting at the current priority.
                                                 Returns a column containing 123 items.
                                         z       Zip to get the rows from columns.
                                          _|     Remove duplicate rows, including
                                                 unused priorities and all-space rows.
                                            (;   Remove the first row (an all-space row).
                                              N* Insert newlines.

IDL 8.4, 316 318 304 ไบต์

เวอร์ชันใหม่ยังคงยาวเกินไป แต่สั้นกว่า! และด้วยจิตวิญญาณที่แท้จริงของ IDL, vectorized อย่างสมบูรณ์ซึ่งหมายความว่า (เนื่องจากไม่มีการวนซ้ำ) ที่ตอนนี้ฉันสามารถทำมันเป็นหนึ่งบรรทัดและรันด้วยตัวเองเมื่อฉันได้รับการอัพเกรดเป็นเวอร์ชั่น 8.4 อย่างสมบูรณ์ จะมีการแก้ไขในภายหลัง

รุ่นหนึ่งบรรทัด:

c=(f='')&read,c,f&l=[0:strlen(f)-1]&c=strmid(c,l,1)&s=strmid(f,l,1)&u=s.uniq()&k=value_locate(u,s)&n=[0:max(k)]&d=hash(n,u.map(lambda(x,y,z:max(z[(r=stregex(y,'('+x+'(.*))?'+x,len=w)):r+w-1])),f,k))&print,n.map(lambda(n,l,c,d,i:i.reduce(lambda(x,i,l,c,d,n:x+(d[l[i]]ge n?c[i]:' ')),l,c,d,n)),k,c,d,l)&end

ด้วยการขึ้นบรรทัดใหม่ (จำนวนไบต์เดียวกัน, การ subbing \ n vs &), และแสดงความคิดเห็น:

c=(f='') ;initialize code and format as strings
read,c,f ;read two lines of input from the prompt
l=[0:strlen(f)-1] ;index array for the strings
c=strmid(c,l,1) ;split the code string into an array, via substrings of length 1
s=strmid(f,l,1) ;same for the format string, saving f for regex later
u=s.uniq() ;get the sorted unique values in the format string (sorts A->a)
k=value_locate(u,s) ;assign layer values to the format characters
n=[0:max(k)] ;index array for the unique format characters
d=hash(n,u.map(lambda(x,y,z:max(z[(r=stregex(y,'('+x+'(.*))?'+x,len=w)):r+w-1])),f,k))
print,n.map(lambda(n,l,c,d,i:i.reduce(lambda(x,i,l,c,d,n:x+(d[l[i]]ge n?c[i]:' ')),l,c,d,n)),k,c,d,l)
end ;end the script

นี่คือการแบ่งอัลกอริทึมสำหรับบรรทัด 9:

r=stregex(y,'('+x+'(.*))?'+x,len=w) ; r, w = starting position & length of substring in y {format string} bracketed by x {character} (inclusive)
z[(r=...):r+w-1] ; grab a slice of z {layer array} from r to r+w-1 -> layer values for each character in the substring
max(z[...]) ; max layer (depth) of any characters in that slice
u.map(lambda(x,y,z:max(...)),f,k) ;map an inline function of the above to every element of the unique-formatting-character array
d=hash(n,u.map(...)) ; create a hash using the unique indices, the result is a hash of (character:max_substring_depth)

... และ 10:

x+(d[l[i]]ge n?c[i]:' ')) ; ternary concatenation: if maxdepth for this character >= current depth, add the character, otherwise add ' '
i.reduce(lambda(x,i,c,d,l,n:...)),,l,c,d,n) ;accumulate elements of i {code/format index array} by passing them through the inline ternary concatenation function
print,n.map(lambda(n,l,c,d,i:i.reduce(...)),k,c,d,l) ;map the depth index through the reduction, ending up with a string for each depth layer, then print it

บรรทัดที่ 9 และ 10 ทำงานได้จริงส่วนที่เหลือจะตั้งค่าตัวแปรที่คุณต้องการในตอนท้าย ฉันคิดว่านี่เป็นเรื่องเกี่ยวกับการเล่นกอล์ฟตามที่จะได้รับฉันไม่สามารถหาที่อื่นให้ทำได้ดีกว่านี้

รุ่นเก่า (ทุกอย่างด้านล่างนี้ล้าสมัยแล้ว):

มันไม่มีที่ไหนใกล้พอที่จะชนะเพราะนี่เป็นภาษากอล์ฟที่แย่มาก แต่ไม่มีใครตอบใน IDL เลยดังนั้นฉันจะไปหามัน

a=(b='')
read,a,b
c=[0:strlen(b)-1]
d=strmid(b,c,1)
a=strmid(a,c,1)
e=d[uniq(d,sort(d))]
f=list(value_locate(e,d),/e)
s=hash()
for i=0,max(f)do begin
g=stregex(b,'('+e[i]+'(.*))?'+e[i],l=l)
s[i]=max(f[g:g+l-1])
print,f.reduce(lambda(x,y,z:x+(s.haskey(y)?z[y]:' '),s,a)
s=s.filter(lambda(x,y:x[1]gt y),i)
endfor
end

ฉันไม่แน่ใจว่ามีวิธีใดที่ฉันสามารถลดมันได้มากกว่านี้ ... ฉันสามารถเรียก strmid ทั้ง a และ b ในเวลาเดียวกัน แต่จากนั้นฉันก็ใช้การจัดทำดัชนีไบต์เพิ่มขึ้น d และมันก็ทำงานเหมือนเดิม ฉันจะพยายามต่อไปเรื่อย ๆ ! (และพรุ่งนี้ฉันจะแก้ไขด้วยคำอธิบายของอัลกอริทึม)