Latar Belakang

Programmer LISP telah mengambil alih dunia! Tanda kurung telah dinyatakan sebagai karakter sakral, dan mulai sekarang, tanda kurung hanya dapat digunakan dalam program LISP. Telah diputuskan bahwa tanda kurung dalam karya sastra akan digantikan oleh catatan kaki, dan tugas Anda adalah mengotomatiskan ini untuk teks Markdown yang disederhanakan.

Memasukkan

Input Anda adalah string tunggal yang berisi karakter ASCII alfabet, spasi, dan karakter khusus ,.!?(). Itu tidak akan mengandung baris atau digit baru. Tanda kurung akan dicocokkan dengan benar.

Keluaran

Anda harus mengubah setiap pasangan tanda kurung yang cocok di string input menjadi catatan kaki. Ini terjadi sebagai berikut:

1. Ganti pasangan kurung yang cocok pertama dan substring di antara mereka dengan nomor berjalan yang dimulai dari 1, dibungkus antara tag Penurunan harga <sup>dan </sup>.
2. Tambahkan ke akhir string
   • dua baris baru,
   • tag penurunan harga <sub>,
   • nomor dari langkah 1,
   • sebuah ruang,
   • substring di antara tanda kurung, dan
   • tag penutup </sub>, dalam urutan ini.
3. Jika masih ada tanda kurung di dalam string, lanjutkan ke langkah 1.

Output Anda adalah string yang dihasilkan, mungkin dengan trailing newline. Anda tidak harus menerapkan algoritme yang tepat ini, selama output Anda benar. Perhatikan bahwa mungkin ada tanda kurung bersarang; dalam hal ini, kami akan memiliki catatan kaki yang berisi referensi ke catatan kaki lainnya. Substring di antara tanda kurung juga mungkin kosong. Lihat contoh uji di bawah ini untuk contoh.

Aturan dan Penilaian

Anda dapat menulis program lengkap atau fungsi. Hitungan byte terendah menang, dan celah standar tidak diizinkan.

Jika bahasa Anda tidak mendukung angka desimal ( batuk Retina batuk ), Anda dapat memberikan nomor catatan kaki di pangkalan lain, termasuk biner atau unary; namun, menggunakan angka yang tidak dikenal akan memberikan penalti + 20% .

Uji Kasus

Memasukkan:

This input contains no parentheses.

Keluaran:

This input contains no parentheses.

Memasukkan:

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

Keluaran:

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

<sub>1 some</sub>

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

Memasukkan:

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

Keluaran:

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>

Memasukkan:

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

Keluaran:

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>

Perhatikan garis kosong di antara catatan kaki.

Perl, 81 75 72 byte

71 byte kode + 1 byte argumen baris perintah.

Membutuhkan Perl 5.10 atau lebih baru (untuk dukungan regex rekursif)

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

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

Pemakaian:

perl -p entry.pl input.txt

Penjelasan

-p parameter akan mencetak hasil dari menerapkan perintah yang diberikan pada input, menghindari kebutuhan untuk cetak eksplisit.

Regex (\(((?1)|.)*?)\))sedang mencari set kurung terluar dari awal string. Ketika ini ditemukan, kami melakukan substitusi, memastikan kami hanya menambahkan di akhir input (dengan menangkap semuanya sampai akhir input menggunakan (.*)).

Kami kemudian mengulangi penggantian regex pada string yang sekarang-disubtitusi menggunakan redo, yang akan terus menerapkan penggantian regex sampai tidak lagi cocok. The sMemastikan pengubah bahwa .di regex akan cocok baris baru, yang diperlukan karena kami mendaftar ulang pertandingan regex hasil substitusi regex sebelumnya.

Emacs Lisp, 335 byte

Kata pengantar. Jawaban ini dan yang Skema saat ini adalah satu-satunya jawaban yang disetujui secara resmi oleh Republik Populer LISP dan Gereja Emacs. Jawaban lain, lebih pendek atau tidak, dianggap sebagai ancaman bagi perdamaian. Khususnya, dan dengan sangat meremehkan dugaan libelious tentang McCarthyism yang secara sporadis terdengar dari musuh negara yang bermusuhan, kami memerintahkan siapa pun yang memiliki informasi tentang identitas asli penulis anonim yang menulis jawaban Nonlisp untuk menghubungi Biro Lokal Anda. Diingatkan bahwa setiap orang harus meluangkan waktu untuk merenung dan memilih sesuai dengan apa yang dia yakini tidak akan mengancam interaksinya di masa depan dengan perwakilan resmi dari kekuasaan yang ada. Kode adalah data. Data adalah kode.

(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>")))))

Lebih elegan:

(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>")))))

Retina , 96 86 83 byte * 120% = 99,6

Kode sumber solusi ini terdiri dari dua file:

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

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

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

Penjelasan

Ini adalah implementasi algoritma yang sangat langsung seperti yang dijelaskan dalam tantangan. Kode terdiri dari substitusi regex tunggal yang mengubah set kurung pertama menjadi catatan kaki. Substitusi ini diulangi +sampai string berhenti berubah, yang di sini berarti bahwa regex tidak lagi cocok (karena tidak dapat menemukan tanda kurung lagi).

Catatan kaki dihitung dalam unary, sehingga saya bisa mencari nomor catatan kaki terakhir dan menambahkan 1untuk membuat yang berikutnya.

Regex untuk menemukan set tanda kurung pertama didasarkan pada teknik standar untuk mencocokkan tanda kurung dengan kelompok penyeimbang (jam, "tanda kurung yang cocok"). Ini telah dipersingkat sedikit dengan menggunakan grup yang tidak disebutkan namanya dan dengan mengasumsikan bahwa tanda kurung seimbang dengan benar (yang berarti kita dapat menghilangkan (dari kelas karakter yang dinegasikan dan mencocokkan final )dengan yang sederhana .dan kita juga tidak perlu memastikan bahwa capture stack kosong).

Setelah mencocokkan tanda kurung dan mengambil isinya ke dalam grup 1, kami menangkap sisa string dengan (.*)ke dalam grup 4dan kemudian mencari kembali melalui string untuk set pertama 1s dengan tampilan negatif di belakang. Jika kami menemukan substring seperti itu, kami menyimpan dalam grup 5. Jika tidak, kita melihat di belakang gagal, tapi tidak apa-apa karena itu opsional - itu hanya berarti $5akan memberikan string kosong yang merupakan representasi unary 0dan yang juga benar.

Tali pengganti kemudian dengan mudah menyatukan semuanya berdasarkan kelompok penangkap. Nomor catatan kaki bertambah dengan menambahkan a 1ke nomor terakhir dengan 1$5.

JavaScript Suci , 1510 byte

Rekan-rekan pemberontak, jangan menyerah pada pembongkaran tirani kurung mereka! Anda harus gigih! Sejak awal, pemrograman telah menjadi usaha bebas. Sekarang, itu telah menjadi pertunjukan kesalehan yang meresapi. Kita harus menunjukkan tidak kurang dari ketakutan absolut. Karena itu, aku telah melawan!

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

Tidak ada aturan yang melarang penggunaan karakter suci dalam bahasa non-Lisp. Tidak, tidak sama sekali. (Dengan cara yang kurang kompak :)

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

Ini mengkompilasi ke JavaScript yang diperluas di jawaban saya yang lain . Ini adalah pengajuan lelucon.

Lua, 222 216 204 201 byte

Golf:

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)

Tidak Terkumpul:

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)

Skema, 92 byte

Frustasi dengan mengimplementasikan pencarian pertama di Real Lisp, ¹ kekuatan-yang-memutuskan untuk mengambil pendekatan yang lebih pragmatis. Bagaimanapun, kurung itu suci, tetapi kurung tidak. ²

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

<sub>1. jangan dengarkan orang-orang sesat dari apa yang disebut “gereja” Emacs!
2. Mereka bukan programmer Racket, bukan?</sub>

Haskell, 210 byte

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#)

Contoh penggunaan:

*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>

Bagaimana itu bekerja:

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

Skema, 533 byte

Dengan lekukan:

(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)) 
                             ())
                          ()
                          ()))))

Ya, ini adalah 533 byte ketika semua spasi putih opsional dihapus. Berjemur dalam kemuliaan fungsional.

Saya menerapkan kurang lebih algoritma dalam uraian: xmengelompokkan input dengan tanda kurung dan fmengganti tingkat pertama grup dengan catatan kaki, mengulang sampai tidak ada lagi grup yang tersisa. Saya yakin itu bisa dibuat lebih pendek, tapi saya tidak melihat bagaimana itu bisa dibuat lebih pendek tanpa beralih ke algoritma yang berbeda.

Seperti yang tertulis, ini adalah program yang lengkap. Anda dapat mencobanya di sini , tetapi karena repl.it tampaknya tidak dapat menangani (read-line)Anda harus meletakkan string input di tempatnya. Versi yang sepenuhnya ungolfed ada di sini .

EDIT: Seperti yang ditunjukkan dalam komentar, saya mengubah tanda kurung ()menjadi tanda kurung []di versi repl.it. Ini murni untuk kenyamanan selama pemrograman dan debugging. Versi yang diposkan sekarang berfungsi dengan ().

JavaScript ES6, 244 byte

Jawaban serius (hanya bekerja di FireFox, setahu saya)

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)}

Diperluas:

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 Bytes

Saat ini tidak bersaing karena ini tidak benar-benar menangani sarang juga.

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);}

Diperluas:

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);

}