Buradaki zorluk, bir programın girişindeki bazı parantezleri gösterildiği gibi genişletmektir:

1. Bir dize bul lar iki eşleşen parantez [ve ]tek haneli bir ile, n ayraç sonra.
2. Destekleri çıkarın.
3. N defalarca tekrarlanan s ile değiştirin . ( N 0 ise, basitçe s'yi kaldırın .)
4. Girişte eşleşen parantez bulunmayana kadar adım 1'e gidin.

Ek kurallar ve açıklamalar:

• İzin verilen herhangi bir yöntemle girdi alacak ve çıktı vereceksiniz.
• Çıktıdaki takip eden yeni satıra izin verilir.
• Girişte yalnızca yazdırılabilir ASCII'yi kullanmanız gerekir.
• Sen girişi alabilir asla yani tüm parantez maç varsayabiliriz []]]]ya [[[[].
• Her kapatma braketinin ]ondan bir rakamı olduğunu varsayabilirsiniz .

Test durumları:

Input                -> Output
[Foo[Bar]3]2         -> FooBarBarBarFooBarBarBar
[one]1[two]2[three]3 -> onetwotwothreethreethree
[three[two[one]1]2]3 -> threetwoonetwoonethreetwoonetwoonethreetwoonetwoone
[!@#[$%^[&*(]2]2]2   -> !@#$%^&*(&*($%^&*(&*(!@#$%^&*(&*($%^&*(&*(
[[foo bar baz]1]1    -> foo bar baz
[only once]12        -> only once2
[only twice]23456789 -> only twiceonly twice3456789
[remove me!]0        -> 
before [in ]2after   -> before in in after

Bu kod golf olduğu için, her dilde en kısa cevap kazanır. İyi şanslar!

Gema , 17 karakter

[#]?=@repeat{?;#}

Örnek çalışma:

bash-4.4$ gema '[#]?=@repeat{?;#}' <<< '[three[two[one]1]2]3'
threetwoonetwoonethreetwoonetwoonethreetwoonetwoone

Retina , 24 23 22 bayt

+`\[([^][]*)](.)
$2*$1

Çevrimiçi deneyin! Bu pratik olarak Retina 1'de yerleşiktir. Düzenleme: @Kobi sayesinde 1 bayt kaydedildi. Retina 0.8.2'deki 47 45 bayt:

].
]$&$*¶
{+`\[([^][]*)]¶
$1[$1]
\[([^][]*)]

Çevrimiçi deneyin!

Haskell , 101 96 bayt

fst.(""%)
infix 4%
s%']':d:r=(['1'..d]>>s,r)
s%'[':r|(t,q)<-""%r=s++t%q
s%x:r=s++[x]%r
s%e=(s,e)

Çevrimiçi deneyin! Diğer cevapların çoğu gibi düzenli ifadeler kullanmak yerine, özyinelemeli bir çözümleyici uygular.

BMO sayesinde -5 bayt !

Perl 5 , 34 33 29 + 1 ( -p) = 30 bayt

s/.([^[]*?)](.)/$1x$2/e&&redo

Çevrimiçi deneyin!

@Shaggy ve @TonHospel'in yardımlarıyla kesin.

Japt v2 , 21 20 19 bayt

@Shaggy sayesinde 2 bayt kaydedildi

e/.([^[]*?)](./@YpZ

Çevrimiçi test edin!

eözyinelemeli ikamedir; bu, bir daha hiçbir eşleşme olmadıkça bir seferde bir değişiklik yapar. Bu durumda, regex'in eşleşmeleri, /\[([^[]*?)](\d)/gbaşka eşleşme bulunmayana kadar <iç metin> tekrarlanan <dijit> zamanları ile değiştirilir.

Planladığım şeye göre ( burada ), bu regex sonunda en az 3 2 bayt daha kısa olmalıdır:

‹[“⁽[»₋”]“.›

JavaScript, 71 67 66 bayt

Ben vardı bir 54 bayt çözümü ancak ikinci test durumu tarafından ele becerdiIer! :(

f=s=>s!=(x=s.replace(/.([^[]*?)](.)/,(_,y,z)=>y.repeat(z)))?f(x):x

Test Kılıfları

f=s=>s!=(x=s.replace(/.([^[]*?)](.)/,(_,y,z)=>y.repeat(z)))?f(x):x
o.innerText=`[Foo[Bar]3]2
[one]1[two]2[three]3
[three[two[one]1]2]3
[!@#[$%^[&*(]2]2]2
[[foo bar baz]1]1
[only once]12
[only twice]23456789
[remove me!]0
before [in ]2after`.split`\n`.map(x=>x.padEnd(22)+`:  `+f(x)).join`\n`

<pre id=o></pre>

Python 3 , 110 93 92 bayt

import re
f=lambda s:f(re.sub(r'\[([^][]+)\](.)',lambda m:m[1]*int(m[2]),s))if'['in s else s

Çevrimiçi deneyin!

Pizzapants sayesinde -17 byte184 -1 byte Kevin Cruijssen sayesinde

Scala , 173 bayt

l.foreach{x=>def r(c:String):String={val t="""\[([^\[\]]*)\](.)""".r.unanchored;c match{case t(g,h)=>r(c.replaceAllLiterally(s"[$g]$h",g*h.toInt));case _=>c}};println(r(x))}

Çevrimiçi deneyin!

Expanded:

l.foreach { x =>
  def remove(current: String): String = {
    val test ="""\[([^\[\]]*)\](.)""".r.unanchored
    current match {
      case test(g, h) => remove(current.replaceAllLiterally(s"[$g]$h", g * h.toInt))
      case _ => current
    }
  }

  println(remove(x))
}

Eski çözüm

Scala , 219 215 213 212 199 bayt

l.foreach{x=>def r(c:String):String={"""\[([^\[\]]*)\](.)""".r.findFirstMatchIn(c).map{x=>val g=x.group(1);val h=x.group(2).toInt;r(c.replaceAllLiterally(s"[$g]$h",g*h))}.getOrElse(c)};println(r(x))}

Çevrimiçi deneyin!

Expanded:

l.foreach { x =>
  def remove(current: String): String = {
    """\[([^\[\]]*)\](.)""".r.findFirstMatchIn(current).map { x =>
      val g = x.group(1)
      val h = x.group(2).toInt
      remove(current.replaceAllLiterally(s"[$g]$h", g * h))
    }.getOrElse(current)
  }
  println(remove(x))
}

L işleyeceğimiz dizgelerin listesi nerede?

-1 Bayt için teşekkürler Kevin Cruijssen

Kullanılmayan bir parametreyi kaldırarak 212'den 199'a gitti, dikkat etmedi.

Yığılmış , 39 38 bayt

Shaggy sayesinde 1 bayt kurtarıldı, regex'i golf oynadı!

['\[([^[\]]+)](.)'{.y x:x#~y*}recrepl]

Çevrimiçi deneyin!

Basitçe '\[([^[\]]+)](.)'tekrarlı bir şekilde bir regex tekrarlama kuralı ile değiştirir .

Python 3, 155 148 101 97 bayt

def f(x):
 a=x.rfind('[')
 if~a:b=x.find(']',a);x=f(x[:a]+x[a+1:b]*int(x[b+1])+x[b+2:])
 return x

Çevrimiçi Deneyin

-47 bayt için HyperNeutrino ve Mego ve -4 bayt için user202729'a teşekkürler.

JavaScript - 77 75 72 bayt

f=a=>a.replace(/(.*)\[([^[]*?)](.)(.*)/,(a,b,c,d,e)=>f(b+c.repeat(d)+e))

Düzenleme: Shaggy'nin tavsiyesiyle regex güncellendi

Parça, parçacık:

const test = ["[Foo[Bar]3]2", "[one]1[two]2[three]3", "[three[two[one]1]2]3", "[!@#[$%^[&*(]2]2]2", "[[foo bar baz]1]1", "[only once]12", "[only twice]23456789", "[remove me!]0", "before [in ]2after"];

const f=a=>a.replace(/(.*)\[([^[]*?)](.)(.*)/,(a,b,c,d,e)=>f(b+c.repeat(d)+e))

d.innerHTML=test.map(f).join("<br>");

<p id="d">

Argüman ile QuadR≡ , 30 28 bayt

\[[^[]+?].
∊(⍎⊃⌽⍵M)⍴⊂1↓¯2↓⍵M

Çevrimiçi deneyin!

\[[^[]+?]. " [non- [stuff ]karakter" yerine

¯2↓⍵M son iki karakteri damla M atch ( " ]basamaklı ')
1↓ (' birinci karakter damla [")
⊂ kuşatmaktadırlar bir bütün olarak tedavi edilecek olan
(... )⍴ r : uzunluğuna eshape
 ⌽⍵M ters M atch
 ⊃ birinci (basamak) çekme
 ⍎ değerlendirmek
∊ ε (nlist düzleştirmek)

≡ daha fazla değişiklik olmaz kadar tekrarla

Eşdeğer Dyalog APL işlevi 47 bayttır:

'\[[^[]+?].'⎕R{∊(⍎⊃⌽⍵.Match)⍴⊂1↓¯2↓⍵.Match}⍣≡

Çevrimiçi deneyin!

Java 8, 250 249 241 239 bayt

s->{for(;s.contains("[");)for(int i=0,j,k;i<s.length();)if(s.charAt(i++)==93){String t="",r=t;for(j=k=s.charAt(i)-48;j-->0;)t+=s.replaceAll(r="(.*)\\[([^\\]]+)\\]"+k+"(.*)","$2");s=k<1?t:s.replaceFirst(r,"$1$3").replace("",t);}return s;}

@JonathanFrech sayesinde -2 bayt (kod, aşağıdaki TIO-linkinde görülebilen, şimdi yazdırılamayan iki ASCII karakteri içerir).

Çek ... Java regex ile çok sınırlı .. Burada kendimi başka bir cevaptan alıntı yapacağım:

Değiştirme WWWWile 222WJava kolaydır ancak birlikte 4Wdeğil .. yalnızca Java şey için normal ifade yakalama grubunu kullanmak için bir yol .. ile uzunluğu alınıyor olsaydı "$1".length(), maçı kendisi yerine "$1".replace(...), bir tam sayıya maç dönüştürme new Integer("$1")veya kullanarak Retina'ya benzer bir şey (yani s.replaceAll("(?=(.)\\1)(\\1)+","$#2$1"))veya JavaScript (yani s.replaceAll("(.)\\1+",m->m.length()+m.charAt(0))) gelecekte Java'da codegolfing'den faydalanmak için görmek istediğim 1 numaralı şeyim olacaktı.>. Yakalama grubu eşleşmesine sahip herhangi bir şey ..
Buradan alıntı yapın.

Açıklama:

Çevrimiçi deneyin.

s->{                           // Method with String as both parameter and return-type
  for(;s.contains("[");)       //  Loop as long as the String contains a block-bracket
    for(int i=0,j,k;i<s.length();)
                               //   Inner loop over the characters of the String
      if(s.charAt(i++)==93){   //    If the current character is a closing block-bracket:
        String t="",r=t;       //     Create two temp-Strings, starting empty
        for(j=k=s.charAt(i)-48;//     Take the digit after the closing bracket
            j-->0;)            //     Loop that many times:
          t+=s.replaceAll(r="(.*)\\[([^\\]]+)\\]"+k+"(.*)","$2");
                               //      Append `t` with the word inside the block brackets
        s=k<1?                 //     If the digit was 0:
           t                   //      Replace the input with an empty String as well
          :                    //     Else:
           s.replaceFirst(r,"$1$3").replace("",t);}
                               //      Replace the word between brackets by `t`,
                               //      and remove the digit
  return s;}                   //  Return the modified input-String as result

Wolfram Dili (Mathematica) , 86 bayt

#//.s_:>StringReplace[s,"["~~x:Except["["|"]"]...~~"]"~~d_:>""<>x~Table~FromDigits@d]&

Çevrimiçi deneyin!

C, 407 368 bayt

Bayt tasarrufu için Jonathan Frech'e teşekkürler.

golf oynadı (bracket.c):

i,j,k,l,n;char*f(a,m)char*a;{for(i=0;a[i];++i){a[i]==91&&(j=i+1);if(a[i]==93){k=a[i+1]-48;if(!k){for(l=i+2;l<m;)a[++l-i+j-4]=a[l];a=realloc(a,m-3);return f(a,m-3);}for(l=j;l<i;)a[~-l++]=a[l];for(l=i+2;l<m;)a[++l-4]=a[l];m-=3;n=m+~-k*(i---j--);a=realloc(a,n);for(l=i;l<m;)a[l+++~-k*(i-j)]=a[l];for(m=0;m<k;++m)for(l=j;l<i;)a[l+++m*(i-j)]=a[l];return f(a,n);}}return a;}

program ile bağlanmamış:

#include <stdlib.h>
#include <stdio.h>

// '[' = 133
// ']' = 135
// '0' = 48

i, j, k, l, n;

char* f(a,m) char*a;
{
  for (i=0; a[i]; ++i) {
    a[i]==91&&(j=i+1);

    if (a[i]==93) {
      k=a[i+1]-48;

      if (!k) {
        for (l=i+2; l<m; )
          a[++l-i+j-4] = a[l];

        a = realloc(a,m-3);
        return f(a,m-3);
      }
      for (l=j;l<i;)
        a[~-l++] = a[l];
      for (l=i+2; l<m; )
        a[++l-4] = a[l];
      m -= 3;
      n = m+~-k*(i---j--);
      a = realloc(a,n);

      for (l=i; l<m; )
        a[l+++~-k*(i-j)] = a[l];
      for (m=0; m<k; ++m)
        for (l=j; l<i;)
          a[l+++m*(i-j)] = a[l];

      return f(a,n);
    }
  }
  return a;
}

int main()
{
  char c[]="[Foo[Bar]3]2";
  char *b;

  char cc[]="[remove me!]0";
  char *bb;

  char ccc[]="[only once]12";
  char *bbb;

  b=malloc(13);
  bb=malloc(14);
  bbb=malloc(14);

  for (i=0; i<13; ++i)
    b[i] = c[i];

  for (i=0; i<14; ++i)
    bb[i] = cc[i];

  for (i=0; i<14; ++i)
    bbb[i]=ccc[i];

  printf("%s\n", f(b, 13));
  printf("%s\n", f(bb, 14));
  printf("%s\n", f(bbb, 14));

  return 0;
}

Gcc 5.4.1 ile derlenmiş, gcc bracket.c

Kırmızı , 147 bayt

f: func[t][a: charset[not"[]"]while[parse t[any a some[remove["["copy h any a"]"copy d a](insert/dup v: copy""h to-integer d)insert v | skip]]][]t]

Ungolfed:

f: func [t][
    a: charset [not "[]"]                          ; all chars except [ and ]
    while [ parse t [                              ; repeat while parse is returning true
        any a                                      ; 0 or more chars other than [ and ]
        some [                                     ; one or more block:
            remove ["[" copy h any a "]" copy d a] ; remove the entire block, store the
                                                   ; substring between the [] in h,
                                                   ; the digit into d
            (insert/dup v: copy "" h to-integer d) ; makes d copies of h 
            insert v                               ; and inserts them in place 
            | skip ]                               ; skip if no match
        ]                                       
    ][]                                            ; empty block for 'while'
    t                                              ; return the modified string
]

Red'in Ayrıştırma lehçesini yalnızca dün öğrenmeye başladım, bu yüzden kodumun daha da geliştirilebileceğinden eminim. Ayrıştırma, regex'ten çok daha ayrıntılı, ancak çok açık, esnek ve okunabilir ve Kırmızı dilin geri kalanıyla serbestçe karıştırılabilir.

Çevrimiçi deneyin!

Jöle , 30 bayt

œṡ”]µḢUœṡ”[ẋ€1¦Ṫ©Ḣ$FṚ;®
Çċ”]$¡

Çevrimiçi deneyin!

Açıklama.

œṡ”]µḢUœṡ”[ẋ€1¦Ṫ©Ḣ$FṚ;®    Helper link 1, expand once.
                           Assume input = "ab[cd]2ef".

œṡ      Split at first occurence of
  ”]      character "]".
    µ   Start new monadic chain. Value = "ab[cd","2ef".

Ḣ       Ḣead. "ab[cd"
 U      Upend. "dc[ba"
  œṡ”[  Split at first occurence of "[". | "dc","ba".

ẋ€        Repeat ...
  1¦        the element at index 1...
          by ...
    Ṫ Ḣ$    the Ḣead of the Ṫail of ...
          the input list ("ab[cd","2ef") (that is, 2)

          The command Ḣ also pop the head '2'. The remaining
            part of the tail is "ef".
     ©    Meanwhile, store the tail ("ef") to the register.

          Current value: "dcdc","ba"
FṚ        Flatten and Ṛeverse. | "abcdcd"
  ;®      Concatenate with the value of the register. "abcdcdef"

Çċ”]$¡    Main link.

 ċ”]$     Count number of "]" in the input.
     ¡    Repeatedly apply...
Ç           the last link...
            that many times.

C, 381 bayt

Kompakt versiyon:

while(1){int t=strlen(i);int a,c=-1;char*w;char*s;char*f;while(c++<t){if(i[c]==']'){int k=c-a;w=calloc((k--),1);memcpy(w,&i[a+1],k);s=calloc((t-c-1),1);memcpy(s,&i[c+2],t-c-2);i[a]=0;int r=i[c+1]-48;if(r==0){f=calloc(t,1);sprintf(f,"%s%s",i,s);}else{f=calloc((t+k),1);sprintf(f,"%s%s[%s]%d%s",i,w,w,r-1,s);}free(i);i=f;break;}else if(i[c]=='[')a=c;}free(w);free(s);if(c>=t)break;}

Tam versiyon:

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

void proceed(char* input)
{
  while(1)
  {
    int t=strlen(input);
    int start,cursor=-1;
    char* word;
    char* suffix;
    char* final;
    while(cursor++<t)
    {
      if(input[cursor]==']')
      {
        int wordlength = cursor-start;
        word=calloc((wordlength--),sizeof(char));
        memcpy(word, &input[start+1], wordlength );
        suffix=calloc((t-cursor-1),sizeof(char));
        memcpy( suffix, &input[cursor+2], t-cursor-2 );
        input[start]='\0';
        int rep=input[cursor+1]-'0';
        if(rep==0)
        {
          final=calloc(t,sizeof(char));
          sprintf(final,"%s%s",input,suffix);
        }
        else
        {
          final=calloc((t+wordlength+5),sizeof(char));
          sprintf(final,"%s%s[%s]%d%s",input,word,word,rep-1,suffix);
        }
        free(input);
        input=final;
        break;
      }
      else if(input[cursor]=='[')
        start=cursor;
    }
    free(word);
    free(suffix);

    if(cursor>=t)break;
  }
}

int main()
{
  char* input=calloc(256,sizeof(char));
  sprintf(input,"a[[toto]2b]2[ana]3");
  printf("in : %s\n",input);
  proceed(input);
  printf("out: %s\n",input);
  return 0;
}

Python, 80 bayt

import re
b=re.sub
s=lambda x:eval(b(r"\](.)",r"')*\1+'",b(r"\[","'+('","%r"%x)))

Çevrimiçi deneyin!

s("[Foo[Bar]3]2")Dönüştürür [Foo[Bar]3]2için ''+('Foo'+('Bar')*3+'')*2+''ve değerlendirir.

Köşeli parantez içindeki girdi girişi başarısız (örn. [']3)