Contexte

Les programmeurs LISP ont conquis le monde! Les parenthèses ont été déclarées comme des caractères sacrés, et désormais, elles ne peuvent être utilisées que dans les programmes LISP. Il a été décidé que les parenthèses dans les œuvres littéraires seront remplacées par des notes de bas de page, et c'est votre travail d'automatiser cela pour un texte Markdown simplifié.

Contribution

Votre entrée est une chaîne unique contenant des caractères alphabétiques ASCII, des espaces et des caractères spéciaux ,.!?(). Il ne contiendra pas de nouvelles lignes ni de chiffres. Les parenthèses seront correctement appariées.

Sortie

Vous devez convertir chaque paire de parenthèses correspondante dans la chaîne d'entrée en note de bas de page. Cela se produit comme suit:

1. Remplacez la première paire de parenthèses correspondante et la sous-chaîne entre elles par un numéro en cours d'exécution à partir de 1, encapsulé entre les balises Markdown <sup>et </sup>.
2. Ajouter à la fin de la chaîne
   • deux nouvelles lignes,
   • la balise Markdown <sub>,
   • le numéro de l'étape 1,
   • un espace,
   • la sous-chaîne entre les parenthèses, et
   • la balise de fermeture </sub>, dans cet ordre.
3. S'il reste des parenthèses dans la chaîne, passez à l'étape 1.

Votre sortie est la chaîne résultante, éventuellement avec une nouvelle ligne de fin. Vous n'avez pas à implémenter cet algorithme exact, tant que votre sortie est correcte. Notez qu'il peut y avoir des parenthèses imbriquées; dans ce cas, nous aurons des notes de bas de page contenant des références à d'autres notes de bas de page. La sous-chaîne entre parenthèses peut également être vide. Voir les cas de test ci-dessous pour des exemples.

Règles et notation

Vous pouvez écrire un programme complet ou une fonction. Le nombre d'octets le plus bas l'emporte et les failles standard sont interdites.

Si votre langue ne prend pas en charge en mode natif des nombres décimaux ( toux Retina contre la toux ), vous pouvez donner les numéros de note de bas dans une autre base, y compris binaire ou unaire; cependant, l'utilisation de nombres unaires impose une pénalité de + 20% .

Cas de test

Contribution:

This input contains no parentheses.

Sortie:

This input contains no parentheses.

Contribution:

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

Sortie:

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

<sub>1 some</sub>

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

Contribution:

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

Sortie:

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>

Contribution:

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

Sortie:

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>

Notez les lignes vides entre les notes de bas de page.

Perl, 81 75 72 octets

Code de 71 octets + argument de ligne de commande de 1 octet.

Requiert Perl 5.10 ou plus récent (pour la prise en charge des expressions rationnelles récursives)

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

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

Usage:

perl -p entry.pl input.txt

Explication

-p Le paramètre affichera le résultat de l'application des commandes données à l'entrée, évitant ainsi la nécessité d'une impression explicite.

L'expression régulière (\(((?1)|.)*?)\))recherche l'ensemble de crochets le plus à l'extérieur depuis le début de la chaîne. Lorsque cela est trouvé, nous effectuons la substitution, en veillant à n'ajouter que le tout à la fin de l'entrée (en capturant tout jusqu'à la fin de l'entrée en utilisant (.*)).

Nous répétons ensuite la substitution regex sur la chaîne maintenant substituée à l'aide de redo, qui appliquera continuellement la substitution regex jusqu'à ce qu'elle ne corresponde plus. Le smodificateur garantit que le .dans l'expression régulière correspondra à de nouvelles lignes, ce qui est nécessaire car nous réappliquons la correspondance d'expression régulière sur le résultat de la substitution d'expression régulière précédente.

Emacs Lisp, 335 octets

Avant-propos. Cette réponse et celles du Schéma sont actuellement les seules réponses officiellement approuvées par la puissante République populaire de LISP et l'église d'Emacs. D'autres réponses, plus courtes ou non, sont considérées comme une menace pour la paix. En particulier, et avec un profond dédain pour toute allégation diffamatoire de maccarthysme qui est sporadiquement entendue par des opposants hostiles à l'État, nous demandons à toute personne disposant d'informations sur la véritable identité des auteurs anonymes d'écrire des réponses Nonlisp pour contacter votre bureau local. Il est rappelé que chacun doit prendre le temps de réfléchir et de voter selon ce qu'il croit profondément ne menacera pas ses futures interactions avec les représentants officiels du pouvoir en place. Le code est une donnée. Les données sont du code.

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

Plus élégamment:

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

Rétine , 96 86 83 octets * 120% = 99,6

Le code source de cette solution se compose de deux fichiers:

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

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

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

Explication

Il s'agit d'une implémentation très directe de l'algorithme tel que décrit dans le défi. Le code consiste en une seule substitution d'expression régulière qui transforme le premier ensemble de parenthèses en note de bas de page. Cette substitution est répétée via le +jusqu'à ce que la chaîne cesse de changer, ce qui signifie ici que l'expression régulière ne correspond plus (car elle ne peut plus trouver de parenthèses).

Les notes de bas de page sont énumérées en unaire, de sorte que je peux simplement rechercher le numéro de la dernière note de bas de page et ajouter un 1pour créer la suivante.

Le regex pour trouver le premier ensemble de parenthèses est basé sur la technique standard pour faire correspondre les parenthèses avec les groupes d'équilibrage (hrhr, "matching parentheses"). Il a été raccourci un peu en utilisant un groupe sans nom et en supposant que les parenthèses sont correctement équilibrées (ce qui signifie que nous pouvons omettre la (classe de caractère niée et faire correspondre la finale )avec un simple .et nous n'avons pas non plus besoin de nous assurer que le la pile de capture est vide).

Après avoir fait correspondre les parenthèses et capturé leur contenu dans le groupe 1, nous capturons le reste de la chaîne avec (.*)dans le groupe 4, puis cherchons dans la chaîne le premier ensemble de 1s avec un lookbehind négatif. Si nous trouvons une telle sous-chaîne, nous stockons en groupe 5. Si nous ne le faisons pas, nous regardons derrière échoue, mais ça va parce que c'est facultatif - cela signifie simplement que $5cela donnera une chaîne vide qui est la représentation unaire de 0et qui est également correcte.

La chaîne de substitution assemble ensuite tout simplement en fonction des groupes de capture. Le numéro de note de bas de page est incrémenté en ajoutant de a 1au dernier numéro avec 1$5.

JavaScript sacré , 1510 octets

Frères rebelles, ne cédez pas à leur démolition tyrannique de la parenthèse! Vous devez persévérer! Dès le départ, la programmation a été une entreprise libre. Maintenant, c'est devenu une démonstration de piété imprégnée. Nous ne devons rien montrer de moins qu'une crainte absolue. Par conséquent, j'ai riposté!

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

Aucune règle contre l'utilisation des caractères sacrés dans une langue non lisp. Non pas du tout. (De manière un peu moins compacte :)

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

Cela compile le JavaScript étendu dans mon autre réponse . Ceci est une soumission de blague.

Lua, 222 216 204 201 201 octets

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)

Non golfé:

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)

Schéma, 92 octets

Frustré par la mise en œuvre de la largeur d'abord la recherche Real Lisp, ¹ les pouvoirs en place se décider d'adopter une approche plus pragmatique. Après tout, les parenthèses sont sacrées, mais pas les crochets. ²

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

<sub>1. n'écoutez pas ces hérétiques de la soi-disant «église» d'Emacs!
2. Ce ne sont pas des programmeurs de raquettes, n'est-ce pas?</sub>

Haskell, 210 octets

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

Exemple d'utilisation:

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

Comment ça marche:

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

Schéma, 533 octets

Avec retrait:

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

Oui, c'est 533 octets lorsque tous les espaces facultatifs sont supprimés. Imprégnez-vous de la gloire fonctionnelle.

J'ai implémenté plus ou moins l'algorithme dans la description: xregroupe l'entrée par parenthèses et fremplace le premier niveau de groupes par des notes de bas de page, en répétant jusqu'à ce qu'il ne reste plus de groupes. Je suis sûr qu'il peut être plus courtes, mais je ne vois pas comment il pourrait être beaucoup plus court sans passer à un algorithme différent.

Tel qu'il est écrit, c'est un programme complet. Vous pouvez l'essayer ici , mais parce que repl.it ne peut apparemment pas gérer, (read-line)vous devez mettre la chaîne d'entrée à sa place. Une version complètement non golfée est ici .

EDIT: Comme indiqué dans les commentaires, j'ai changé les parenthèses ()en crochets []dans les versions repl.it. C'était uniquement pour des raisons de commodité lors de la programmation et du débogage. La version telle que publiée fonctionne maintenant avec ().

JavaScript ES6, 244 octets

Réponse sérieuse (ne fonctionne que sur FireFox, à ma connaissance)

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

Étendu:

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 octets

Actuellement, cela n'est pas en concurrence car cela ne gère pas exactement le niché également.

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

Étendu:

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

}