编写一个程序（通过标准输入或命令行）以递归形式接收字符串

PREFIX[SUFFIXES]

哪里

• PREFIX 可以是任何小写字母（az）字符串，包括空字符串，并且
• SUFFIXES可以是递归形式PREFIX[SUFFIXES]连接在一起的任何字符串序列，包括空序列。

通过递归求值每个后缀中的字符串列表并将它们附加到前缀，从输入生成一个小写字母字符串列表。输出以任何顺序输出此列表中的字符串，每行一个（加上可选的尾随换行符）。

例

如果输入是

cat[s[up[][]][]ch[e[r[]s[]]]a[maran[]comb[]pult[[]ing[]]]]

那么前缀是cat和和后缀s[up[][]]，[]， ch[e[r[]s[]]]，和a[maran[]comb[]pult[[]ing[]]]。每个后缀都有自己的前缀和后缀。

输出将是任意顺序的这9个字

catsup
cats
cat
catcher
catches
catamaran
catacomb
catapult
catapulting

因为输入对这棵树进行了编码

通过从根到叶遍历树可以形成9个输出字中的每一个。

笔记

• 请记住，前缀可能是空字符串，所以类似

  [donut[][]cruller[]]
  

  是有效输入，其输出将是（任何顺序）

  donut
  
  cruller
  

  空行用于第二个后缀匹配的空字符串。

• 后缀序列也可以为空，因此平凡的输入大小写

  []
  

  有一个空行作为其输出：

• 您可以假设输入将仅产生唯一的输出字。
  • 例如hat[s[]ter[]s[]]将是无效的输入，因为它hats被编码了两次。
  • 同样，[[][]]无效，因为空字符串被编码两次。
• 您可能不会假定输入尽可能短或压缩。
  • 例如，'e'上面主要示例中的'ch'节点可以与该节点组合，但这并不意味着输入无效。
  • 同样，[[[[[]]]]]尽管仅对空字符串进行了次优编码，但仍然有效。
• 代替程序，您可以编写一个函数，该函数将输入字符串作为参数并正常打印输出或将其作为字符串或列表返回。

以字节为单位的最短代码获胜。

红宝石，119 115

t=['']
l=[0]
gets.chars{|c|c<?]?t<<''&&(l<<0)[-2]+=1:c<?^?(x=l.pop;t.pop==''&&(puts t*''if x<1;t[-1]='')):t[-1]<<c}

例

试试看：http : //ideone.com/NW0CNB

描述

程序从stdin获取输入，并将结果输出到stdout。

它遍历树，将当前分支保留在堆栈中。还有一个不同的堆栈，称为堆栈，weights用于跟踪每个节点的子代数。为了确定节点是否确实是叶子，或者它过去有子节点，这是必需的。

可读程序：

stack = ['']
weights = [0]

gets.chars do |c|
  case c
  when '['
    weights[-1] += 1
    stack << ''
    weights << 0
  when ']'
    last_weight = weights.pop

    if stack.pop == ''
      puts stack.join if last_weight < 1
      stack[-1] = ''
    end
  else
    stack[-1] << c
  end
end

Haskell，125个字节

t=tail.p
p=g.break(=='[')
g(a,(_:t))=(:)&(map(a++).z)$t#[]
z[]=[""];z x=x
(']':u)#a=u:a
s#a=(#)&(a++)$p s
(g&f)(x:y)=g x$f y

该函数是t（用于遍历）：

λ: t "cat[s[up[][]][]ch[e[r[]s[]]]a[maran[]comb[]pult[[]ing[]]]]"
["catsup","cats","cat","catcher","catches","catamaran","catacomb","catapult","catapulting"]
λ: t "[donut[][]cruller[]]"
["donut","","cruller"]
λ: t "[[[[[]]]]]"
[""]

Java，206字节

定义一个函数，该函数接受字符串作为参数并返回字符串列表。要获得额外的奖励，它会以与问题相同的顺序返回字符串。

int c,i;List a(String a){String b=a.substring(c,c=a.indexOf(91,c));List d=new ArrayList();for(;a.charAt(++c)!=93;)d.addAll(a(a));if(d.isEmpty())d.add("");for(i=0;i<d.size();)d.set(i,b+d.get(i++));return d;}

用法示例：

class A{
    public static void main(String[] args){
        System.out.println(new A.a("cat[s[up[][]][]ch[e[r[]s[]]]a[maran[]comb[]pult[[]ing[]]]]"));
    }

    int c,i;List a(String a){String b=a.substring(c,c=a.indexOf(91,c));List d=new ArrayList();for(;a.charAt(++c)!=93;)d.addAll(a(a));if(d.isEmpty())d.add("");for(i=0;i<d.size();)d.set(i,b+d.get(i++));return d;}
}

展开：

int c, i;
List a(String a){
    String b = a.substring(c, c = a.indexOf(91, c));
    List d = new ArrayList();
    for(; a.charAt(++c) != 93 ;)
        d.addAll(a(a));
    if (d.isEmpty())
        d.add("");
    for (i = 0; i < d.size();)
        d.set(i, b + d.get(i++));
    return d;
}

我明天将添加一个解释。

Python，212个字符

def p(t,f="",o="",d=0):
 if[]==t:return
 b=[""]
 for c in t:d+=c=="[";b[-1]+=c;d-=c=="]";b+=[""]*(d==0)*(c=="]")
 for r in b[:-1]:i=r.index("[");w,s=f+r[:i],r[i:][1:-1];p(s,w);o+= ["",w+"\n"][""==s]
  if o:print o,

我希望能达到200岁以下，但我对此仍然感到非常满意。

Javascript ES6，142个字节

s=>(o=[],x=_=>s[0]==']'?s=s.slice(1):0,(g=d=>{while(s&&!x())[o[d],s]=s.split(/\[(.*)/).concat``,x()?console.log(o.join``):g(d+1),o.pop()})(0))

问：70个字节

f:{,/'$({(z_x),y}\[();{`$x@&~x="]"}'w;-b])@-1+&0<b:(+/"]"=)'w:"["\:x}

定义一个函数f，它接受一个字符串并返回一个字符串列表（单词）

作为lambda（匿名函数），我们删除了前两个字符f :，因此长度为68个字节

测试

f "cat[s[up[][]][]ch[e[r[]s[]]]a[maran[]comb[]pult[[]ing[]]]]"

（“ catsup”；“ cats”；“ cat”；“ catcher”；“ catching”；“ catamaran”；“ catacomb”；“ catapult”；“ catapulting”））

f "[donut[][]cruller[]]"

（“甜甜圈”;“”;“ cruller”）

f "[[[[[]]]]]"

，”

笔记

，“”表示仅包含空字符串的字符串列表

符号是原子的。在堆栈中压入/弹出符号是一个简单的操作，不受符号长度的影响（请参阅说明）

说明

Q是APL（kx.com）的表亲

伪代码：

• 在“ [”字符处分割字符串（arg x）。w中的结果（字符串列表）
• 在每个元素中计算“]”字符。的 结果为b
• 修改w中的每个项目以滤除字符“]”并将每个字符串转换为符号
• 生成逻辑序列（位图）以标记b中的> 0项
• 使用堆栈迭代部分结果：如果标记了项目，则必须删除多个符号之一（根据b中的值）。始终将实际符号附加到堆栈
• 迭代后，我们拥有堆栈的所有中间状态。我们选择先前标记的状态
• 最后，对于每个结果，我们将符号转换为字符串并将其连接起来

眼镜蛇-181

def f(s='')as String*
    for m in RegularExpressions.Regex.matches(s,r'(\w*)\[((?:(?<B>\[)|\w|(?<-B>]))*)](?(B)(?!))'),for r in.f('[(u=m.groups)[2]]'),yield'[u[1]]'+r
    if''==s,yield''