Arka fon

LISP programcıları dünyayı ele geçirdi! Parantezler kutsal karakterler olarak ilan edilmiştir ve bundan sonra sadece LISP programlarında kullanılabilirler. Edebi eserlerde parantezlerin dipnotlarla değiştirilmesine karar verilmiştir ve basitleştirilmiş Markdown metni için bunu otomatikleştirmek sizin işinizdir.

Giriş

Girişiniz alfabetik ASCII karakterleri, boşlukları ve özel karakterleri içeren tek bir dizedir ,.!?(). Yeni satır veya rakam içermez. Parantezler doğru şekilde eşleştirilecektir.

Çıktı

Giriş dizesindeki eşleşen her parantez çiftini dipnot haline getirmelisiniz. Bu şöyle olur:

1. Eşleşen ilk parantez çiftini ve aralarındaki alt 1dizgeyi, Markdown etiketleri arasına sarılmış, başından başlayarak çalışan bir numara <sup>ile değiştirin </sup>.
2. Dizenin sonuna ekle
   • iki yeni hat
   • Markdown etiketi <sub>,
   • 1. adımdaki sayı,
   • bir boşluk,
   • parantez arasındaki alt dize ve
   • </sub>Bu sırayla kapanış etiketi .
3. İpte hala parantez varsa, 1. adıma gidin.

Çıktınız, muhtemelen sonunda izleyen bir yeni satır olan sonuç dizesidir. Çıktınız doğru olduğu sürece bu tam algoritmayı uygulamanız gerekmez. Yuvalanmış parantez olabileceğini unutmayın; Bu durumda, diğer dipnotlara referanslar içeren dipnotlarımız olacaktır. Parantezler arasındaki alt dize de boş olabilir. Örnekler için aşağıdaki test durumlarına bakın.

Kurallar ve Puanlama

Tam bir program ya da bir fonksiyon yazabilirsiniz. En düşük bayt sayısı kazanır ve standart boşluklar izin verilmez.

Diliniz doğal olarak ondalık sayıları desteklemiyorsa ( öksürük Retina öksürüğü ), dipnot numaralarını ikili veya tekli dahil olmak üzere başka bir temelde verebilirsiniz; bununla birlikte, tek sayılı sayılar kullanılması % + 20 ceza verir .

Test Kılıfları

Giriş:

This input contains no parentheses.

Çıktı:

This input contains no parentheses.

Giriş:

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

Çıktı:

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

<sub>1 some</sub>

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

Giriş:

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

Çıktı:

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>

Giriş:

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

Çıktı:

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>

Dipnotlar arasındaki boş satırlara dikkat edin.

Perl, 81 75 72 bayt

71 bayt kodu + 1 bayt komut satırı bağımsız değişkeni.

Perl 5.10 veya daha yenisini gerektirir (özyinelemeli regex desteği için)

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

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

Kullanımı:

perl -p entry.pl input.txt

açıklama

-p parametresi, verilen komutları girişe uygulamanın sonucunu basar ve açık bir baskıya gerek kalmaz.

Düzenli (\(((?1)|.)*?)\))ifade, dizenin başındaki en dıştaki köşeli ayraç kümesini arar. Bu bulunduğunda, değiştirmeyi gerçekleştiririz, yalnızca girişin sonuna ekleyeceğimizden emin oluruz (kullanarak girişin sonuna kadar her şeyi yakalayarak (.*)).

Daha sonra redo, artık eşleşmeyene kadar sürekli düzenli başvuru uygulayacak olan şimdi kullanılan ikameli dizedeki regex ikamesini tekrar ediyoruz . sDeğiştirici olmasını sağlar bu .önceki regex ikamesi sonucuna regex maç yeniden uygulamak çünkü regex gereklidir yeni satırlar maç olacak.

Emacs Lisp, 335 bayt

Önsöz. Bu cevap ve Düzenleme Programları şu anda hem Güçlü LISP Cumhuriyetinin hem de Emacs Kilisesi'nin resmi olarak onayladığı tek cevaplardır. Daha kısa olan veya olmayan diğer cevaplar barış için bir tehdit olarak kabul edilir. Özellikle ve devletin düşmanca muhaliflerinden sporadik bir şekilde duyulan hakaretçi herhangi bir iddiaya aykırı bir şekilde derinlemesine düştüğünde, yerel büronuzla temasa geçmek için Nonlisp cevapları yazan isimsiz yazarların gerçek kimliği hakkında bilgisi olan herkesi seviyoruz. Herkesin, iktidardaki resmi temsilcilerle gelecekteki etkileşimlerini tehdit etmeyeceğine inandığı şeye göre düşünmesi ve yükseltmesi için zaman ayırması gerektiği hatırlatılır. Kod veridir. Veri koddur.

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

Daha zarif:

(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 bayt *% 120 = 99.6

Bu çözümün kaynak kodu iki dosyadan oluşur:

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

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

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

açıklama

Bu, mücadelede tanımlandığı gibi algoritmanın çok doğrudan bir uygulamasıdır. Kod, ilk parantez kümesini dipnot haline getiren tek bir regex ikamesinden oluşur. Bu ikame, +dize değişmeyi bırakana kadar devam eder, bu, burada regex'in artık eşleşmeyeceği anlamına gelir (çünkü başka parantez bulamaz).

Dipnotlar aynı şekilde sıralanmıştır, böylece son dipnotun numarasını arayabilir ve bir 1sonrakini oluşturmak için a ekleyebilirim .

İlk parantez grubunu bulmak için yapılan regex, parantezleri dengeleme gruplarıyla eşleştirmek için standart bir tekniği temel alır (hrhr, "eşleşen parantez"). Adsız bir grup kullanarak ve parantezlerin doğru dengelendiğini farzederek biraz kısaltılmıştır (bu (, reddedilen karakter sınıfından çıkarıp final )ile basit bir şekilde eşleştirilebileceği anlamına gelir .ve ayrıca, yakalama yığını boş).

Parantez eşleşen ve gruba içeriklerini çektikten sonra 1, biz dize kalanını yakalamak (.*)gruba 4ve daha sonra ilk seti için dize üzerinden geri arama 1negatif olan ileriye dönük ile s. Böyle bir alt dize bulursak, grup halinde saklarız 5. Yapmazsak, başarısız gözüküyoruz, ancak sorun yok çünkü isteğe bağlı - bu sadece $5birliğin temsili olan 0ve aynı zamanda doğru olan boş bir dize verileceği anlamına geliyor .

Ornatım dizisi daha sonra yakalama gruplarına bağlı olarak her şeyi bir araya getirir. Dipnot numarası, 1ile son numaraya hazırlanarak artırılır 1$5.

Kutsal JavaScript , 1510 bayt

Asiler, parantezdeki zorba yıkılmalarına teslim olmuyor! Sebat etmelisin! Başlangıçtan itibaren programlama ücretsiz bir girişimdi. Şimdi, dindar bir dindarlık gösterisi haline geldi. Mutlak korkudan daha azını göstermemeliyiz. Bu yüzden geri savaştım!

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

Lisp olmayan bir dilde kutsal karakterlerin kullanılmasına karşı kural yok. Hayır, hiç de değil. (Biraz daha az kompakt bir şekilde :)

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

Bu, diğer cevabımdaki genişletilmiş JavaScript ile derleniyor . Bu bir şaka teslimi.

Lua, 222 216 204 201 bayt

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)

Şema, 92 bayt

Real Lisp'te genişlik birinci araştırmasını uygulamaktan hüsrana uğrayan ¹ güç, daha pratik bir yaklaşım benimsemeye karar verdi. Sonuçta, Parantez kutsaldır, ancak parantez değildir. ²

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

<sub>1. Emacs'ın sözde “kilisesinden” bu sesleri dinlemeyin!
2. Raket programcıları değiller, değil mi?</sub>

Haskell, 210 bayt

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

Kullanım örneği:

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

Nasıl çalışır:

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

Şema, 533 bayt

Girintili:

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

Evet, isteğe bağlı tüm boşluklar kaldırıldığında bu 533 bayttır. Fonksiyonel zaferde bask.

Tanımda algoritma az çok uygulamıştım: xgirişi parantez içine falarak gruplandırıyorum ve ilk grup seviyesini dipnotlarla değiştirerek başka grup kalmayacak şekilde tekrar ediyorum . Daha kısa yapılabileceğinden eminim, ancak farklı bir algoritmaya geçmeden nasıl daha kısa hale getirildiğini göremiyorum .

Yazıldığı gibi, tam bir programdır. Burada deneyebilirsiniz , ancak repl.it görünüşte (read-line)sizinle baş edemediği için giriş dizesini yerine koymak zorundasınız. Tamamen ungolfed versiyonu burada .

EDIT: Yorumlarda belirtildiği gibi, parantezleri repl.it versiyonlarında ()parantez []içinde değiştirdim . Bu sadece programlama ve hata ayıklama sırasındaki kolaylık içindi. Şimdi yayınlanan sürüm ile çalışır ().

JavaScript ES6, 244 bayt

Ciddi cevap (bildiğim kadarıyla sadece FireFox'ta çalışıyor)

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

Expanded:

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 Bayt

Şu anda bu tam anlamıyla iç içe geçmediği için rekabet etmiyor.

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

Expanded:

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

}