Pythは、おそらく最も成功した汎用ゴルフ言語です。新しい言語の結果としてやや低下していますが、2014年から2016年にかけて、Pythの簡潔な構文、絶え間ない更新、オーバーロード、および（その時代から）多くのビルトインが大部分の質問でお気に入りになりました。

Pythコードは読みにくいことがよくあります。デバッグモード（Pythonのコンパイル済み）の出力でさえ、長い行で構成されていることが多く、場合によっては、括弧が10段ネストされています。ただし、正しくフォーマットされたPythは非常に読みやすくなっています。

Play the Word Chainの @isaacgによって書かれたPythコードの一部を次に示します。

.MlZfqhMtTeMPT+Lzs.pMyQ

このように読みやすくなっています。

.M                     Filter by gives-maximal-value of
   l Z                   lambda Z:length(Z) over
   f                     filter by (lambda T:
     q                     equal
       hM t T                head-map tail T
       eM P T                end-map Pop T)
     +L                    Append z to each element in
        z                        
        s .pM y Q            flattened permutations of each subset of Q

この課題では、Pythキャラクターを分類するkolmogorov-complexityの側面を排除し、フォーマットに焦点を当てます。Pythコードである代わりに、入力はの文字で構成され0123456789Mます。数字nはarityの関数を表し、演算子nをM表します。たとえば、上記のコードはとして表され210221M101M102M011M10ます。縮小する手順は次のとおりです。

文字列をトークンに分離します。

トークンが一致し[0-9]M*ます。0M入力では発生しません。

末尾に0を追加します。

十分な引数がない場合、PythはQプログラムの引数を埋めるのに必要な数の暗黙変数（ラムダ変数またはs）をコードに追加します。これらは0s で表される必要があります。

トークンを行にグループ化します。

トークンのアリティは、その数字の値です。

• arity-0トークン（つまり0）は行を終了します。

• arity-1トークンの場合、次のトークンはスペースで区切って同じ行に移動する必要があります。

• arity> = 2トークンの場合、引数はコードに表示される順序で別々の行に移動し、各引数の後にサブ引数などが続きます。トークンへの引数は、そのトークンの末尾にスペースを1つ追加してインデントされます。

入力

から成る空でない文字列（またはchar配列、長さ1の文字列の配列など）で構成さ0123456789Mれ、にはsubstringは含まれません0M。

出力

上記の規則に従ってフォーマットされた文字列。

テストケース

210221M101M102M011M10

2
  1 0
  2
    2
      1M 1 0
      1M 1 0
    2M
       0
       1 1M 1 0


123M4M

1 2
    3M
       4M
          0
          0
          0
          0
       0
       0
    0


2MM

2MM
    0
    0


11011100

1 1 0
1 1 1 0
0


9000000

9
  0
  0
  0
  0
  0
  0
  0
  0
  0

JavaScript（ES8）、160 159バイト

f=(s,a=[d=0,p=[1]])=>s.replace(/(.)M*/g,(s,c)=>(g=_=>a[d]?s+(P=p[d]-=c--&&~s.length,c?`
`.padEnd(P):' '):g(d--))(a[d]--,a[++d]=+c,p[d]=p[d-1]))+(d?f('0',a):'')

オンラインでお試しください！

コメント済み

f = (                          // f = recursive function taking:
  s,                           //   s   = input string
  a = [                        //   a[] = array holding the number of expected arguments
    d = 0,                     //   d   = current depth, initialized to 0
    p = [1]                    //   p[] = array holding the padding values
  ]                            //
) =>                           //
  s.replace(                   // search in s all substrings
    RegExp('(.)M*', 'g'),      // consisting of a digit followed by 0 to N 'M' characters
    (s, c) =>                  // for each substring s beginning with the digit c:
      ( g = _ =>               //   g = recursive function
          a[d] ?               //     if we're still expecting at least one argument at
                               //     this depth:
            s + (              //       append s
              P = p[d] -=      //       update the padding value P = p[d] for this depth:
                c-- &&         //         decrement c; unless c was equal to 0,
                ~s.length,     //         add the length of s + 1 to p[d]
              c ?              //       if c is not equal to 0 (i.e. was not equal to 1):
                `\n`.padEnd(P) //         append a linefeed followed by P - 1 spaces
              :                //       else:
                ' '            //         append a single space
            )                  //
          :                    //     else (all arguments have been processed):
            g(d--)             //       decrement the depth and call g again
      )(                       //   before the initial call to g:
        a[d]--,                //     decrement the number of arguments at depth d
        a[++d] = +c,           //     set the number of arguments for the next depth
        p[d] = p[d - 1]        //     set the padding value for the next depth,
      )                        //     using a copy of the previous depth
  ) + (                        // end of replace()
    d ?                        // if we're not back at depth 0:
      f('0', a)                //   do a recursive call to f with an extra '0'
    :                          // else:
      ''                       //   stop recursion
  )                            //

ハスケル、192の 190 187バイト

unlines.snd.f
f(n:r)|(m,t)<-span(>'9')r,(s,l)<-n#t=(s,n?((n:m):map((' '<$(n:n:m))++)l))
f e=(e,["0"])
'1'?(a:b:r)=(a++drop(length a)b):r
_?s=s
'0'#s=(s,[])
n#s|(r,l)<-f s=(l++)<$>pred n#r

オンラインでお試しください！

arity-1のケースを処理するより良い方法が必要です。現在は45バイトを使用しています。

編集：

• 1を処理する別の方法に切り替えることで-2バイト。ただし、以前の方法にはおそらく最適化の可能性があります。
• 文字の数字を数字に変換せず、pred代わりにを使用して、-3バイトn-1。

unlines.snd.f
f(n:r)|(m,t)<-span(>'9')r,(s,l)<-read[n]#t,w<-map((' '<$(n:n:m))++)=(s,last$((n:m):w l):[(n:m++' ':h):w t|n<'2',h:t<-[l]])
f e=(e,["0"])
0#s=(s,[])
n#s|(r,l)<-f s=(l++)<$>(n-1)#r

オンラインでお試しください！

炭、75バイト

ＦＳ⊞υ⎇⁼ιM⁺⊟υιι≔⮌υυ≔⟦⟧θ≔⟦⟧ηＷ∨υη«≔⎇υ⊟υ0ιι¿⊖Σι↘→⊞θι⊞ηΣιＷ∧η¬§η±¹«⊟ηＭ⊕Ｌ⊟θ←¿η⊞η⊖⊟η

オンラインでお試しください！リンクは、コードの詳細バージョンです。説明：

ＦＳ⊞υ⎇⁼ιM⁺⊟υιι

入力文字をループし、オプションのM接尾辞付きの数字のリストに変換します。

≔⮌υυ

このリストを逆にして、使用できるようにPopします。

≔⟦⟧θ

この変数は、アリティがまだ満たされていないトークンのスタックです。

≔⟦⟧η

この変数は、満たされていないトークンの残りのアリティのスタックです。

Ｗ∨υη«

すべてのトークンを消費し、スタックを空にするまで繰り返します。

     ≔⎇υ⊟υ0ι

次のトークンを取得するか0、トークンがない場合。

     ι¿⊖Σι↘→

トークンを印刷し、1それ以外の場合は斜めにカーソルを水平方向に移動します。

     ⊞θι⊞ηΣι

トークンとそのアリティを適切な変数に追加します。

     Ｗ∧η¬§η±¹«

アリティスタックが空ではないが、上部のアリティがゼロである間に繰り返します。

              ⊟η

ゼロアリティを破棄します。

              Ｍ⊕Ｌ⊟θ←

そのトークンを削除し、その数の文字を残します。

              ¿η⊞η⊖⊟η

アリティが残っている場合は、トップアリティをデクリメントします。