任务

通过S以下过程构造字符串：

1. 从...开始 S是空字符串。
2. 插入S格式为的字符串的某个位置ds，其中d是非零数字，并且s是d小写ASCII字母的字符串。我们说ds是一个组成部分的S。
3. 转到步骤2或停止。

您的任务是采用这样的字符串作为输入，并按其前导数字的出现顺序将其组成部分输出为单个字符串。输出必须是单个字符串，并且成分之间不能有任何定界符（包括换行符）。您可以选择输入和输出字符串是否带有引号。请注意，输入和输出永远不会为空。

例

让我们用上述过程构造一个字符串。最终结果突出显示了成分的结构。

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

通过按数字的顺序将组成部分串联在一起来获得输出。在这种情况下，正确的输出是

"1x3abc3tty2gh"

规则和计分

您可以编写完整的程序或函数。最低的字节数为准，并且不允许出现标准漏洞。

测试用例

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

JavaScript（ES6），68个字节

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

说明

基于一个简单的概念：

• 匹配最后一位数字，n后跟n输入字符串中字母
• 从输入字符串中删除它，并将其添加到输出字符串的开头
• 重复直到输入字符串为空

递归是使用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个字节

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)

在线尝试！用法示例：fst.p $ "1x33ttya2ghbc"yields "1x3abc3tty2gh"。

Python 3中，173个 159字节

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

在线尝试！

可能不是最复杂的Python实现。

逻辑几乎很简单：它扫描字符串。当找到一个数字时，它将开始添加随后的字符，并根据需要添加这些字符（即，直到计数与该数字相对应）。如果在完成任务之前遇到数字，则会将它们添加到与要跳过的字符数相对应的计数器中。当计数器达到零时，它返回添加字符（即，直到计数对应于初始数字）。

注意：由于使用了Wheat Wizard和HyperNeutrino，因此节省了14个字节

Java 8，152字节

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

说明：

在这里尝试。

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字节

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)

在线尝试！

说明：

该代码保留了两个组成组列表， d and D。

然后扫描字符串的每个字符：

• 如果是数字，则将一个新组添加到两个列表中
• 否则，将角色添加到最新的组中 d

当组的长度与其数字相同时，将从中删除该组d。

最后，将D串联起来，因为其中的组D按原始顺序排列。

例：

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'