फुटनोट्स में कोष्ठक

Question

पृष्ठभूमि

LISP प्रोग्रामर दुनिया भर में ले लिया है! कोष्ठक को पवित्र चरित्र के रूप में घोषित किया गया है, और अब से, उनका उपयोग केवल एलआईएसपी कार्यक्रमों में किया जा सकता है। यह निर्णय लिया गया है कि साहित्यिक रचनाओं में कोष्ठक को फुटनोट द्वारा प्रतिस्थापित किया जाएगा, और सरलीकृत मार्केड पाठ के लिए इसे स्वचालित करना आपका काम है।

इनपुट

आपका इनपुट एक एकल स्ट्रिंग है जिसमें अल्फाबेटिक ASCII वर्ण, रिक्त स्थान और विशेष वर्ण हैं ,.!?()। इसमें नए अंक या अंक नहीं होंगे। कोष्ठक सही ढंग से मिलान किया जाएगा।

उत्पादन

आप इनपुट स्ट्रिंग में प्रत्येक कोष्ठक के मिलान जोड़े को फुटनोट में बदल देंगे। यह इस प्रकार होता है:

1. एक चल संख्या से कोष्ठक के पहले मिलान जोड़ी और उन दोनों के बीच-स्ट्रिंग की जगह है कि से शुरू होता है 1, Markdown टैग के बीच लिपटे <sup>और </sup>।
2. स्ट्रिंग के अंत में संलग्न करें
   • दो नए समाचार,
   • मार्कडाउन टैग <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>

फ़ुटनोट्स के बीच की खाली लाइनों पर ध्यान दें।

Comments

यदि लिस्प में नहीं लिखा गया है या क्या यह दंडनीय अपराध है तो क्या मेरे कार्यक्रम में कोष्ठक हो सकते हैं?

— मार्टिन एंडर

@ गैर-एलआईएसपी कार्यक्रमों में मार्टिनबटनर कोष्ठक की अनुमति दी जाती है, जब तक कि उनका उपयोग अधिक से अधिक अच्छे के लिए किया जाता है, जैसे अन्य कोष्ठकों को फुटनोट में परिवर्तित करना।

— जर्गब

क्या इनपुट कई लाइनें हो सकती हैं? उस स्थिति में, फुटनोट्स को प्रत्येक पंक्ति के बाद, या अंत में रखा जाना चाहिए? उदाहरण के लिए, आउटपुट क्या है foo (bar)\nfoot (note)?

— xebtl

@xebtl इनपुट हमेशा एक ही लाइन होती है। अनुभाग इनपुट देखें : "इसमें नए अंक या अंक नहीं होंगे।"

— जरगब

:( @ यह कल्पना संख्या गहराई के बजाय पहले-पहले

— पायदान पर पहुंचती है

Answer 1

पर्ल, 81 75 72 बाइट्स

71 बाइट्स कोड + 1 बाइट कमांड लाइन तर्क।

पर्ल 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संशोधक सुनिश्चित है कि .regex में नई लाइनों, जो आवश्यक है से मेल खाते हैं, क्योंकि हम पिछले regex प्रतिस्थापन के परिणाम पर regex मैच फिर से लागू होगा।

Comments

आप के साथ के साथ भाग प्राप्त करने में सक्षम हो सकता है [^)] या यहाँ तक कि .बजाय [^()]गारंटी नहीं है कि इनपुट सही ढंग से संतुलित हो जाएगा की वजह से।

— मार्टिन एंडर

+1 करने के लिए मुझे पुनरावर्ती rexxes शुरू करने के लिए :-)। लेकिन मुझे लगता है कि इस सख्त चुनौती को पढ़ने पर यह गलत है: यदि स्ट्रिंग में नई लाइनें हैं, तो अंत के बजाय प्रत्येक पंक्ति के बाद फुटनोट रखे जाएंगे। (ऊपर स्पष्टीकरण के लिए मेरा अनुरोध देखें।)

— xebtl

अच्छी बात है @ मार्टिन बर्नर - हम .मैच को आलसी बनाकर दूर हो सकते हैं । @xebtl, चुनौती बताती है कि "इसमें नए अंक या अंक नहीं होंगे"

— Jarmex

Answer 2

एमएसीएस लिस्प, 335 बाइट्स

प्राक्कथन। यह उत्तर और स्कीम वाले वर्तमान में एकमात्र उत्तर हैं जो LISP के माइटी पॉपुलर रिपब्लिक और चर्च ऑफ एमाक्स दोनों द्वारा आधिकारिक रूप से स्वीकृत किए गए हैं। अन्य उत्तर, छोटे या नहीं, को शांति के लिए खतरा माना जाता है। विशेष रूप से, और राज्य के शत्रुतापूर्ण विरोधियों से छिटपुट रूप से होने वाले मैकार्थीवाद के किसी भी परिवादात्मक आरोप का गहरा तिरस्कार करने के साथ, हम किसी को भी, जो आपके स्थानीय ब्यूरो से संपर्क करने के लिए गुमनाम उत्तर लिखने वाले गुमनाम लेखकों की वास्तविक पहचान के बारे में जानकारी देते हैं। यह याद दिलाया जाता है कि हर किसी को उस समय के अनुसार प्रतिबिंबित करने और उभारने में समय लगना चाहिए, जो वह या वह गहराई से मानता है कि उसके या उसके भविष्य के पारस्परिक संबंधों को खतरे में नहीं डाल देगा। कोड डेटा है। डेटा कोड है।

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

Answer 3

रेटिना , 96 86 83 बाइट्स * 120% = 99.6

इस समाधान के स्रोत कोड में दो फाइलें हैं:

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

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

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

व्याख्या

यह चुनौती में वर्णित एल्गोरिथ्म का एक बहुत ही सीधा कार्यान्वयन है। कोड में एकल रेगेक्स प्रतिस्थापन होता है जो कोष्ठक के पहले सेट को फुटनोट में बदल देता है। यह प्रतिस्थापन +तब तक दोहराया जाता है जब तक कि स्ट्रिंग बदलना बंद नहीं हो जाता है, जिसका मतलब है कि रेगेक्स अब मेल नहीं खाता है (क्योंकि यह किसी भी अधिक कोष्ठक नहीं मिल सकता है)।

फ़ुटनोट्स को एकात्मक में शामिल किया गया है, ताकि मैं बस आखिरी फुटनोट की संख्या 1देख सकूँ और अगले एक को बनाने के लिए अपील कर सकूँ ।

कोष्ठक के पहले सेट को खोजने के लिए रेगेक्स, कोष्ठक समूहों के साथ कोष्ठक के मिलान (घंटा, "मेलिंग कोष्ठक") के लिए मानक तकनीक पर आधारित है । किसी अनाम समूह का उपयोग करके और यह मानकर कि इसे छोटा किया गया है कि कोष्ठक सही ढंग से संतुलित हैं (जिसका अर्थ है कि हम (नकारा गया वर्ण वर्ग से बाहर निकल सकते हैं और फाइनल )को एक साधारण से मिला सकते हैं .और हमें यह भी सुनिश्चित करने की आवश्यकता नहीं है कि कब्जा ढेर खाली है)।

कोष्ठक मिलान और समूह में उनकी सामग्री पर कब्जा करने के बाद 1, हम साथ स्ट्रिंग के शेष पर कब्जा (.*)समूह में 4और उसके बाद के पहले सेट के लिए स्ट्रिंग के माध्यम से वापस खोज 1एक नकारात्मक lookbehind साथ। यदि हमें ऐसा कोई विकल्प मिलता है, तो हम समूह में स्टोर करते हैं 5। यदि हम नहीं करते हैं, तो हम असफल दिखते हैं, लेकिन यह ठीक है क्योंकि यह वैकल्पिक है - इसका मतलब है कि $5यह एक खाली स्ट्रिंग देगा जो कि एकात्मक प्रतिनिधित्व है 0और जो सही भी है।

प्रतिस्थापन स्ट्रिंग फिर कैप्चरिंग समूहों के आधार पर सब कुछ एक साथ टुकड़े करता है। फुटनोट संख्या को 1अंतिम संख्या के साथ जोड़कर बढ़ा दिया जाता है 1$5।

Comments

रेटिना एक जीतने वाली लकीर पर है!

— orlp

@orlp या है? ;) संतुलन समूहों का पुनरावर्ती रेगेक्स के लिए कोई मुकाबला नहीं है। वह और दशमलव संख्या को संभालने में सक्षम नहीं हो रहा है ...

— मार्टिन एंडर

PHP के रैपर को चुराने और PCRE के आसपास रेटिना को लागू करने का समय :

— ñ̷͉h̷̭̿aealh̸̡̅ẗ̵̨́d

@ n @h ,a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ आम तौर पर, मैं पुनरावृत्ति की तुलना में समूहों को संतुलित करना चाहता हूं, लेकिन कुछ मामले ऐसे होते हैं, जहां बाद वाले अधिक संक्षिप्त होते हैं। शायद एक दिन मैं रेटिना के लिए .NET रेगेक्स स्वाद को फिर से लागू करूँगा और कुछ अतिरिक्त सुविधाओं में पैच करूँगा। ;)

— मार्टिन एंडर

Answer 4

पवित्र जावास्क्रिप्ट , 1510 बाइट्स

साथी विद्रोही, कोष्ठक के अपने अत्याचारी विध्वंस में नहीं देते हैं! आपको दृढ़ रहना चाहिए! शुरू से, प्रोग्रामिंग एक मुक्त उद्यम रहा है। अब, यह पवित्रता का विकृत प्रदर्शन बन गया है। हमें कुछ भी कम नहीं दिखाना चाहिए, फिर पूर्ण निडरता। इसलिए, मैंने लड़ाई लड़ी है!

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

गैर-लिस्प भाषा में पवित्र पात्रों का उपयोग करने के खिलाफ कोई नियम नहीं। नहीं बिल्कुल नहीं। (थोड़ा कम कॉम्पैक्ट तरीके से :)

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

यह मेरे अन्य उत्तर में विस्तारित जावास्क्रिप्ट का संकलन करता है । यह एक मजाक प्रस्तुत करना है।

Answer 5

लुआ, 222 216 204 201 बाइट्स

golfed:

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)

Ungolfed:

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)

Comments

एक repeat a,b=l(s,g) ... untill a<1पाश अपने समय से कम नहीं होगा ?

— केटेनको

Answer 6

स्कीम, 92 बाइट्स

रियल लिस्प में चौड़ाई-पहली खोज को लागू करने से निराश, ¹ शक्तियां-जो कि अधिक व्यावहारिक दृष्टिकोण लेने का फैसला करती हैं। सब के बाद, कोष्ठक पवित्र हैं, लेकिन कोष्ठक नहीं हैं। ²

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

<sub>1. Emacs के तथाकथित "चर्च" से उन विधर्मियों के लिए नहीं सुनो!
2. वे रैकेट प्रोग्रामर नहीं हैं, हैं?</sub>

Comments

स्कीम को Schism कहा जाएगा: यह कहना कि यह "वास्तविक लिस्प" वास्तविक विधर्म है। और आप कहते हैं कि यह व्यावहारिक है ? एक उत्तर की यह हैक

— स्कीमर

@ कोर्डपम्प और आप दावा करेंगे कि आपका राक्षसी गैर-कार्यात्मक अति सटीक उत्तर ट्रू लिस्प का एक उदाहरण है? यह थोड़ा लंबा, सच हो सकता है, लेकिन जब स्कीम का उत्तर समाप्त हो जाता है, तो यह राइट थिंग होगा!

— xebtl

Answer 7

हास्केल, 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

Answer 8

स्कीम, 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)आप के साथ सौदा नहीं कर सकते हैं इनपुट स्ट्रिंग को इसके स्थान पर रखना होगा। एक पूरी तरह से ungolfed संस्करण यहाँ है ।

संपादित करें: जैसा कि टिप्पणियों में बताया गया है, मैंने उत्तर संस्करणों ()में कोष्ठक को कोष्ठक []में बदल दिया है । यह विशुद्ध रूप से प्रोग्रामिंग और डीबगिंग के दौरान सुविधा के लिए था। अब पोस्ट किया गया संस्करण साथ काम करता है ()।

Comments

+1, लेकिन मुझे समझ नहीं आता कि आप वर्ग कोष्ठक क्यों बदलते हैं। यदि मैं #\[संबंधित कोष्ठक (और अद्यतन परीक्षण) द्वारा '#] को बदल देता हूं , तो यह समस्या के बिना काम करता है। क्या कोई कारण है कि आपने वर्ग को छोड़ दिया है? क्या यह आपके पिछले उत्तर से संबंधित है?

— coredump

@ कोर्डम्प आप बिल्कुल सही हैं। मैं कोष्ठक में बदल गया क्योंकि (ए) पैरेन चरित्र शाब्दिकों ने उत्तर को गड़बड़ कर दिया था। डिबगिंग, आउटपुट (जिसमें सूचियों में बहुत सारे पार्नर्स शामिल होंगे) में ब्रैड्स के साथ बहुत अधिक पठनीय था। फिर मैंने उसे वैसे ही छोड़ दिया। मैं संपादित करूंगा।

— 15

Answer 9

जावास्क्रिप्ट ईएस 6, 244 बाइट्स

गंभीर जवाब (केवल मेरी जानकारी के लिए, फ़ायरफ़ॉक्स पर काम करता है)

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

Answer 10

हासियम , 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);

}