sfondo

I programmatori LISP hanno conquistato il mondo! Le parentesi sono state dichiarate come personaggi sacri e da ora in poi possono essere utilizzate solo nei programmi LISP. È stato deciso che le parentesi nelle opere letterarie debbano essere sostituite da note a piè di pagina ed è tuo compito automatizzare questo per un testo Markdown semplificato.

Ingresso

Il tuo input è una singola stringa contenente caratteri alfabetici ASCII, spazi e caratteri speciali ,.!?(). Non conterrà nuove righe o cifre. Le parentesi verranno abbinate correttamente.

Produzione

Devi convertire ogni coppia di parentesi nella stringa di input in una nota a piè di pagina. Questo succede come segue:

1. Sostituisci la prima coppia di parentesi corrispondente e la sottostringa tra loro con un numero che parte da 1, racchiuso tra i tag Markdown <sup>e </sup>.
2. Aggiungi alla fine della stringa
   • due newline,
   • il tag Markdown <sub>,
   • il numero dal passaggio 1,
   • Uno spazio,
   • la sottostringa tra parentesi e
   • il tag di chiusura </sub>, in questo ordine.
3. Se nella stringa sono ancora presenti parentesi, andare al passaggio 1.

L'output è la stringa risultante, possibilmente con una nuova riga finale. Non è necessario implementare questo algoritmo esatto, purché l'output sia corretto. Si noti che potrebbero esserci parentesi nidificate; in tal caso, avremo note a piè di pagina che contengono riferimenti ad altre note a piè di pagina. La sottostringa tra parentesi può anche essere vuota. Vedere i casi di test di seguito per esempi.

Regole e punteggio

Puoi scrivere un programma completo o una funzione. Vince il conteggio di byte più basso e non sono consentite scappatoie standard.

Se la tua lingua non supporta nativamente i numeri decimali ( tosse Retina tosse ), puoi dare i numeri delle note a piè di pagina in un'altra base, incluso binario o unario; tuttavia, l'utilizzo di numeri unari comporta una penalità del + 20% .

Casi test

Ingresso:

This input contains no parentheses.

Produzione:

This input contains no parentheses.

Ingresso:

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

Produzione:

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

<sub>1 some</sub>

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

Ingresso:

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

Produzione:

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>

Ingresso:

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

Produzione:

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>

Nota le righe vuote tra le note.

Perl, 81 75 72 byte

Codice 71 byte + argomento riga comandi 1 byte.

Richiede Perl 5.10 o più recente (per supporto regex ricorsivo)

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

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

Uso:

perl -p entry.pl input.txt

Spiegazione

-p Il parametro stamperà il risultato dell'applicazione dei comandi dati all'input, evitando la necessità di una stampa esplicita.

Il regex (\(((?1)|.)*?)\))sta cercando il set di parentesi più esterno dall'inizio della stringa. Quando viene trovato, eseguiamo la sostituzione, assicurandoci di aggiungere solo alla fine dell'input (catturando tutto fino alla fine dell'input usando (.*)).

Quindi ripetiamo la sostituzione regex sulla stringa ora sostituita usando redo, che applicherà continuamente la sostituzione regex fino a quando non corrisponde più. Il smodificatore assicura che .in regex corrisponderà a nuove righe, il che è necessario perché riappliciamo la corrispondenza regex sul risultato della precedente sostituzione regex.

Emacs Lisp, 335 byte

Prefazione. Questa risposta e quelle del Programma sono attualmente le uniche risposte sanzionate ufficialmente sia dalla Mighty Popular Republic of LISP che dalla Church of Emacs. Altre risposte, più brevi o meno, sono considerate una minaccia per la pace. In particolare, e con un profondo disprezzo per qualsiasi accusa calunniosa di maccartismo che è sporadicamente ascoltata da avversari ostili dello stato, raccomandiamo a chiunque disponga di informazioni sulla vera identità degli autori anonimi di scrivere risposte Nonlisp per contattare il proprio ufficio locale. Si ricorda che tutti dovrebbero prendersi del tempo per riflettere e votare secondo quanto crede profondamente che non minaccino le proprie interazioni future con i rappresentanti ufficiali del potere in atto. Il codice è dati. I dati sono codice.

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

Più elegantemente:

(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

Il codice sorgente di questa soluzione è costituito da due file:

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

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

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

Spiegazione

Questa è un'implementazione molto diretta dell'algoritmo come descritto nella sfida. Il codice consiste in una singola sostituzione regex che trasforma la prima serie di parentesi in una nota a piè di pagina. Questa sostituzione viene ripetuta tramite +fino a quando la stringa non smette di cambiare, il che significa che la regex non corrisponde più (perché non trova più parentesi).

Le note a piè di pagina sono elencate in unario, in modo che io possa semplicemente cercare l'ultimo numero della nota a piè di pagina e aggiungere a 1per creare quello successivo.

La regex per trovare la prima serie di parentesi si basa sulla tecnica standard per abbinare le parentesi ai gruppi di bilanciamento (hrhr, "parentesi corrispondenti"). È stato abbreviato un po 'usando un gruppo senza nome e supponendo che le parentesi siano correttamente bilanciate (il che significa che possiamo omettere la (classe di caratteri negata e abbinare la finale )con una semplice .e inoltre non abbiamo bisogno di assicurarci che il lo stack di acquisizione è vuoto).

Dopo aver abbinato le parentesi e acquisito il loro contenuto in gruppo 1, catturiamo il resto della stringa con (.*)in gruppo 4e quindi cerchiamo indietro attraverso la stringa il primo set di 1s con un aspetto negativo. Se troviamo una tale sottostringa, memorizziamo in gruppo 5. Se non lo facciamo, guardiamo dietro fallendo, ma va bene perché è facoltativo - significa solo che $5darà una stringa vuota che è la rappresentazione unaria di 0e che è anche corretta.

La stringa di sostituzione quindi riunisce semplicemente tutto in base ai gruppi di acquisizione. Il numero della nota a piè di pagina viene incrementato anteponendo 1a all'ultimo numero con 1$5.

JavaScript sacro , 1510 byte

Compagni ribelli, non arrendetevi alla loro tirannica demolizione della parentesi! Devi perseverare! Sin dall'inizio, la programmazione è stata un'impresa libera. Ora, è diventato uno spettacolo pervaso di pietà. Non dobbiamo mostrare niente di meno che assoluta paura. Pertanto, ho reagito!

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

Nessuna regola contro l'uso dei caratteri sacri in un linguaggio non Lisp. No, per niente. (In un modo un po 'meno compatto :)

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

Questo si completa con il JavaScript espanso nella mia altra risposta . Questa è una presentazione scherzosa.

Lua, 222 216 204 201 byte

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)

Schema, 92 byte

Frustrato dall'implementare la prima ampia ricerca in Real Lisp, ¹ i poteri che potrebbero decidere di adottare un approccio più pragmatico. Dopotutto, le parentesi sono sacre, ma non le parentesi. ²

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

<sub>1. non ascoltare quegli eretici della cosiddetta "chiesa" di Emacs!
2. Non sono programmatori di racchette, vero?</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#)

Esempio di utilizzo:

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

Come funziona:

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

Schema, 533 byte

Con rientro:

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

Sì, sono 533 byte quando viene rimosso tutto lo spazio bianco opzionale. Crogiolarsi nella gloria funzionale.

Ho implementato più o meno l'algoritmo nella descrizione: xraggruppa l'input tra parentesi e fsostituisce il primo livello di gruppi con note a piè di pagina, ripetendo fino a quando non rimangono più gruppi. Sono sicuro che può essere reso più breve, ma non vedo come potrebbe essere reso molto più breve senza passare a un algoritmo diverso.

Come scritto, è un programma completo. Puoi provarlo qui , ma poiché apparentemente repl.it non può farcela, (read-line)devi mettere la stringa di input al suo posto. Una versione completamente non golfata è qui .

EDIT: Come sottolineato nei commenti, ho cambiato le parentesi ()tra parentesi []nelle versioni repl.it. Questo era puramente per comodità durante la programmazione e il debug. La versione pubblicata ora funziona con ().

JavaScript ES6, 244 byte

Risposta seria (funziona solo su FireFox, per quanto ne so)

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

Allargato:

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 byte

Attualmente non è in competizione poiché non gestisce esattamente anche il nidificato.

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

Allargato:

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

}