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

รหัส Pyth มักจะอ่านยาก แม้เอาต์พุตของโหมดดีบัก (transpiled Python) มักจะประกอบด้วยบรรทัดยาวบางครั้งมีวงเล็บซ้อนกันสิบลึก อย่างไรก็ตามการจัดรูปแบบ Pyth ในรูปแบบที่ถูกต้องสามารถอ่านได้มาก

นี่เป็นชิ้นส่วนของรหัส Pyth เขียนโดย @isaacg ในการเล่นห่วงโซ่ของ Word

.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

สำหรับความท้าทายนี้เราจะกำจัดความซับซ้อนของkolmogorovในการจัดหมวดหมู่อักขระPythและมุ่งเน้นที่การจัดรูปแบบ แทนที่จะเป็นรหัส Pyth 0123456789Mใส่จะประกอบด้วยตัวละครใน ตัวเลขnแสดงถึงฟังก์ชันของ arity nและMแสดงถึงโอเปอเรเตอร์ 210221M101M102M011M10ยกตัวอย่างเช่นโค้ดข้างต้นจะแสดงเป็น นี่คือขั้นตอนในการลดขนาด:

แยกสตริงออกเป็นโทเค็น

[0-9]M*ตรงกับโทเค็น 0Mจะไม่เกิดขึ้นในอินพุต

เพิ่ม 0 ต่อท้าย

เมื่อมีข้อโต้แย้งไม่เพียงพอ Pyth จะผนวกตัวแปรโดยนัย (ตัวแปรแลมบ์ดาหรือหลายตัวแปรQ) เข้ากับโค้ดเท่าที่จำเป็นเพื่อเติมอาร์กิวเมนต์ของโปรแกรม สิ่งเหล่านี้ควรถูกแทนด้วย0s

กลุ่มโทเค็นเป็นเส้น

โทเค็น arity คือค่าตัวเลข

• โทเค็น arity-0 (เช่น a 0) ลงท้ายด้วยบรรทัด

• สำหรับโทเค็น arity-1 โทเค็นถัดไปควรอยู่ในบรรทัดเดียวกันคั่นด้วยช่องว่าง

• สำหรับ arity> = 2 โทเค็นอาร์กิวเมนต์ของมันจะอยู่ในบรรทัดแยกตามลำดับที่ปรากฏในโค้ดแต่ละรายการตามด้วยอาร์กิวเมนต์ย่อยของตนเองและอื่น ๆ อาร์กิวเมนต์ของโทเค็นจะถูกเยื้องไปยังจุดสิ้นสุดของโทเค็นนั้นบวกหนึ่งช่องว่าง

อินพุต

สตริงว่าง (หรือแถวถ่านอาร์เรย์ของความยาว-1 สตริง ฯลฯ ได้รับอนุญาตโดยวิธีการมาตรฐาน I / O) ประกอบด้วยซึ่งจะไม่ประกอบด้วยอักขระย่อย0123456789M0M

เอาท์พุต

สตริงที่จัดรูปแบบตามกฎข้างต้น

กรณีทดสอบ

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

Haskell , 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 ไบต์

การแก้ไข:

• -2 ไบต์โดยสลับไปใช้วิธีการจัดการที่แตกต่างกัน 1 แม้ว่าวิธีก่อนหน้านี้อาจมีศักยภาพในการปรับให้เหมาะสมมากขึ้น
• -3 ไบต์โดยไม่แปลงตัวเลขตัวอักษรกับตัวเลขและการใช้แทนpredn-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เพื่อบริโภค

≔⟦⟧θ

ตัวแปรนี้เป็นสแต็กของโทเค็นที่ arity ยังไม่ได้ปฏิบัติตาม

≔⟦⟧η

ตัวแปรนี้เป็นสแต็กของ arity ที่เหลืออยู่ของโทเค็นที่ไม่ได้ผล

Ｗ∨υη«

ทำซ้ำจนกว่าเราจะใช้โทเค็นทั้งหมดและทำให้สแต็กหมด

     ≔⎇υ⊟υ0ι

รับโทเค็นถัดไปหรือ0หากไม่มี

     ι¿⊖Σι↘→

พิมพ์โทเค็นแล้วเลื่อนเคอร์เซอร์ในแนวนอนหากเริ่มต้นด้วย1แนวทแยงมุม

     ⊞θι⊞ηΣι

เพิ่มโทเค็นและ arity ให้กับตัวแปรที่เหมาะสม

     Ｗ∧η¬§η±¹«

ทำซ้ำในขณะที่ arity stack ไม่ว่างเปล่า แต่ arity บนสุดเป็นศูนย์

              ⊟η

ยกเลิก arity ศูนย์

              Ｍ⊕Ｌ⊟θ←

นำโทเค็นออกแล้วเลื่อนไปทางซ้ายของอักขระจำนวนมาก

              ¿η⊞η⊖⊟η

หากยังมี arities เหลืออยู่ให้ลดระดับ arity ด้านบนลง