La tâche

Une chaîne Sest construite avec le processus suivant:

1. Commencez par Sêtre la chaîne vide.
2. Insérer à une certaine position d' Sune chaîne du formulaire ds, où dest un chiffre différent de zéro et sest une chaîne de dlettres ASCII minuscules. Nous disons dsest un constituant de S.
3. Passez à l'étape 2 ou arrêtez.

Votre tâche consiste à prendre une telle chaîne en entrée et à sortir ses constituants concaténés en une seule chaîne, dans l'ordre d'apparition de leurs premiers chiffres. La sortie doit être une seule chaîne et il ne peut pas y avoir de délimiteurs (y compris les sauts de ligne) entre les constituants. Vous pouvez choisir si les chaînes d'entrée et de sortie ont des guillemets. Notez que l'entrée et la sortie ne seront jamais vides.

Exemple

Construisons une chaîne avec le processus ci-dessus. La structure des constituants est mise en évidence dans le résultat 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 sortie est obtenue en concaténant les constituants dans l'ordre de leurs chiffres. Dans ce cas, la sortie correcte est

"1x3abc3tty2gh"

Règles et notation

Vous pouvez écrire un programme complet ou une fonction. le nombre d'octets le plus bas l'emporte et les failles standard sont interdites.

Cas de test

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

JavaScript (ES6), 68 octets

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

Explication

Basé sur un concept simple:

• Correspond au dernier chiffre nsuivi de nlettres dans la chaîne d'entrée
• Supprimez-le de la chaîne d'entrée et ajoutez-le au début de la chaîne de sortie
• Répétez jusqu'à ce que la chaîne d'entrée soit vide

La récursivité était le moyen le plus court de le faire 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 octets

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)

Essayez-le en ligne! Exemple d'utilisation: fst.p $ "1x33ttya2ghbc"rendements "1x3abc3tty2gh".

Python 3 , 173 159 octets

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

Essayez-le en ligne!

Probablement pas l'implémentation Python la plus golfique.

La logique est presque simple: elle scanne la chaîne. Lorsqu'il trouve un chiffre, il commence à ajouter les caractères qui suivent, autant que nécessaire (c'est-à-dire jusqu'à ce que le compte corresponde au chiffre). S'il rencontre des chiffres avant de terminer la tâche, il les ajoute à un compteur correspondant au nombre de caractères à ignorer. Lorsque le compteur atteint zéro, il revient à ajouter des caractères (c'est-à-dire jusqu'à ce que le compte corresponde au chiffre initial).

Remarque: enregistré 14 octets grâce à Wheat Wizard et HyperNeutrino

Java 8, 152 octets

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

Explication:

Essayez-le ici.

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 135 octets

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)

Essayez-le en ligne!

Explication:

Le code conserve deux listes de groupes constitutifs, d and D.

Chaque caractère de la chaîne est ensuite scanné:

• S'il s'agit d'un chiffre, un nouveau groupe est ajouté aux deux listes
• Sinon, le caractère est ajouté au dernier groupe de d

Lorsqu'un groupe a la même longueur que son chiffre, le groupe est supprimé de d.

À la fin, le Dest concaténé, car les groupes Dsont dans l'ordre d'origine.

Exemple:

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'