Question

假设我有一个这样的字符串：

string = [+++[>>[--]]]abced

现在我想要一个返回列表：[[--],[>>],[+++]]。这是最深[嵌套的内容，然后是其他嵌套。我想出了这样的解决方案：

def string = "[+++[>>[--]]]"
loop = []
temp = []
string.each {
    bool = false
    if(it == "["){
        temp = []
        bool = true
    }
    else if( it != "]")
        temp << it 
    if(bool)
         loop << temp

}
println loop.reverse()

但是这确实在最后abced之后取]字符串并输入结果！但我想要的只是[[--],[>>],[+++]]

有没有任何巧妙的解决方法？

Answer 1

如果你不介意使用递归

，你可以使用它

def sub(s , list){
    if(!s.contains('[') && !s.contains('[')) 
        return list
    def clipped = s.substring(s.lastIndexOf('[')+1, s.indexOf(']'))
    list.add(clipped)
    s = s - "[$clipped]"
    sub(s , list)
}

调用

sub('''[+++[>>[--]]]abced''' , [])

返回括号之间所有子部分的列表。

['--', '>>', '+++']

Answer 2

如果括号是对称的，您可以引入一个保持括号嵌套深度的计数器变量。输出中只允许高于0的深度级别：

def string = "[+++[>>[--]]]abc"
loop = []
temp = []
depth = 0;
string.each {
  bool = false
  if(it == "["){
    temp = []
    bool = true
    depth++;
  }   
  else if (it == "]"){
    depth--;
  }   
  else if (depth > 0){ 
    temp << it  
  }   
  if(bool){
    loop << temp
  }   
}
println loop.reverse()

Answer 3

class Main {

    private static final def pattern = ~/([^\[]*)\[(.+?)\][^\]]*/

    static void main(String[] args) {
        def string = "[+++[>>[--]]]abced"

        def result = match(string)
        println result

    }

    static def match(String val) {
        def matcher = pattern.matcher(val);

        if (matcher.matches()) {
            return matcher.group(1) ? match(matcher.group(2)) + matcher.group(1) : match(matcher.group(2))
        }
        [val]
    }
}

System.out

[--, >>, +++]

可能会改进正则表达式模式中第一组的捕获。现在第一组是任何不是[的字符，如果第一组[前面没有任何内容，则第一组将包含空字符串。

我怎样才能找到内嵌的内容？

3 个答案: