Các bản đệ trình mã golf thành công, về bản chất, chứa đầy các biểu tượng điên rồ khắp nơi. Để làm cho trình của họ dễ hiểu hơn, nhiều người chơi golf chọn cách đưa ra lời giải thích về mã của họ. Theo giải thích của họ, dòng mã được biến thành sơ đồ nổ theo chiều dọc.

Ví dụ: nếu đây là mã của tôi:

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

Một trong nhiều sơ đồ có thể tôi có thể tạo sẽ trông như thế này:

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

Mục đích

Trong thử thách này, bạn sẽ viết một công cụ định dạng tự động giải thích, lấy một dòng mã và tạo một sơ đồ để có thể dễ dàng thêm văn bản giải thích.

Để làm cho điều này trở thành một thách thức hữu ích hơn , người dùng sẽ có thể chỉ định nội dung của từng dòng, bằng cách cung cấp một chuỗi định dạng. Chuỗi định dạng sẽ là một dòng thứ hai, chỉ chứa các chữ cái A-Za-z, có cùng độ dài với chương trình. Các chữ cái hiển thị thứ tự mà các ký tự của chương trình sẽ được in trong phần giải thích.

Dưới đây là một ví dụ về I / O mà không có bất kỳ định dạng giống như ngoặc :

123423
AabcBC

1     
    2 
     3
 2    
  3   
   4  

Chân đế

Nếu có nhiều hơn một ký tự trong chương trình có cùng mức ưu tiên, thì bộ ký tự đó đóng vai trò là một khối mã duy nhất (nếu chúng tạo thành một nhóm) hoặc một bộ dấu ngoặc (nếu chúng chứa các ký tự khác ở giữa). Các quy tắc chung rất đơn giản:

1. Các ký tự không xuất hiện trong một dòng của sơ đồ cho đến khi tất cả các ký tự có mức độ ưu tiên cao hơn đã xuất hiện trên các dòng trên nó trong sơ đồ.

2. Các ký tự có mức độ ưu tiên như nhau luôn được in trên cùng một dòng. Nếu một ký tự nhất định xuất hiện trên một dòng, tất cả các ký tự khác có mức độ ưu tiên như nhau sẽ xuất hiện trên dòng đó.

3. Một tập hợp các ký tự có mức độ ưu tiên như nhau tiếp tục xuất hiện trên mỗi dòng cho đến khi tất cả các ký tự khác được bao quanh bởi nó đã xuất hiện ít nhất một lần. Điều này cho phép các công trình "giống như khung". Nếu bceablà các ưu tiên, thì các bký tự sẽ xuất hiện trên dòng thứ hai (chúng là ưu tiên cao thứ hai) và sẽ tiếp tục xuất hiện cho đến khi tất cả các ceaký tự xuất hiện. Nếu chuỗi ưu tiên là abcadeafga, thì tất cả bcdefgđược coi là chứa trong chuỗi đó, tất cả 4 agiây sẽ tiếp tục xuất hiện cho đến khi gxuất hiện.

Yêu cầu định dạng khác

Tất cả các dòng đầu ra phải có cùng độ dài (chiều dài của các dòng đầu vào), được đệm bằng các khoảng trắng khi cần thiết. Dòng chương trình đầu vào có thể chứa khoảng trắng, mặc dù các khoảng trắng đó cũng sẽ được đặt một chữ cái ưu tiên. Trailing newlines trên đầu ra / đầu vào là tùy chọn.

Chấm điểm

Đây là mã golf, ít byte thắng nhất.

Ví dụ

Dưới đây là một ví dụ nhận xét về một đoạn mã với định dạng phức tạp hơn.

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

Một ví dụ trong Perl:

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

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

Dưới đây là một vài ví dụ ở CJam, với sự giúp đỡ của 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$}*}/

Đây là một ví dụ điên rồ chỉ để gây rối với bạn:

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

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

Dưới đây là một ví dụ rõ ràng hơn về những gì xảy ra khi dấu ngoặc trùng nhau abab. (Thông thường, đây không phải là cách bạn sẽ chọn để định dạng lời giải thích của mình.)

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.

Bình thường, 33 40 byte

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

Dùng thử trực tuyến: Trình biên dịch / thực thi Pyth

Giải trình:

Được tạo bằng chuỗi 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

Vì vậy, dòng đầu vào là z, dòng đầu vào thứ hai là J.

Vòng lặp lặp trên tất cả các ký tự Jtheo thứ tự được sắp xếp và không trùng lặp. Char hiện tại được gọi H.

Sau đó, cho mỗi Ycủa Jtôi in các char phóng viên của zhoặc một khoảng trắng, tùy thuộc vào nếu cả hai điều kiện sau đây được thỏa mãn:

• Y <= H(một char đầu tiên xuất hiện trong dòng H)
• có một char d >= H, xuất hiện trong một khối bắt đầu và kết thúc bằng Y(ngoặc).

Ví dụ

Điều này cho thấy dòng thứ tư của đầu vào abcdaeb, abcdaebđược in như thế nào . Dòng thứ tư là một đại diện tốt, vì hầu hết các trường hợp có thể xảy ra:

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

Và một ví dụ khác dựa trên trường hợp thử nghiệm, @Optimizer đã cho tôi. (đã phá hủy giải pháp 33 của tôi).

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

Phiên bản cũ: 58 57 52 byte

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

Dùng thử trực tuyến: Trình biên dịch / thực thi Pyth

Điều này tạo ra một mặt nạ, mà tôi sẽ sửa đổi trước và sau khi in từng dòng. Để biết thêm thông tin xem lịch sử chỉnh sửa.

CJam, 82 byte

Khá lâu hiện tại và tôi nghĩ rằng tôi có thể cạo thêm một vài byte.

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

Thuật toán

Thuật toán cơ bản như sau:

• leel:F]z::+ : Nhóm mã, định dạng và chỉ mục của từng ký tự với nhau
• F$_&\f{{W=1$=},\;}: Nhóm các bộ ba trên thành ưu tiên in bằng chuỗi định dạng. Mã này cũng đảm bảo rằng các ưu tiên được sắp xếp.
• ]_{0f=_W=),\0=>Lf&Ra#)},: Đối với mỗi nhóm bộ ba ưu tiên, hãy lấy phạm vi chỉ mục giới hạn và xem có chỉ mục nào chưa được in không. Nếu có một chỉ mục chưa được in, hãy đưa nhóm ưu tiên này vào nhóm "sẽ được in trong bước này".
• F,S*\:+{~;1$L+:L;t}%oNo~}%: Sau khi nhận được tất cả các nhóm được in trong bước này, hãy điền mã vào chỉ mục chính xác của chuỗi không gian trống và sau đó in chuỗi đó. Cũng cập nhật mảng chứa danh sách các chỉ mục được in.

Giải thích mã được tuân theo khi tôi chơi golf này.

Thí dụ

Đây là mã chạy trên chính mã:

Đầu vào:

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

Đầu ra:

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~}%];

Dùng thử trực tuyến tại đây

CJam, 48 byte

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

Giải trình

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 byte

Phiên bản mới, vẫn còn quá dài, nhưng ngắn hơn! Và, theo tinh thần thực sự của IDL, được vector hóa hoàn toàn, điều đó có nghĩa là (vì không có vòng lặp) mà bây giờ tôi có thể thực hiện dưới dạng một dòng và tự chạy nó, khi tôi nâng cấp phiên bản của mình lên 8.4. Điều đó sẽ được chỉnh sửa sau.

Phiên bản một dòng:

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

Với các ngắt dòng (cùng số byte, thay thế \ n vs &) và nhận xét:

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

Đây là một sự cố thuật toán cho dòng 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)

... và 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

Dòng 9 và 10 thực hiện công việc thực tế, phần còn lại của nó thiết lập các biến bạn cần cho cuối. Tôi nghĩ rằng đây là về việc chơi golf như nó sẽ có được, tôi không thể tìm thấy bất cứ nơi nào khác để làm điều đó tốt hơn.

Phiên bản cũ (mọi thứ bên dưới ở đây đã hết hạn):

Đây không phải là nơi đủ ngắn để giành chiến thắng, bởi vì đây là một ngôn ngữ chơi golf tồi tệ, nhưng không ai trả lời bằng IDL vì vậy tôi sẽ đi theo nó.

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

Tôi không chắc có cách nào để tôi có thể cắt giảm nhiều hơn không ... Tôi có thể gọi strmid trên cả a và b cùng một lúc, nhưng sau đó tôi dành nhiều byte hơn để lập chỉ mục d và nó hoạt động như nhau. Tôi sẽ tiếp tục làm việc với nó, mặc dù! (Và ngày mai tôi sẽ chỉnh sửa phần giải thích thuật toán.)