성공적인 코드 골프 제출은 본질적으로 모든 곳에서 미친 상징으로 가득 차 있습니다. 제출을 이해하기 쉽도록 많은 코드 골퍼는 코드에 대한 설명을 포함하도록 선택합니다. 그들의 설명에서, 코드 라인은 수직 분해 다이어그램으로 바뀝니다.

예를 들어, 이것이 내 코드 인 경우 :

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

내가 만들 수있는 많은 가능한 다이어그램 중 하나는 다음과 같습니다.

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

목표

이 과제에서는 코드 한 줄을 사용하고 설명 텍스트를 쉽게 추가 할 수있는 다이어그램을 만드는 설명 자동 서식 도구를 작성합니다.

이를보다 유용한 과제 로 만들기 위해 사용자는 형식화 문자열을 제공하여 각 행의 내용을 지정할 수 있습니다. 형식화 문자열은 문자 만 포함하는 두 번째 행 A-Za-z으로, 프로그램과 길이가 같습니다. 문자는 설명에서 프로그램의 문자가 인쇄되는 순서를 나타냅니다.

다음은 괄호와 같은 형식이없는 I / O의 예입니다 .

123423
AabcBC

1     
    2 
     3
 2    
  3   
   4  

브라켓

프로그램에서 둘 이상의 문자가 동일한 우선 순위 레벨을 갖는 경우, 해당 문자 세트는 단일 코드 블록 (그룹을 구성하는 경우) 또는 대괄호 세트 (중간에 다른 문자를 포함하는 경우)로 작동합니다. 일반적인 규칙은 간단합니다.

1. 우선 순위가 더 높은 다른 모든 문자가 이미 다이어그램에서 위의 행에 나타날 때까지 문자는 다이어그램의 행에 나타나지 않습니다.

2. 우선 순위가 같은 문자는 항상 같은 줄에 인쇄됩니다. 특정 문자가 줄에 나타나면 우선 순위가 같은 다른 모든 문자가 줄에 나타납니다.

3. 그와 같이 묶인 다른 모든 문자가 적어도 한 번 나타날 때까지 우선 순위가 동일한 문자 세트가 각 행에 계속 나타납니다. 이것은 "브래킷 같은"구조를 허용합니다. 경우 bceab우선 순위이며, 다음 b문자는 (그들은 두 번째로 높은 우선 순위) 두 번째 줄에 표시되고 모든 때까지 계속 나타납니다 cea문자가 나타났다. 우선 순위 문자열이 abcadeafga인 경우 모든 문자열이 그 bcdefg안에 포함 된 것으로 간주되며, 4가 모두 a표시 될 때까지 계속 나타납니다 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

다음은 Martin Bü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.

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이고 두 번째 입력 라인은 J입니다.

루프는 모든 문자를 J정렬 된 순서로 반복 없이 반복합니다. 현재 문자를이라고 H합니다.

그런 다음 각각 Y의 JI의 대응 문자 인쇄 z다음 조건이 모두 충족되는 경우에 따라, 또는 공백 :

• Y <= H(문자가 먼저 줄에 나타납니다 H)
• (괄호)로 d >= H시작하고 끝나는 블록에 나타나는 char이 Y있습니다.

예

입력의 전후 라인이 어떻게 프로그램 abcdaeb, abcdaeb인쇄된다. 네 번째 줄은 가능한 대부분의 경우가 발생하기 때문에 좋은 표현입니다.

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

마스크를 만들어 각 줄을 인쇄하기 전후에 수정합니다. 자세한 내용은 편집 기록을 참조하십시오.

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~}%];

여기에서 온라인으로 사용해보십시오

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.

IDL 8.4, 316 318 304 바이트

새 버전이지만 여전히 길지만 짧습니다! 그리고 IDL의 진정한 정신으로 완전히 벡터화되었으므로 (루프가 없기 때문에) 이제 한 줄로 수행하고 버전을 8.4로 완전히 업그레이드하면 자체적으로 실행할 수 있습니다. 나중에 편집 할 것입니다.

한 줄 버전 :

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를 색인화하는 데 더 많은 바이트를 소비하고 동일하게 작동합니다. 그래도 계속 노력하겠습니다! (내일은 알고리즘에 대한 설명으로 편집하겠습니다.)