Фон

Програмісти LISP захопили світ! Дужки були оголошені священними символами, і відтепер вони можуть використовуватися лише в програмах LISP. Було вирішено, що дужки в літературних творах будуть замінені виносками, і ваше завдання автоматизувати це для спрощеного тексту Маркдаун.

Вхідні дані

Ваш вхід - це одна рядок, що містить алфавітні символи, пробіли та спеціальні символи ASCII ,.!?(). Він не буде містити нових рядків або цифр. Круглі дужки будуть правильно підібрані.

Вихід

Ви повинні перетворити кожну збірну пару круглих дужок у вхідному рядку у виноску. Це відбувається так:

1. Замініть першу відповідну пару круглих дужок і підрядку між ними на запущене число, яке починається з 1, загорнутий між тегами Markdown <sup>і </sup>.
2. Додайте до кінця рядка
   • два нових рядки,
   • тег Markdown <sub>,
   • число від кроку 1,
   • простір,
   • підрядок між дужками та
   • </sub>в цьому порядку закриваючий тег .
3. Якщо в рядку залишилися дужки, перейдіть до кроку 1.

Ваш вихід - це результат-рядок, можливо, з наступним рядком. Вам не доведеться реалізовувати цей точний алгоритм, якщо ваш результат правильний. Зауважте, що можуть бути вкладені дужки; у такому випадку у нас будуть виноски, які містять посилання на інші виноски. Підрядок між дужками також може бути порожнім. Дивіться приклади тестів нижче для прикладів.

Правила та підрахунок балів

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

Якщо ваша мова не підтримує десяткові числа ( кашель сітківки кашлю ), ви можете вказати нотатки виноски в іншій базі, включаючи двійкові чи одинарні; однак за використання одинакових цифр накладається штраф у розмірі + 20% .

Випробування

Вхід:

This input contains no parentheses.

Вихід:

This input contains no parentheses.

Вхід:

This has (some) parentheses (but not so many).

Вихід:

This has <sup>1</sup> parentheses <sup>2</sup>.

<sub>1 some</sub>

<sub>2 but not so many</sub>

Вхід:

This has (nested (deeply (or highly?) nested)) parentheses (and several groups).

Вихід:

This has <sup>1</sup> parentheses <sup>2</sup>.

<sub>1 nested <sup>3</sup></sub>

<sub>2 and several groups</sub>

<sub>3 deeply <sup>4</sup> nested</sub>

<sub>4 or highly?</sub>

Вхід:

Hmm()(()(,))  a()((trt)(v( (((((wut)))))(X)(Y)(Z) )!?!?!?!))oooooooo(oooo)oooo

Вихід:

Hmm<sup>1</sup><sup>2</sup>  a<sup>3</sup><sup>4</sup>oooooooo<sup>5</sup>oooo

<sub>1 </sub>

<sub>2 <sup>6</sup><sup>7</sup></sub>

<sub>3 </sub>

<sub>4 <sup>8</sup><sup>9</sup></sub>

<sub>5 oooo</sub>

<sub>6 </sub>

<sub>7 ,</sub>

<sub>8 trt</sub>

<sub>9 v<sup>10</sup>!?!?!?!</sub>

<sub>10  <sup>11</sup><sup>12</sup><sup>13</sup><sup>14</sup> </sub>

<sub>11 <sup>15</sup></sub>

<sub>12 X</sub>

<sub>13 Y</sub>

<sub>14 Z</sub>

<sub>15 <sup>16</sup></sub>

<sub>16 <sup>17</sup></sub>

<sub>17 <sup>18</sup></sub>

<sub>18 wut</sub>

Помітьте порожні рядки між виносками.

Perl, 81 75 72 байт

71 байт код + 1 байт аргументу командного рядка.

Потрібен Perl 5.10 або новіший (для рекурсивної підтримки регулярних виразів)

$i++;s#(\((((?1)|.)*?)\))(.*)#<sup>$i</sup>$4

<sub>$i $2</sub>#s&&redo

Використання:

perl -p entry.pl input.txt

Пояснення

-p Параметр буде надрукувати результат застосування поданих команд до вводу, уникаючи необхідності явного друку.

Регекс (\(((?1)|.)*?)\))шукає найвіддаленіший набір дужок з початку рядка. Коли це буде знайдено, ми виконуємо заміну, гарантуючи, що ми додаємо лише в самому кінці вводу (захоплюючи все до кінця використання вводу (.*)).

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

Emacs Lisp, 335 байт

Передмова. Ця відповідь і схема на даний момент є єдиними відповідями, офіційно санкціонованими як Могутньою Народною Республікою LISP, так і Церквою Emacs. Інші відповіді, коротші чи ні, вважаються загрозою миру. Зокрема, і з глибокою презирством до будь-якого неправдоподібного твердження про маккартизм, який спорадично чується від ворожих супротивників держави, ми отримуємо задоволення від усіх, хто має інформацію про реальну особистість анонімних авторів, які пишуть відповіді Nonlisp, звертатися до місцевого бюро. Нагадується, що кожен повинен витратити час на роздуми та проголошення відповідно до того, що він або вона глибоко вірить, що не загрожуватиме його майбутнім взаємодіям з офіційними представниками влади. Код - це дані. Дані - код.

(defun p()(let(b(cpt 0)n)(goto-char 0)(while(search-forward"("()t)(setf b(point)n(number-to-string(incf cpt)))(backward-char)(forward-sexp)(backward-char)(kill-region b(point))(delete-backward-char 1)(delete-forward-char 1)(insert "<sup>"n"</sup>")(save-excursion(end-of-buffer)(newline 2)(insert "<sub>"n" ")(yank)(insert"</sub>")))))

Більш елегантно:

(defun parens ()
  (let (b(cpt 0)n)
    (goto-char 0)
    (while(search-forward"("()t)
      (setf b(point)n(number-to-string(incf cpt)))
      (backward-char)
      (forward-sexp)
      (backward-char)
      (kill-region b(point))
      (delete-backward-char 1)
      (delete-forward-char 1)
      (insert "<sup>"n"</sup>")
      (save-excursion
       (end-of-buffer)
       (newline 2)
       (insert "<sub>"n" ")
       (yank)
       (insert "</sub>")))))

Сітківка , 96 86 83 байт * 120% = 99,6

Вихідний код цього рішення складається з двох файлів:

+s`\((((\()|(?<-3>\))|[^)])*).(.*)(?<=(1+).*?)?

<sup>1$5</sup>$4

<sub>1$5 $1</sub>

Пояснення

Це дуже пряма реалізація алгоритму, як описано в виклику. Код складається з однієї заміни регулярних виразів, яка перетворює перший набір дужок у виноску. Ця заміна повторюється через, +поки рядок не перестане змінюватися, що означає, що регулярний вираз більше не збігається (оскільки він не може знайти більше дужок).

Зноски перераховуються одинарними, так що я можу просто шукати номер останньої виноски і додавати а, 1щоб створити наступну.

Регекс для пошуку першого набору круглих дужок заснований на стандартній техніці зіставлення дужок з балансуючими групами (hrhr, "збігання дужок"). Це було трохи скорочено за допомогою неназваної групи та припускаючи, що круглі дужки правильно врівноважені (це означає, що ми можемо опустити класу (з заперечуваного класу символів і порівняти фінал )з простим, .і нам також не потрібно гарантувати, що стек захоплення порожній).

Після зіставлення дужок і захоплення їх вмісту в групу 1, ми захоплюємо решту рядка з (.*)у групу, 4а потім шукаємо назад через рядок для першого набору 1s з негативним оглядом. Якщо ми знайдемо таку підрядку, зберігаємо в групі 5. Якщо ми цього не зробимо, ми дивимось на помилки, але це нормально, оскільки це необов'язково - це просто означає, що $5дасть порожній рядок, який є неоднаковим поданням 0і який також є правильним.

Потім рядок заміни просто з'єднує все на основі груп захоплення. Число виноски збільшується заздалегідь, додаючи 1до останнього числа с 1$5.

Сакральний JavaScript , 1510 байт

Повстанці-товариші, не поступайтеся своїм тиранічним знесенням дужок! Ви повинні наполягати! З самого початку програмування було вільним підприємством. Тепер це стало пронизаним проявом благочестя. Ми повинні виявляти не менше, ніж абсолютну боязнь. Тому я відбив!

    ( )( (((  ((  )( )  (( ))( )) (( ( ((  ) ( ()( ) (( ) )(( ((( ()((( ) ( ) )((  ) (((((( )( (())((  ) ) )( ()(( ((()((()   ( (  (  ( )) ((  )( ) (( ) )((((  ( () ) )( ( ()(( )( () ((( )(( ) )( ()((( ) ( )  ( )() (((( () ) (((( () ) ((() ) ()  ( (  (  ( )) ( )(  ((((( )) ((  )( ) (( ) )((((  ) )  ()(  ((() ( ()(( ) ( ) )(( ))(((  (( ) ((  ) ( ()(( )( ) ()  ( (  (  ( ()( ) )( ()(  ) ()  ( (  (  ( )( (( ( (( )  ((((( ))  ) )(( )) ((  )( ) (( ) )((((  ) ()( ))  ) ) (( )( () (((   ( ) )((  )( )(((( ))( )() ) ()( ))  (()( (()( ((()((()   ( (  (    (  ( )) ( )(  (((((( )(( ( (( )) ( ((  ) )( ) )( ( )( ((() ( )( ((() ( ()( ()( ()   ) )( ()(( ) ()  ( (  (    (  ( )) ( )(  (((((( )(( ( (( )) ( ((  ) )( ) )( ( )( (((( ( )( ((() ( ()( ()( (()( ) )( ()(( ) ()  ( (  (    (  ( )) ( )(  (((( ( ) ( ()( ((() ( ()( ())(( ) ( ) )( ()(( ))) ) ()  ( (  (  ((())  ( (  (  ((( ( ) )((( )( () ((( )(((   ( )) ( )  ( ) ) ((((( )) ((  )( ) (( ) )((((  (())( ))  (()( ()(( ((()  ( (  (  ( )(  ) )(((( ( () ((( ) ( ) )(( ((((   ( ()(( )  ( ) ) (((( () )( ((( ((((((()( ((() ((   () )( )(( (()) ( )( ( )( ((() ) ()  ( (  (  (( ) ( ) )(( ))(((  (( ) ((  ) ( ()( ) (( ) )(( ((( ()((( ) ( ) )((  ) (((((( )( () ((( ) ( ) )(( ((((   ( ()(( )  ( ) ) ((((((( ( (()) ( )( ) ) (( )((((  ( ()) ) )) ( )( (()(((  ) (()( ( )( ) )  () )(( )((((  ( ()) ) )) ( )( ((() (()( ( )(  ( (  ( ( ) ) (( )((((  ( ()) ) )) ( )( (()(((  ) (()( ( )( ( () ( )( (()(( )(  (()( ( )( ) )  () )(( )((((  ( ()) ) )) ( )( (())((  ) (()( ()(( ((() ) ()  ( (((())

Немає правил проти використання священних символів мовою, що не є Lisp. Ні, зовсім не. (Трохи менш компактним способом :)

( )( (((  ((  )( )  (( ))( )) (( ( ((  ) ( ()( ) (( ) )(( ((( ()((( ) 
( ) )((  ) (((((( )( (())((  ) ) )( ()(( ((()((()   ( (  (  ( )) ((  )
( ) (( ) )((((  ( () ) )( ( ()(( )( () ((( )(( ) )( ()((( ) ( )  ( )()
 (((( () ) (((( () ) ((() ) ()  ( (  (  ( )) ( )(  ((((( )) ((  )( ) (
( ) )((((  ) )  ()(  ((() ( ()(( ) ( ) )(( ))(((  (( ) ((  ) ( ()(( )(
 ) ()  ( (  (  ( ()( ) )( ()(  ) ()  ( (  (  ( )( (( ( (( )  ((((( )) 
 ) )(( )) ((  )( ) (( ) )((((  ) ()( ))  ) ) (( )( () (((   ( ) )((  )
( )(((( ))( )() ) ()( ))  (()( (()( ((()((()   ( (  (    (  ( )) ( )( 
 (((((( )(( ( (( )) ( ((  ) )( ) )( ( )( ((() ( )( ((() ( ()( ()( ()  
 ) )( ()(( ) ()  ( (  (    (  ( )) ( )(  (((((( )(( ( (( )) ( ((  ) )(
 ) )( ( )( (((( ( )( ((() ( ()( ()( (()( ) )( ()(( ) ()  ( (  (    (  
( )) ( )(  (((( ( ) ( ()( ((() ( ()( ())(( ) ( ) )( ()(( ))) ) ()  ( (
  (  ((())  ( (  (  ((( ( ) )((( )( () ((( )(((   ( )) ( )  ( ) ) ((((
( )) ((  )( ) (( ) )((((  (())( ))  (()( ()(( ((()  ( (  (  ( )(  ) )(
((( ( () ((( ) ( ) )(( ((((   ( ()(( )  ( ) ) (((( () )( ((( ((((((()(
 ((() ((   () )( )(( (()) ( )( ( )( ((() ) ()  ( (  (  (( ) ( ) )(( ))
(((  (( ) ((  ) ( ()( ) (( ) )(( ((( ()((( ) ( ) )((  ) (((((( )( () (
(( ) ( ) )(( ((((   ( ()(( )  ( ) ) ((((((( ( (()) ( )( ) ) (( )((((  
( ()) ) )) ( )( (()(((  ) (()( ( )( ) )  () )(( )((((  ( ()) ) )) ( )(
 ((() (()( ( )(  ( (  ( ( ) ) (( )((((  ( ()) ) )) ( )( (()(((  ) (()(
 ( )( ( () ( )( (()(( )(  (()( ( )( ) )  () )(( )((((  ( ()) ) )) ( )(
 (())((  ) (()( ()(( ((() ) ()  ( (((())

Це компілюється до розширеного JavaScript в іншій моїй відповіді . Це жарт.

Луа, 222 216 204 201 байт

Гольф:

s=io.read()g="%b()"c=1k=string l=k.find t=k.sub o=k.format a,b=l(s,g)while a do s=t(s,0,a-1)..o("<sup>%d</sup>",c)..t(s,b+1,#s).."\n\n"..o("<sub>%d %s</sub>",c,t(s,a+1,b-1))c=c+1 a,b=l(s,g)end print(s)

Безголовки:

input=io.read() 
inputFormat="<sup>%d</sup>"
footnoteFormat="<sub>%d %s</sub>"
counter=1
a,b=string.find(input,"%b()")
while a do
    current=string.sub(input,a+1,b-1)
    input=input.."\n\n"..string.format(footnoteFormat, counter, current) 
    input=string.sub(input,0,a-1)..string.format(inputFormat, counter)..string.sub(input,b+1,#input)
    counter=counter+1
    a,b=string.find(input,"%b()")
end

print(input)

Схема, 92 байти

Розчарувавшись у здійсненні першого розгорнутого пошуку в Real Lisp, ¹ повноваження вирішили скористатися більш прагматичним підходом. Зрештою, дужки є священними, а дужки - ні. ²

(lambda(s)(list->string(map(lambda(c)(case c((#\()#\[)((#\))#\])(else c)))(string->list s)))

<sub>1. не слухайте тих єретиків з так званої «церкви» Емака!
2. Вони не є програмістами Ракетки, чи не так?</sub>

Haskell, 210 байт

n#x|b==""=a|1<2=a++"<sup>"++m++"</sup>"++((n+1)#(c++"\n\n<sub>"++m++' ':init d++"</sub>"))where m=show n;(a,b)=span(/='(')x;(d,c)=[x|x@(y,_)<-map(`splitAt`(tail b))[0..],'('!y<')'!y]!!0;c!l=[1|m<-l,m==c]
p=(1#)

Приклад використання:

*Main> putStrLn $ p "This has (nested (deeply (or highly?) nested)) parentheses (and several groups)."
This has <sup>1</sup> parentheses <sup>2</sup>.

<sub>1 nested <sup>3</sup></sub>

<sub>2 and several groups</sub>

<sub>3 deeply <sup>4</sup> nested</sub>

<sub>4 or highly?</sub>

Як це працює:

n # x                      -- # does all the work, n is the current number of the
                           --   footnote and x the input string
  | b=="" = a              -- if b (see below) is empty, there's no ( in the
                           --   string and the result is 'a' (see below)
  | 1<2   = a++"<sup>"++m++"</sup>"++ ((n+1)#(c++"\n\n<sub>"++m++' ':init d++"</sub>"))
                           -- otherwise (b not empty) build the output string
                           --   starting with 'a' and a footnote number and a
                           --   recursive call with the current footnote appended
                           --   to the rest of the string  

  where 
  m = show n;              -- turn n into string
  (a,b) = span (/='(') x;  -- split the input string x into two parts:
                           --   a: everything before the first (
                           --   b: beginning with the first ( to the end
                           --   if there's no (, a is x and b is empty
  (d,c) = [x|x@(y,_)<-map(`splitAt`(tail b))[0..],'('!y<')'!y]!!0;
                           -- find matching ) in the tail of b ('tail' to remove leading '(') 
                           --   d: everything before and including the matching )
                           --   c: everything behind the matching )
  c!l=[1|m<-l,m==c]        -- helper function that builds a list of 1s for every character searched for
                           --   we have reached the matching ) if the list for ( is
                           --   shorter (less than, <) the list for )

p=(1#)                     -- start with footnote 1

Схема, 533 байти

З відступом:

(letrec ((l string->list)
         (n number->string)
         (? null?)
         (p (lambda (o) (or (pair? o)(? o))))
         (a car)
         (d cdr)
         (e append)
         (i 0)
         (x
          (lambda (h t)
            (if (? h)
                t
                (case (a h)
                  ((#\() 
                   (let ((s (x (d h) ())))
                     (x (a s) (e t (d s)))))
                  ((#\)) (cons (d h) (list t)))
                  (else 
                   (x (d h) (e t (list (a h)))))))))
         (f 
          (lambda (h t F)
            (cond ((? h)
                   (let ((w (e t F)))
                     (if (find p w) (f w()()) w)))
                  ((p(a h))
                   (set! i(+ 1 i))
                   (f (d h)
                      (e t (e (l "<sup>")
                              (l (n i))
                              (l "</sup>")))
                      (e F (e (l "\n\n<sub>")
                              (l (n i))
                              '(#\ )
                              (a h)
                              (l "</sub>")))))
                  (else (f (d h) 
                           (e t (list (a h)))
                           F))))))
  (print (list->string (f (x (l (read-line)) 
                             ())
                          ()
                          ()))))

Так, це 533 байти, коли видалено все необов’язкове пробіл. Гуляйте у функціональній славі.

Я реалізував більш-менш алгоритм в описі: xгрупує введення в дужках і fзамінює виноски в групі першого рівня, повторюючи, поки не залишиться більше груп. Я впевнений, що його можна зробити коротшим, але я не бачу, як це можна зробити набагато коротшим, не перемикаючись на інший алгоритм.

Як написано, це повноцінна програма. Ви можете спробувати тут , але оскільки repl.it, мабуть, не справляється з (read-line)вами, ви повинні поставити рядок введення на його місце. Цілком неперевершена версія тут .

EDIT: Як зазначалося в коментарях, я змінив круглі дужки ()в дужки []у версіях repl.it. Це було виключно для зручності під час програмування та налагодження. Опублікована зараз версія працює ().

JavaScript ES6, 244 байти

Серйозна відповідь (наскільки мені відомо лише на FireFox)

d=(s,n=1)=>{u=s.search(/\(/);if(index<a=0)return s;for(i=index;i<s.length;i++){if(s[i]==")")a-=1;if(s[i]=="(")a+=1;if(!a)break}return d(s.replace(v=s.slice(index,i+1),"<sub>"+n+"</sub>")+`

<sub>`+n+" "+v.replace(/^\(|\)$/g,"")+"</sub>",n+1)}

Розширено:

function deparen(s,n=1){
    index = s.search(/\(/);
    if(index<0) return s;
    a=0;
    for(i=index;i<s.length;i++){
        if(s[i]==")") a-=1;
        if(s[i]=="(") a+=1;
        if(!a) break;
    }
    v=s.slice(index,i+1)
    f=v.replace(/^\(|\)$/g,"");
    return deparen(s.replace(v,"<sub>"+n+"</sub>")+"\n\n<sub>"+n+" "+f+"</sub>",n+1);
}

Hassium , 315 байт

В даний час це неконкурентоспроможне, оскільки це також точно не справляється з вкладеними.

func main(){i=input();r="";f="";z=1;for(x=0;x<i.length;x++){c=i[Convert.toNumber(Convert.toString(x))];if(c=="("){f+="\n<sub>"+z+" ";for(x++;!(i[Convert.toNumber(Convert.toString(x))]==")");x++){f+=i[Convert.toNumber(Convert.toString(x))];}f+="</sub>\n";z++;r+="<sup>"+z+"</sup>";}else r+=c;}println(r);println(f);}

Розширено:

func main() {
    i = input();
    r = "";
    f = "";
    z = 1;
    for (x = 0; x < i.length; x++) {
            c = i[Convert.toNumber(Convert.toString(x))];
            if (c == "(") {
                    f += "\n<sub>" + z + " ";
                    for (x++; !(i[Convert.toNumber(Convert.toString(x))] == ")"); x++) {
                            f += i[Convert.toNumber(Convert.toString(x))];
                    }
                    f += "</sub>\n";
                    z++;
                    r += "<sup>" + z + "</sup>";
            } else
                    r += c;
    }

    println(r);
    println(f);

}