Ihre Herausforderung besteht darin, einige Klammern in der Eingabe eines Programms wie folgt zu erweitern:

1. Suchen Sie eine Zeichenfolge s zwischen zwei übereinstimmenden Klammern [und ]mit einer einzelnen Ziffer n nach der schließenden Klammer.
2. Entfernen Sie die Halterungen.
3. Ersetzen Sie s durch sich selbst n- mal wiederholt . (Wenn n 0 ist, entferne einfach s .)
4. Fahren Sie mit Schritt 1 fort, bis die Eingabe keine übereinstimmenden Klammern mehr enthält.

Zusätzliche Regeln und Erläuterungen:

• Sie nehmen Input und geben Output mit allen erlaubten Mitteln.
• Ein Zeilenumbruch in der Ausgabe ist zulässig.
• Sie müssen nur druckbares ASCII in der Eingabe behandeln.
• Sie können davon ausgehen, dass alle Klammern übereinstimmen, dh Sie erhalten niemals die Eingabe []]]]oder [[[[].
• Sie können davon ausgehen, dass ]hinter jeder schließenden Klammer eine Ziffer steht.

Testfälle:

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

Da dies Codegolf ist , gewinnt die kürzeste Antwort in jeder Sprache. Viel Glück!

Gema , 17 Zeichen

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

Probelauf:

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

Retina , 24 23 22 Bytes

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

Probieren Sie es online! Dies ist praktisch in Retina 1 eingebaut. Bearbeiten: 1 Byte dank @Kobi gespeichert. 47 45 Bytes in Retina 0.8.2:

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

Probieren Sie es online!

Haskell , 101 96 Bytes

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)

Probieren Sie es online! Anstatt reguläre Ausdrücke wie die meisten anderen Antworten zu verwenden, wird ein rekursiver Parser implementiert.

-5 Bytes dank BMO !

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

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

Probieren Sie es online!

Reduzieren Sie es mit Hilfe von @Shaggy und @TonHospel.

Japt v2 , 21 20 19 Bytes

2 Bytes dank @Shaggy gespart

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

Online testen!

eist rekursives Ersetzen, dh es wird jeweils ein Ersatz erstellt, bis keine Übereinstimmungen mehr vorhanden sind. In diesem Fall werden Übereinstimmungen des regulären Ausdrucks /\[([^[]*?)](\d)/gdurch <innerer Text> ersetzt, die <Ziffern> Male wiederholt werden, bis keine Übereinstimmungen mehr vorhanden sind.

Nach meinem Plan ( hier ) sollte dieser reguläre Ausdruck mindestens 3 bis 2 Byte kürzer sein:

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

JavaScript, 71 67 66 Bytes

Ich hatte eine 54-Byte-Lösung, aber sie wurde durch den zweiten Testfall beschädigt! :(

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

Testfälle

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 Bytes

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

Probieren Sie es online!

-17 Bytes dank pizzapants184 -1 Bytes dank Kevin Cruijssen

Scala , 173 Bytes

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

Probieren Sie es online!

Erweitert:

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

Alte Lösung

Scala , 219 215 213 212 199 Bytes

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

Probieren Sie es online!

Erweitert:

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

Wobei l die Liste der Zeichenfolgen ist, die wir verarbeiten werden.

Vielen Dank an Kevin Cruijssen für -1 Byte

Ging von 212 bis 199 durch Entfernen eines nicht verwendeten Parameters, achtete nicht darauf.

Gestapelt , 39 38 Bytes

Dank Shaggy 1 Byte gespart, Regex golfen!

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

Probieren Sie es online!

Ersetzt einfach rekursiv einen regulären Ausdruck '\[([^[\]]+)](.)'durch die Wiederholungsregel.

Python 3, 155 148 101 97 Bytes

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

Probieren Sie es online

Danke an HyperNeutrino und Mego für -47 Bytes und user202729 für -4 Bytes.

JavaScript - 77 75 72 Bytes

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

Bearbeiten: Regex mit Shaggys Empfehlung aktualisiert

Snippet:

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

QuadR mit dem ≡Argument, 30 28 Bytes

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

Probieren Sie es online!

\[[^[]+?]. Ersetzen Sie " [non- [stuff ]character" durch

¯2↓⍵M die letzten beiden Zeichen des Tropfens M atch ( „ ]digit‚)
1↓ fallen das erste Zeichen (‘ [“)
⊂ einschließen als Ganzes behandelt zu werden
(... )⍴ r eshape auf Länge:
 ⌽⍵M Umkehren der M atch
 ⊃  die erste (die Ziffer) Wählen
 ⍎ auszuwerten
∊ ε nlist ( ebnen)

≡ Wiederholen, bis keine Änderungen mehr vorgenommen werden

Die äquivalente Dyalog APL-Funktion ist 47 Bytes:

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

Probieren Sie es online!

Java 8, 250 249 241 239 Bytes

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

-2 Bytes dank @JonathanFrech (Code enthält jetzt zwei nicht druckbare ASCII-Zeichen, die im TIO-Link unten zu sehen sind).

Seufz ... Java mit Regex ist so verdammt begrenzt. Ich zitiere mich einfach aus einer anderen Antwort hier:

Ersetzen WWWWmit 222Wist in Java einfach, aber 4Wnicht. Wenn nur Java die Möglichkeit hätte, die Regex-Erfassungsgruppe für etwas zu verwenden. Ermitteln der Länge mit "$1".length(), Ersetzen der Übereinstimmung durch "$1".replace(...), Konvertieren der Übereinstimmung in eine Ganzzahl mit new Integer("$1")oder Verwenden von Etwas Ähnliches wie Retina (dh s.replaceAll("(?=(.)\\1)(\\1)+","$#2$1"))oder JavaScript (dh s.replaceAll("(.)\\1+",m->m.length()+m.charAt(0)))) wäre meine Nummer 1, die ich in Zukunft gerne in Java sehen würde, um das Codegolfing zu fördern alles mit dem Capture-Group-Match ..
Zitat von hier.

Erläuterung:

Probieren Sie es online aus.

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 Language (Mathematica) , 86 Byte

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

Probieren Sie es online!

C 407 368 Bytes

Vielen Dank an Jonathan Frech für das Speichern von Bytes.

golfed (dateiklammer.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;}

ungolfed mit programm:

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

Kompiliert mit gcc 5.4.1, gcc bracket.c

Rot , 147 Bytes

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
]

Ich habe erst gestern angefangen, Reds Parse-Dialekt zu lernen, daher bin ich sicher, dass mein Code weiter verbessert werden kann. Parse ist unvergleichlich ausführlicher als Regex, aber es ist sehr klar, flexibel und lesbar und kann frei mit dem Rest der roten Sprache gemischt werden.

Probieren Sie es online!

Gelee , 30 Bytes

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

Probieren Sie es online!

Erläuterung.

œṡ”]µḢ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 Bytes

Kompakte Version:

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

Vollversion:

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

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

Probieren Sie es online!

s("[Foo[Bar]3]2")Konvertiert [Foo[Bar]3]2zu ''+('Foo'+('Bar')*3+'')*2+''und wertet aus.

Eingabe mit Anführungszeichen in Klammern schlägt fehl (z. B. [']3)