Pyth는 아마도 가장 성공적인 범용 골프 언어 일 것입니다. 2014 년부터 2016 년까지는 새로운 언어의 결과로 다소 감소 했지만 , Pyth의 간결한 구문, 지속적인 업데이트, 과부하 및 (기존에는) 많은 내장이 대부분의 질문에서 선호되었습니다.

Pyth 코드는 종종 읽기가 어렵습니다. 디버그 모드 (번역 된 Python)의 출력조차도 종종 긴 줄로 구성되며 때로는 괄호가 10 개 깊이로 중첩되어 있습니다. 그러나 올바른 형식의 Pyth는 매우 읽기 쉽습니다.

다음은 @isaacg가 Play the Word Chain 에서 작성한 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 문자 분류의 복잡성 측면을 없애고 형식 지정에 중점을 둡니다. Pyth 코드 대신 입력은의 문자로 구성됩니다 0123456789M. 디지트는 n인수에 대응하는 기능을 나타내며 n, 및 M연산자를 나타낸다. 예를 들어 위 코드는로 표시됩니다 210221M101M102M011M10. 최소화하는 단계는 다음과 같습니다.

문자열을 토큰으로 분리하십시오.

토큰이 일치 [0-9]M*합니다. 0M입력에서 발생하지 않습니다.

후행 0을 추가하십시오.

인수가 충분하지 않은 경우 Pyth는 Q프로그램의 인수를 채우는 데 필요한만큼 암시 적 변수 (람다 변수 또는 s)를 코드에 추가합니다. 이들은 0s 로 표시되어야합니다 .

토큰을 줄로 묶습니다.

토큰의 arity는 숫자의 가치입니다.

• arity-0 토큰 (즉, 0)은 라인을 종료합니다.

• arity-1 토큰의 경우 다음 토큰은 공백으로 구분 된 동일한 행에 있어야합니다.

• arity> = 2 토큰의 경우, 인수는 코드에 표시되는 순서대로 개별 행에 표시되며 각 인수는 자체 하위 인수 등이 뒤 따릅니다. 토큰에 대한 인수는 해당 토큰의 끝과 한 칸의 공백으로 들여 쓰기됩니다.

입력

비어 있지 않은 문자열 (또는 표준 I / O 방법에서 허용하는 문자 배열, 길이 1 문자열 배열 등) 0123456789M은 하위 문자열을 포함하지 않는 로 구성 됩니다 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가 그것을 소비 하는 데 사용할 수 있도록이 목록 을 뒤집으십시오.

≔⟦⟧θ

이 변수는 arity가 아직 충족되지 않은 토큰 스택입니다.

≔⟦⟧η

이 변수는 완료되지 않은 토큰의 나머지 특성입니다.

Ｗ∨υη«

모든 토큰을 소비하고 스택을 비울 때까지 반복하십시오.

     ≔⎇υ⊟υ0ι

다음 토큰을 얻거나 0없으면.

     ι¿⊖Σι↘→

토큰을 인쇄 한 다음 1대각선으로 시작하면 커서를 가로로 움직 입니다.

     ⊞θι⊞ηΣι

토큰과 해당 변수를 적절한 변수에 추가하십시오.

     Ｗ∧η¬§η±¹«

arity 스택이 비어 있지 않지만 상단 arity가 0 인 동안 반복하십시오.

              ⊟η

무의식을 버린다.

              Ｍ⊕Ｌ⊟θ←

토큰을 제거하고 많은 문자를 왼쪽으로 이동하십시오.

              ¿η⊞η⊖⊟η

남은 자족이 있다면 최고 자손을 감소시킵니다.