Dấu ngoặc đơn vào chú thích


29

Lý lịch

Các lập trình viên LISP đã chiếm lĩnh thế giới! Dấu ngoặc đơn đã được tuyên bố là ký tự thiêng liêng và từ giờ trở đi, chúng chỉ có thể được sử dụng trong các chương trình LISP. Người ta đã quyết định rằng dấu ngoặc đơn trong tác phẩm văn học sẽ được thay thế bằng chú thích và công việc của bạn là tự động hóa điều này cho văn bản Markdown đơn giản hóa.

Đầu vào

Đầu vào của bạn là một chuỗi chứa các ký tự ASCII chữ cái, dấu cách và các ký tự đặc biệt ,.!?(). Nó sẽ không chứa dòng mới hoặc chữ số. Các dấu ngoặc đơn sẽ được khớp chính xác.

Đầu ra

Bạn sẽ chuyển đổi từng cặp dấu ngoặc đơn phù hợp trong chuỗi đầu vào thành chú thích. Điều này xảy ra như sau:

  1. Thay thế cặp dấu ngoặc đơn phù hợp đầu tiên và chuỗi con giữa chúng bằng một số chạy bắt đầu từ 1, được bao bọc giữa các thẻ Markdown <sup></sup>.
  2. Nối vào cuối chuỗi
    • hai dòng mới,
    • thẻ Markdown <sub>,
    • số từ bước 1,
    • một không gian,
    • chuỗi con giữa các dấu ngoặc đơn và
    • thẻ đóng </sub>, theo thứ tự này.
  3. Nếu vẫn còn dấu ngoặc trong chuỗi, chuyển sang bước 1.

Đầu ra của bạn là chuỗi kết quả, có thể với một dòng mới. Bạn không phải thực hiện thuật toán chính xác này, miễn là đầu ra của bạn là chính xác. Lưu ý rằng có thể có dấu ngoặc đơn lồng nhau; trong trường hợp đó, chúng ta sẽ có các chú thích có chứa các tham chiếu đến các chú thích khác. Chuỗi con giữa các dấu ngoặc đơn cũng có thể trống. Xem các trường hợp thử nghiệm dưới đây để biết ví dụ.

Quy tắc và chấm điểm

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng. Số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép.

Nếu ngôn ngữ của bạn không hỗ trợ số thập phân ( ho Retina ho ), bạn có thể đưa ra các số chú thích ở một cơ sở khác, bao gồm nhị phân hoặc đơn nguyên; tuy nhiên, sử dụng số đơn nguyên áp đặt mức phạt + 20% .

Các trường hợp thử nghiệm

Đầu vào:

This input contains no parentheses.

Đầu ra:

This input contains no parentheses.

Đầu vào:

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

Đầu ra:

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

<sub>1 some</sub>

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

Đầu vào:

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

Đầu ra:

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>

Đầu vào:

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

Đầu ra:

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>

Lưu ý các dòng trống giữa các chú thích.


23
Chương trình của tôi có thể chứa dấu ngoặc đơn ngay cả khi nó không được viết bằng Lisp hay bây giờ đó có phải là một hành vi phạm tội bị trừng phạt không?
Martin Ender

16
@ MartinBüttner Dấu ngoặc đơn trong các chương trình không phải LISP được cho phép một cách miễn cưỡng, miễn là chúng được sử dụng cho mục đích tốt hơn, như chuyển đổi các dấu ngoặc đơn khác thành chú thích.
Zgarb

Đầu vào có thể là nhiều dòng? Trong trường hợp đó, nên đặt chú thích sau mỗi dòng, hoặc ở cuối? Ví dụ, đầu ra để làm foo (bar)\nfoot (note)gì?
xebtl

@xebtl Đầu vào luôn là một dòng duy nhất. Xem phần Đầu vào : "Nó sẽ không chứa dòng mới hoặc chữ số."
Zgarb

2
:( @ thông số này ghi chú số đầu tiên thay vì chiều sâu đầu tiên
Sparr

Câu trả lời:


10

Perl, 81 75 72 byte

71 byte mã + 1 byte đối số dòng lệnh.

Yêu cầu Perl 5.10 hoặc mới hơn (để hỗ trợ regex đệ quy)

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

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

Sử dụng:

perl -p entry.pl input.txt

Giải trình

-p tham số sẽ in kết quả của việc áp dụng các lệnh đã cho vào đầu vào, tránh sự cần thiết phải in rõ ràng.

Regex (\(((?1)|.)*?)\))đang tìm kiếm bộ dấu ngoặc ngoài cùng từ đầu chuỗi. Khi điều này được tìm thấy, chúng tôi thực hiện thay thế, đảm bảo chúng tôi chỉ thêm vào cuối của đầu vào (bằng cách chụp mọi thứ cho đến khi kết thúc đầu vào bằng cách sử dụng (.*)).

Sau đó, chúng tôi lặp lại thay thế regex trên chuỗi được thay thế bằng cách sử dụng redo, chuỗi này sẽ liên tục áp dụng thay thế regex cho đến khi nó không còn phù hợp. Công cụ ssửa đổi đảm bảo rằng .trong biểu thức chính quy sẽ khớp với các dòng mới, điều này là cần thiết bởi vì chúng tôi áp dụng lại kết quả khớp chính thức trên kết quả của sự thay thế biểu thức chính trước đó.


1
Bạn có thể có thể thoát khỏi với [^)] hoặc thậm chí .thay [^()]vì bởi vì đảm bảo rằng đầu vào sẽ được cân bằng chính xác.
Martin Ender

+1 để giới thiệu cho tôi các biểu thức đệ quy :-). Nhưng tôi nghĩ rằng trong một bài đọc nghiêm ngặt về thách thức thì điều này là không chính xác: Nếu chuỗi chứa dòng mới, chú thích sẽ được đặt sau mỗi dòng thay vì ở cuối. (Xem yêu cầu của tôi để làm rõ ở trên.)
xebtl

Điểm hay @ MartinBüttner - chúng ta có thể thoát khỏi bằng .cách làm cho trận đấu trở nên lười biếng. @xebtl, thử thách nêu rõ "Nó sẽ không chứa dòng mới hoặc chữ số"
Jarmex

12

Emacs Lisp, 335 byte

Lời tựa. Câu trả lời này và các Đề án hiện đang là câu trả lời duy nhất bị trừng phạt chính thức bởi cả Cộng hòa LISP nổi tiếng và Nhà thờ Emacs. Các câu trả lời khác, ngắn hơn hay không, được coi là mối đe dọa cho hòa bình. Đặc biệt, và với thái độ khinh bỉ sâu sắc đối với bất kỳ cáo buộc phỉ báng nào về chủ nghĩa McCarthy được nghe một cách rời rạc từ các đối thủ thù địch của nhà nước, chúng tôi mời bất kỳ ai có thông tin về danh tính thực sự của các tác giả ẩn danh viết câu trả lời Không liên quan để liên hệ với Văn phòng Địa phương của bạn. Chúng tôi xin lưu ý rằng mọi người nên dành thời gian để phản ánh và nâng cao theo những gì anh ấy hoặc cô ấy tin tưởng sâu sắc sẽ không đe dọa đến sự tương tác trong tương lai của anh ấy với các đại diện chính thức của quyền lực. Mã là dữ liệu. Dữ liệu là mã.

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

Thanh lịch hơn:

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

9

Võng mạc , 96 86 83 byte * 120% = 99,6

Mã nguồn của giải pháp này bao gồm hai tệp:

+s`\((((\()|(?<-3>\))|[^)])*).(.*)(?<=(1+).*?)?
<sup>1$5</sup>$4

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

Giải trình

Đây là một triển khai rất trực tiếp của thuật toán như được mô tả trong thử thách. Mã này bao gồm một thay thế regex duy nhất biến tập hợp dấu ngoặc đơn đầu tiên thành chú thích. Sự thay thế này được lặp lại thông qua +cho đến khi chuỗi ngừng thay đổi, điều này có nghĩa là regex không còn phù hợp nữa (vì nó không thể tìm thấy bất kỳ dấu ngoặc đơn nào nữa).

Các chú thích được liệt kê một cách đơn nhất, do đó tôi chỉ cần tìm số chú thích cuối cùng và nối thêm 1để tạo số tiếp theo.

Regex để tìm bộ dấu ngoặc đơn đầu tiên dựa trên kỹ thuật tiêu chuẩn để khớp ngoặc đơn với các nhóm cân bằng (hrhr, "khớp ngoặc đơn"). Nó đã được rút ngắn một chút bằng cách sử dụng một nhóm không tên và bằng cách giả sử rằng các dấu ngoặc đơn được cân bằng chính xác (có nghĩa là chúng ta có thể bỏ qua (lớp ký tự bị phủ định và khớp với trận chung kết )với một đơn giản .và chúng ta cũng không cần phải đảm bảo rằng chụp ngăn xếp là trống rỗng).

Sau khi khớp các dấu ngoặc đơn và thu thập nội dung của chúng thành nhóm 1, chúng tôi nắm bắt phần còn lại của chuỗi (.*)thành nhóm 4và sau đó tìm kiếm lại qua chuỗi cho tập hợp 1s đầu tiên có giao diện phủ định. Nếu chúng tôi tìm thấy một chuỗi con như vậy, chúng tôi lưu trữ trong nhóm 5. Nếu chúng ta không làm như vậy, chúng ta sẽ thất bại, nhưng điều đó không sao vì điều đó là tùy chọn - điều đó chỉ có nghĩa là $5sẽ đưa ra một chuỗi trống là đại diện đơn nhất 0và cũng đúng.

Chuỗi thay thế sau đó chỉ đơn giản là ghép mọi thứ lại với nhau dựa trên các nhóm bắt giữ. Số chú thích được tăng lên bằng cách thêm một 1đến số cuối cùng với 1$5.


3
Retina đang trên đà chiến thắng!
orlp

@orlp Hay là nó? ;) Các nhóm cân bằng không phù hợp với regex đệ quy. Điều đó và không thể xử lý các số thập phân ...
Martin Ender

Thời gian để đánh cắp trình bao bọc PHP và triển khai Retina xung quanh PCRE:
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

@ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ Thông thường, tôi muốn có các nhóm cân bằng hơn là đệ quy, nhưng có một số trường hợp sau này ngắn gọn hơn. Có thể một ngày nào đó tôi sẽ thực hiện lại hương vị regex .NET cho Retina và vá một số tính năng bổ sung. ;)
Martin Ender

9

JavaScript linh thiêng , 1510 byte

Những kẻ nổi loạn, đừng nhượng bộ trong việc phá hủy sự chuyên chế của họ! Bạn phải kiên trì! Ngay từ đầu, lập trình đã là một doanh nghiệp miễn phí. Bây giờ, nó đã trở thành một chương trình về lòng đạo đức. Chúng ta phải thể hiện không có gì ít hơn sau đó là sự sợ hãi tuyệt đối. Vì vậy, tôi đã chiến đấu trở lại!

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

Không có quy tắc chống lại việc sử dụng các ký tự thiêng liêng trong một ngôn ngữ không phải là Lisp. Không phải là tất cả. (Theo cách nhỏ gọn hơn một chút :)

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

Điều này biên dịch thành JavaScript mở rộng trong câu trả lời khác của tôi . Đây là một đệ trình đùa.


5

Lua, 222 216 204 201 byte

Chơi gôn

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)

Ung dung:

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)

một repeat a,b=l(s,g) ... untill a<1vòng lặp sẽ ngắn hơn thời gian của bạn?
Katenkyo

4

Lược đồ, 92 byte

Thất vọng với việc thực hiện tìm kiếm đầu tiên trong Real Lisp, 1 quyền hạn được quyết định thực hiện một cách tiếp cận thực tế hơn. Xét cho cùng, Dấu ngoặc đơn là thiêng liêng, nhưng dấu ngoặc thì không. 2

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

1. đừng nghe những kẻ dị giáo từ cái gọi là nhà thờ Hồi giáo Emacs!
2. Họ không phải là lập trình viên vợt, phải không?


Lược đồ sẽ được gọi là Schism: nói rằng đó là "Real Lisp" là dị giáo thực sự. Và bạn nói nó thực dụng ? Bản hack của một câu trả lời này cho thấy bản chất thực sự của những kẻ lừa đảo ;-)
coredump

@coredump Và bạn sẽ khẳng định câu trả lời không cần thiết của bạn là một ví dụ của True Lisp? Nó có thể mất một chút thời gian, đúng, nhưng khi câu trả lời Scheme kết thúc, nó sẽ là Điều đúng!
xebtl

3

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

Ví dụ sử dụng:

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

Làm thế nào nó hoạt động:

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

2

Lược đồ, 533 byte

Với vết lõm:

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

Có, đây là 533 byte khi tất cả các khoảng trắng tùy chọn bị xóa. Đắm mình trong vinh quang chức năng.

Tôi đã triển khai ít nhiều thuật toán trong phần mô tả: xnhóm đầu vào theo dấu ngoặc đơn và fthay thế cấp độ nhóm đầu tiên bằng chú thích, lặp lại cho đến khi không còn nhóm nào nữa. Tôi chắc chắn rằng nó có thể được làm ngắn hơn, nhưng tôi không thấy làm thế nào nó có thể được làm ngắn hơn nhiều mà không chuyển sang một thuật toán khác.

Như đã viết, nó là một chương trình hoàn chỉnh. Bạn có thể dùng thử ở đây , nhưng vì repl.it dường như không thể đối phó với (read-line)bạn nên đặt chuỗi đầu vào vào vị trí của nó. Một phiên bản hoàn toàn vô văn hóa là ở đây .

EDIT: Như đã chỉ ra trong các bình luận, tôi đã thay đổi dấu ngoặc đơn ()thành ngoặc []trong các phiên bản repl.it. Điều này hoàn toàn là sự thuận tiện trong quá trình lập trình và gỡ lỗi. Các phiên bản như được đăng bây giờ làm việc với ().


1
+1, nhưng tôi không hiểu tại sao bạn thay đổi dấu ngoặc vuông. Nếu tôi thay đổi #\['#] `bằng dấu ngoặc đơn tương ứng (và kiểm tra cập nhật), thì điều này sẽ hoạt động mà không gặp vấn đề gì. Có một lý do bạn rời khỏi những hình vuông? nó có liên quan đến câu trả lời trước của bạn không?
coredump

1
@coredump bạn hoàn toàn đúng. Tôi đã thay đổi thành ngoặc đơn vì (a) các ký tự paren bị rối tung so sánh thay thế par.it và (b) trong gỡ lỗi, đầu ra (sẽ bao gồm rất nhiều parens từ danh sách) dễ đọc hơn với dấu ngoặc. Sau đó, tôi chỉ để nó theo cách đó. Tôi sẽ chỉnh sửa.
xebtl

1

JavaScript ES6, 244 byte

Câu trả lời nghiêm túc (chỉ hoạt động trên FireFox, theo hiểu biết của tôi)

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

Mở rộng:

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

0

Kali , 315 byte

Hiện tại điều này không cạnh tranh vì điều này cũng không xử lý chính xác lồng nhau.

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

Mở rộng:

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

}

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.