Успешная подача кода в гольф по своей природе наполнена сумасшедшими символами повсюду. Чтобы облегчить понимание их представления, многие игроки в коде предпочитают включать объяснение своего кода. В их объяснении строка кода превращается в вертикально разнесенную диаграмму.

Например, если бы это был мой код:

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 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из них 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 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, полностью векторизовано, что означает (поскольку нет цикла for), что теперь я могу сделать это одной строкой и запустить саму себя, как только я полностью обновлю свою версию до 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 против &) и комментарий:

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, и это работает одинаково. Я буду продолжать работать над этим, хотя! (А завтра я отредактирую объяснение алгоритма.)