Pyth belki de en başarılı genel amaçlı golf dilidir. Daha yeni diller sonucunda bir şekilde düşüş gösterse de, 2014'ten 2016'ya kadar Pyth'in özlü sözdizimi, sürekli güncellemeler, aşırı yükleme ve (dönemi için) birçok yerleşik, soruların çoğunluğu için bir favori haline getirdi.

Pyth kodunu okumak genellikle zordur. Hata ayıklama modunun (aktarılan Python) çıktısı bile, bazen on derinlikte iç içe parantez içeren uzun bir çizgiden oluşur. Ancak, doğru biçimlendirilmiş Pyth çok okunabilir.

İşte Word Zinciri'nde @isaacg tarafından yazılmış bir parça Pyth kodu .

.MlZfqhMtTeMPT+Lzs.pMyQ

Bunun gibi çok daha okunabilir.

.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

Bu zorluk için, Pyth karakterlerini kategorize etmenin kolmogorov-karmaşıklık yönünü ortadan kaldırıyoruz ve biçimlendirmeye odaklanıyoruz. Pyth kodu olmak yerine, girdi içindeki karakterlerden oluşacaktır 0123456789M. Rakam n, bir arity fonksiyonunu nve Mbir operatörü temsil eder. Örneğin, yukarıdaki kod olarak temsil edilir 210221M101M102M011M10. Sesi kaldırmak için gereken adımlar şunlardır:

Dizeyi belirteçlere ayırın.

Bir token eşleşir [0-9]M*. 0Mgirişte gerçekleşmez.

Sondaki 0'ları ekleyin.

Yeterli bağımsız değişken olmadığında, Pyth Qkoda programın bağımsız değişkenlerini doldurmak için gereken sayıda kapalı değişken (lambda değişkeni veya s) ekler ; bunlar 0s ile temsil edilmelidir .

Grupları satırlar halinde gruplandırın.

Bir token'ın rakamı, rakamının değeridir.

• Bir arity-0 jetonu (yani bir 0) bir çizgiyi bitirir.

• Bir arity-1 jetonu için, bir sonraki jeton boşlukla ayrılmış olarak aynı satıra gitmelidir.

• Bir arity> = 2 belirteci için, argümanları kodda göründükleri sırayla, her biri kendi alt argümanları vb. İle ayrı satırlara gider. Bir jetonla ilgili bağımsız değişkenler, jetonun sonuna ve bir boşluk içine girintilenir.

Giriş

Alt dizeyi 0123456789Miçermeyen, içermeyen, boş olmayan bir dize (veya char dizisi, uzunluk-1 dizelerinin dizisi vb.) 0M.

Çıktı

Yukarıdaki kurallara göre biçimlendirilmiş dize.

Test senaryoları

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 bayt

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

Çevrimiçi deneyin!

Yorumlananlar

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
  )                            //

Haskell , 192 190 187 bayt

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

Çevrimiçi deneyin!

Arity-1 vakasını ele almanın daha iyi bir yolu olmalı, şu anda 45 bayt sürüyor.

Düzenlemeler:

• Farklı bir işleme yöntemine 1 geçerek -2 bayt olsa da, önceki yöntem muhtemelen daha fazla optimizasyon potansiyeline sahiptir.
• Karakter sayılarını sayılara dönüştürmemek ve predyerine kullanmak yerine -3 bayt 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

Çevrimiçi deneyin!

Kömür , 75 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

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

Giriş karakterlerinin üzerine gelin ve isteğe bağlı Msonekleri olan bir basamak listesine dönüştürün .

≔⮌υυ

Tüketmek için kullanabileceğimiz Popşekilde bu listeyi tersine çevirin .

≔⟦⟧θ

Bu değişken, henüz güvenliği sağlanamayan bir token yığınıdır.

≔⟦⟧η

Bu değişken, yerine getirilmeyen tokenlerin kalan artejeninin bir yığınını oluşturur.

Ｗ∨υη«

Tüm jetonları tüketip yığını boşalana kadar tekrarlayın.

     ≔⎇υ⊟υ0ι

Bir sonraki jetonu al veya 0yoksa.

     ι¿⊖Σι↘→

Simgeyi yazdırın ve ardından 1çapraz olarak başlıyorsa imleci yatay olarak hareket ettirin .

     ⊞θι⊞ηΣι

Belirteci ve değişkenini uygun değişkenlere ekleyin.

     Ｗ∧η¬§η±¹«

Arity yığıtı boşken, üst atarite sıfırken tekrarlayın.

              ⊟η

Sıfır kaynağı atın.

              Ｍ⊕Ｌ⊟θ←

Simgesini kaldırın ve o kadar çok karakter taşıyın.

              ¿η⊞η⊖⊟η

Kalan herhangi bir varlık varsa, o zaman üst dünyayı azaltın.