Die Aufgabe

Eine Zeichenfolge Swird mit dem folgenden Prozess erstellt:

1. Beginnen Sie damit S, die leere Zeichenfolge zu sein.
2. Fügen Sie an Seiner beliebigen Stelle eine Zeichenfolge des Formulars ein ds, wobei des sich um eine Ziffer ungleich Null und seine Zeichenfolge aus dASCII-Kleinbuchstaben handelt. Wir sagen, dsist ein Bestandteil von S.
3. Fahren Sie mit Schritt 2 fort oder halten Sie an.

Ihre Aufgabe ist es, eine solche Zeichenfolge als Eingabe zu verwenden und ihre Bestandteile, die zu einer einzelnen Zeichenfolge verkettet sind, in der Reihenfolge des Auftretens ihrer führenden Ziffern auszugeben. Die Ausgabe muss eine einzelne Zeichenfolge sein, und zwischen den Bestandteilen dürfen keine Trennzeichen (einschließlich Zeilenumbrüchen) stehen. Sie können wählen, ob die Eingabe- und Ausgabezeichenfolgen Anführungszeichen enthalten. Beachten Sie, dass die Ein- und Ausgabe niemals leer sein wird.

Beispiel

Lassen Sie uns einen String mit dem obigen Prozess konstruieren. Die Struktur der Bestandteile wird im Endergebnis hervorgehoben.

S = ""              // Insert "3abc"
S = "3abc"          // Insert "2gh" after 'a'
S = "3a2ghbc"       // Insert "1x" before '3'
S = "1x3a2ghbc"     // Insert "3tty" after '3'
S = "1x33ttya2ghbc" // Final result
     └┘│└┴┴┘│└┴┘││
       └────┴───┴┘

Die Ausgabe wird durch Verketten der Bestandteile in der Reihenfolge ihrer Ziffern erhalten. In diesem Fall ist die korrekte Ausgabe

"1x3abc3tty2gh"

Regeln und Wertung

Sie können ein vollständiges Programm oder eine Funktion schreiben. Die niedrigste Byteanzahl gewinnt, und Standardlücken sind nicht zulässig.

Testfälle

1k -> 1k
4asdf -> 4asdf
111xyz -> 1z1y1x
8whatever3yes -> 8whatever3yes
8what3yesever -> 8whatever3yes
1x33ttya2ghbc -> 1x3abc3tty2gh
63252supernestedstrings2ok -> 6trings3eds2st5perne2su2ok
9long3yes4lo2ngwords11here -> 9longrdsre3yes4lowo2ng1e1h
9abc8de7fg6hi5jk4lm3o2pq1rstuvwxyzabcdefghijklmnopqrst -> 9abcopqrst8deijklmn7fgdefgh6hizabc5jkwxy4lmuv3ost2pq1r

JavaScript (ES6), 68 Byte

f=s=>s&&f(s.replace(/\d\D+$/,m=>(s=m.slice(0,i=++m[0]),m.slice(i))))+s

Erläuterung

Basierend auf einem einfachen Konzept:

• Entspricht der letzten Ziffer, ngefolgt von nBuchstaben in der Eingabezeichenfolge
• Entfernen Sie es aus der Eingabezeichenfolge und fügen Sie es am Anfang der Ausgabezeichenfolge hinzu
• Wiederholen, bis die Eingabezeichenfolge leer ist

Rekursion war der kürzeste Weg, dies in JavaScript zu tun.

f=s=>
  s&&                        // if the input string is empty, return the empty string
  f(                         // prepend the constituent before it
    s.replace(/\d\D+$/,m=>(  // match the last digit followed by every remaining letter
      s=m.slice(0,n=++m[0]), // set s to the constituent (n followed by n letters)
                             // (we must use s because it is our only local variable)
      m.slice(n)             // replace the match with only the letters after it
    ))
  )+s                        // append the constituent

<input type="text" id="input" value="9long3yes4lo2ngwords11here" />
<button onclick="result.textContent=f(input.value)">Go</button>
<pre id="result"></pre>

Haskell , 89 Bytes

fst.p
p(d:s)|(h,(g,r))<-p<$>span('9'<)s,(a,b)<-splitAt(read[d])$h++r=(d:a++g,b)
p e=(e,e)

Probieren Sie es online! Anwendungsbeispiel: fst.p $ "1x33ttya2ghbc"Erträge "1x3abc3tty2gh".

Python 3 , 173 159 Bytes

k='123456789';y='';i=0
for t in x:
 i+=1
 if t in k:
  y+=t;n=int(t);m=0
  for z in x[i:]:
   if n:  
    if z in k:m+=int(z)+1
    if m<1:y+=z;n-=1
    m-=m>0

Probieren Sie es online!

Wahrscheinlich nicht die golfenste Python-Implementierung.

Die Logik ist fast unkompliziert: Sie scannt die Zeichenfolge. Wenn es eine Ziffer findet, fügt es die folgenden Zeichen so oft hinzu, bis die Zahl der Ziffer entspricht. Wenn es vor Abschluss der Aufgabe auf Ziffern stößt, werden diese zu einem Zähler hinzugefügt, der der Anzahl der zu überspringenden Zeichen entspricht. Wenn der Zähler Null erreicht, werden wieder Zeichen hinzugefügt (dh bis der Zähler der Anfangsziffer entspricht).

Hinweis: Dank Wheat Wizard und HyperNeutrino wurden 14 Byte gespeichert

Java 8, 152 Bytes

s->{String t=s,r="";for(char c;!s.isEmpty();c=t.charAt(0),s=s.replace(t=c+(t.substring(1,c-47)),""),r=t+r)t=s.replaceAll(".*(\\d\\D+$)","$1");return r;}

Erläuterung:

Probieren Sie es hier aus.

s->{                        // Method with String as both parameter and return-type
  String t=s,               //  Temp-String, starting at the input-String
         r="";              //  Result-String, starting empty
  for(char c;!s.isEmpty();  //  Loop as long as the input-String `s` is not empty
                            //    After every iteration:
      c=t.charAt(0),        //     Get the leading digit from `t` as character
      s=s.replace(t=c+(t.substring(1,c-47))
                            //     Set `t` to the last substring (digit + `c` letters),
                  ,""),     //     and remove that sub-string from String `s`
      r=t+r)                //     And add the substring at the start of result-String `r`
    t=s.replaceAll(".*(\\d\\D+$)","$1");
                            //   Get the last digit + everything after it,
                            //   and set this substring to `t`
                            //  End of loop (implicit / single-line body)
  return r;                 //  Return result-String
}                           // End of method

Python 2 , 151 147 135 Bytes

d,D=[],[]
for c in input():
 if'/'<c<':':x=[[c]];d=x+d;D+=x
 else:y=d[0];y+=c;d=d[len(y)>int(y[0]):]
print''.join(''.join(w)for w in D)

Probieren Sie es online!

Erläuterung:

Der Code enthält zwei Listen der Konstituentengruppen d and D.

Jedes Zeichen der Zeichenfolge wird dann gescannt:

• Wenn es sich um eine Ziffer handelt, wird beiden Listen eine neue Gruppe hinzugefügt
• Andernfalls wird der Charakter der neuesten Gruppe in hinzugefügt d

Wenn eine Gruppe dieselbe Länge wie ihre Ziffer hat, wird die Gruppe von entfernt d.

Am Ende wird das Dverkettet, da sich die Gruppen Din der ursprünglichen Reihenfolge befinden.

Beispiel:

Input = '1121xwyzv'
d = [], D = []
Loop each character in the input

c='1'
    d=[[1]], D=[[1]]
c='1'
    d=[[1], [1]], D=[[1], [1]]
c='2'
    d=[[2], [1], [1]], D=[[1], [1], [2]]
c='1'
    d=[[1], [2], [1], [1]], D=[[1], [1], [2], [1]]
c='x'
    d=[[1x], [2], [1], [1]], D=[[1], [1], [2], [1x]]
latest group in d is full:
    d=[[2], [1], [1]], D=[[1], [1], [2], [1x]]
c='w'
    d=[[2w], [1], [1]], D=[[1], [1], [2w], [1x]]
c='y'
    d=[[2wy], [1], [1]], D=[[1], [1], [2wy], [1x]]
latest group in d is full:
    d=[[1]], D=[[1], [1], [2wy], [1x]]
c='z'
    d=[[1z], [1]], D=[[1], [1z], [2wy], [1x]]
latest group in d is full:
    d=[[1]], D=[[1], [1z], [2wy], [1x]]
c='v'
    d=[[1v]], D=[[1v], [1z], [2wy], [1x]]
latest group in d is full:
    d=[], D=[[1v], [1z], [2wy], [1x]]
print D in order:
    '1v1z2wy1x'