32

成功したコードゴルフの提出は、本質的に、至る所に狂ったシンボルで満たされています。投稿を理解しやすくするために、多くのコード愛好家は自分のコードの説明を含めることを選択します。彼らの説明では、コードの行は垂直分解図に変わります。

たとえば、これが私のコードだった場合：

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

作成できる多くの図の1つは次のようになります。

目標

この課題では、コードの行を取得し、説明テキストを簡単に追加できるダイアグラムを作成する説明自動フォーマットツールを作成します。

これをより便利な課題にするために、ユーザーはフォーマット文字列を提供することにより、各行の内容を指定できます。書式設定文字列は、文字のみを含む2行目でA-Za-z、プログラムと同じ長さです。文字は、説明の中でプログラムの文字を印刷する順序を示しています。

以下は、ブラケットのような書式設定のない I / Oの例です。

ブラケット

プログラム内の複数の文字が同じ優先度レベルを持っている場合、その文字セットはコードの単一ブロック（グループを形成する場合）またはブラケットセット（それらが間に他の文字を含む場合）として機能します。一般的なルールは簡単です：

優先順位の高い他のすべての文字が図のその上の行に既に表示されるまで、文字は図の行に表示されません。
同じ優先順位の文字は常に同じ行に印刷されます。特定の文字が行に表示される場合、同じ優先順位の他のすべての文字が行に表示されます。
同じ優先順位の文字のセットは、それに囲まれた他のすべての文字が少なくとも1回現れるまで、各行に現れ続けます。これにより、「ブラケットのような」構造が可能になります。bceab優先度がある場合、b文字は2行目に表示され（2番目に高い優先度です）、すべてのcea文字が表示されるまで表示され続けます。優先度文字列がabcadeafgaである場合、すべてがその中にbcdefg含まれていると見なされ、4 aが出現するまで4 がすべて表示され続け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

以下は、MartinBüttnerの好意によるCJamの例です。

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.

code-golf whitespace balanced-string

— PhiNotPi
ソース

14

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

したがって、最初の入力行はz、2番目の入力行はJです。

ループはJ、ソートされた順序で、重複なしにすべての文字を繰り返し処理します。現在の文字が呼び出されますHます。

次に、次の条件の両方が満たされるかどうかに応じて、それぞれYのJ対応する文字zまたは空白を印刷します：

Y <= H （文字が最初に行に表示されます H）
charがありd >= H、それはY（括弧）で始まりブロックで終わるブロックに現れます。

例

入力の前後ラインがどのようにこのショーabcdaeb、abcdaeb印刷されます。考えられるケースのほとんどが発生するため、4行目は適切な表現です。

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

これによりマスクが作成され、各行を印刷する前後に変更します。詳細については、編集履歴を参照してください。

— ジャクベ
ソース

8

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$=},\;}：上記のトリプレットを、フォーマット文字列を使用して印刷の優先度にグループ化します。また、このコードにより、優先順位が確実にソートされます。
]_{0f=_W=),\0=>Lf&Ra#)},：トリプレットの優先度グループごとに、境界インデックス範囲を取得し、まだ印刷されていないインデックスがあるかどうかを確認します。未印刷のインデックスがある場合、この優先度グループを「このステップで印刷される」グループに含めます。
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~}%];

こちらからオンラインでお試しください

— オプティマイザ
ソース

oNo置き換えることが可能nでTIO。

— エソランジングフルーツ

8

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.

— ジミー23013
ソース

6

IDL 8.4、316の 318 304バイト

新しいバージョン、まだ長すぎますが、短い！そして、IDLの真の精神では、完全にベクトル化されています。つまり、バージョンが8.4に完全にアップグレードされると、（forループがないため）1行で実行し、それ自体で実行できるようになります。後で編集します。

1行バージョン：

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

改行あり（同じバイト数、\ 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

もっと削減できる方法があるかどうかはわかりません... aとbの両方でstrmidを同時に呼び出すことができますが、dのインデックス付けにさらにバイトを費やすと、同じように動作します。しかし、私はそれに取り組んでいきます！（そして明日、アルゴリズムの説明で編集します。）

— サーパーシバル
ソース

コード説明フォーマッター