Вдале подання коду для гольфу за своєю природою повсюдно наповнене шаленими символами. Щоб зробити їх подання простішим для розуміння, багато гравців із кодом вирішили включити пояснення свого коду. У їхньому поясненні рядок коду перетворюється на вертикально підірвану діаграму.

Наприклад, якщо це мій код:

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

Один із безлічі можливих діаграм, які я міг би створити, виглядав би так:

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

Мета

У цьому виклику ви напишете інструмент автоматичного форматування пояснень, який бере рядок коду та створює схему, до якої легко можна додати пояснювальний текст.

Для того, щоб зробити це більш корисним завданням, користувач зможе вказати вміст кожного рядка, надавши рядок форматування. Рядок форматування буде другим рядком, що містить лише літери A-Za-z, такої ж довжини, що і програма. Букви показують порядок, в якому символи програми повинні бути надруковані в поясненні.

Ось приклад вводу-виводу без форматування, подібного до дужок :

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

Ось кілька прикладів 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

Пояснення:

Створено за допомогою рядка 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з них Jя надрукую відповідну таблицю zабо пробіл, залежно від того, чи виконуються обидві наступні умови:

• Y <= H(в рядку вперше з’являється значок H)
• є знак d >= H, який з’являється в блоці, що починається і закінчується 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

Це створить маску, яку я зміню до і після друку кожного рядка. Для отримання додаткової інформації дивіться історію редагування.

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

Я не впевнений, чи є якийсь спосіб, щоб я його більше скоротив ... Я міг би викликати strmid одночасно на a і b, але потім витрачаю більше байтів, що індексують d, і це працює так само. Я продовжую працювати над цим, хоча! (А завтра я відредагую в поясненні алгоритму.)