A tarefa

Uma sequência Sé construída com o seguinte processo:

1. Comece Ssendo a string vazia.
2. Insira em alguma posição de Suma seqüência de caracteres do formulário ds, onde dhá um dígito diferente de zero e sé uma sequência de dletras ASCII em minúsculas. Dizemos que dsé um constituinte de S.
3. Vá para o passo 2 ou pare.

Sua tarefa é pegar uma string como entrada e gerar seus componentes concatenados em uma única string, na ordem de aparência dos dígitos iniciais. A saída deve ser uma única sequência e não pode haver delimitadores (incluindo novas linhas) entre os constituintes. Você pode escolher se as seqüências de entrada e saída têm aspas. Observe que a entrada e a saída nunca estarão vazias.

Exemplo

Vamos construir uma string com o processo acima. A estrutura dos constituintes é destacada no 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
     └┘│└┴┴┘│└┴┘││
       └────┴───┴┘

A saída é obtida concatenando os constituintes na ordem de seus dígitos. Nesse caso, a saída correta é

"1x3abc3tty2gh"

Regras e pontuação

Você pode escrever um programa completo ou uma função. a menor contagem de bytes vence e as brechas padrão não são permitidas.

Casos de teste

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

Explicação

Baseado em um conceito simples:

• Corresponde ao último dígito nseguido por nletras na sequência de entrada
• Remova-o da sequência de entrada e adicione-o ao início da sequência de saída
• Repita até que a string de entrada esteja vazia

A recursão foi a maneira mais curta de fazer isso em 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)

Experimente online! Exemplo de uso: fst.p $ "1x33ttya2ghbc"rendimentos "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

Experimente online!

Provavelmente não é a implementação mais eficiente do Python.

A lógica é quase direta: verifica a string. Quando encontra um dígito, ele começa a adicionar os caracteres a seguir, quantos forem necessários (ou seja, até que a contagem corresponda ao dígito). Se encontrar dígitos antes de concluir a tarefa, os adicionará a um contador correspondente ao número de caracteres a serem ignorados. Quando o contador chega a zero, volta a adicionar caracteres (ou seja, até que a contagem corresponda ao dígito inicial).

Nota: salvou 14 bytes graças ao 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;}

Explicação:

Experimente aqui.

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)

Experimente online!

Explicação:

O código mantém duas listas de grupos constituintes d and D,.

Cada caractere da sequência é verificado:

• Se for um dígito, um novo grupo será adicionado às duas listas
• Caso contrário, o caractere é adicionado ao último grupo em d

Quando um grupo tem o mesmo comprimento que seu dígito, o grupo é removido de d.

No final, o Dé concatenado, pois os grupos Destão na ordem original.

Exemplo:

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'