La tarea

Una cadena Sse construye con el siguiente proceso:

1. Comienza Ssiendo la cadena vacía.
2. Inserte en alguna posición de Suna cadena de la forma ds, donde des un dígito distinto de cero y ses una cadena de dletras minúsculas ASCII. Decimos que dses un componente de S.
3. Vaya al paso 2 o pare.

Su tarea es tomar una cadena como entrada y generar sus componentes concatenados en una sola cadena, en el orden de aparición de sus dígitos iniciales. La salida debe ser una sola cadena y no puede haber delimitadores (incluidas las nuevas líneas) entre los componentes. Puede elegir si las cadenas de entrada y salida tienen comillas. Tenga en cuenta que la entrada y la salida nunca estarán vacías.

Ejemplo

Construyamos una cadena con el proceso anterior. La estructura de los componentes se destaca en el resultado final.

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
     └┘│└┴┴┘│└┴┘││
       └────┴───┴┘

La salida se obtiene concatenando los componentes en el orden de sus dígitos. En este caso, la salida correcta es

"1x3abc3tty2gh"

Reglas y puntaje

Puede escribir un programa completo o una función. gana el conteo de bytes más bajo y no se permiten las lagunas estándar.

Casos de prueba

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

JavaScript (ES6), 68 bytes

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

Explicación

Basado en un concepto simple:

• Haga coincidir el último dígito nseguido de nletras en la cadena de entrada
• Eliminarlo de la cadena de entrada y agregarlo al inicio de la cadena de salida
• Repita hasta que la cadena de entrada esté vacía

La recursión fue la forma más corta de hacer esto en JavaScript.

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)

Pruébalo en línea! Ejemplo de uso: fst.p $ "1x33ttya2ghbc"rendimientos "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

Pruébalo en línea!

Probablemente no sea la implementación de Python más golfista.

La lógica es casi sencilla: escanea la cadena. Cuando encuentra un dígito, comienza a agregar los caracteres que siguen, tantos como sea necesario (es decir, hasta que el recuento corresponda al dígito). Si encuentra dígitos antes de completar la tarea, los agrega a un contador correspondiente a la cantidad de caracteres a omitir. Cuando el contador llega a cero, vuelve a agregar caracteres (es decir, hasta que el recuento corresponde al dígito inicial).

Nota: se guardaron 14 bytes gracias a Wheat Wizard e HyperNeutrino

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

Explicación:

Pruébalo aquí

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)

Pruébalo en línea!

Explicación:

El código mantiene dos listas de grupos constituyentes, d and D.

Luego se escanea cada carácter de la cadena:

• Si es un dígito, se agrega un nuevo grupo a ambas listas
• De lo contrario, el personaje se agrega al último grupo en d

Cuando un grupo tiene la misma longitud que su dígito, el grupo se elimina de d.

Al final, Dse concatena, ya que los grupos Destán en el orden original.

Ejemplo:

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'