Question

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

(a(b(p(m()()))))

并想要检索子字符串：

a(b(p(m()())))
b(p(m()()))
p(m()())
m()()

任意获取封装括号之间的文本将导致类似以下情况的

a(b(p(m(

这是我计划用于处理此问题的函数的方式：

def get_encapsulated_text(s):
    t = ''
    it = cycle(s)
    count = 0
    for c in it:
        if c is '(':
            print(c)
            while count != 0:
                t += next(it)
                print(t)
                nxt = next(it)
                if nxt is '(':
                    count += 1
                elif nxt is ')':
                    count -= 1

但是它显然进入了无限循环，我不是Pythonista。任何帮助将不胜感激！

我想让它针对一个更复杂的示例，例如：

(x(q(y(w()())(k()()))())(a(z()())(d(f()())())))

预期输出如下：

['x(q(y(w()())(k()()))())(a(z()())(d(f()())()))', 'q(y(w()())(k()()))()', 'y(w()())(k()())', 'w()()', 'k()()', 'a(z()())(d(f()())())', 'z()()', 'd(f()())()', 'f()()']

Answer 1

def get_components(string):
    pairs, comps = [], []
    for i, c in enumerate(string):
        if c == "(":
            pairs.append([i,])
        elif c == ")":
            for p in reversed(pairs):
                if len(p) < 2:
                    p.append(i)
                    comps.insert(0, string[p[0]+1:p[1]])
                    break
    return [x for x in comps if len(x) > 0]

Answer 2

def get_encapsulated_text(text):
    stack = []
    for c in text:
        if c == ')':
            inner = stack.pop()
            if inner:
                yield ''.join(inner)
        for s in stack:
            s.append(c)
        if c == '(':
            stack.append([])

Answer 3

strings = '(a(b(p(m()()))))'
charset = '((((()()))))'

result = []
bisected = len(charset) //2
for i, c in enumerate(strings):
    if c not in charset:
        sub = strings[i: (bisected + len(charset_len) - i + 1)]
        result.append(sub)

print(result)
# ['a(b(p(m()()))))', 'b(p(m()()))))', 'p(m()()))', 'm()()']

Answer 4

def get_substrings(string):
    string = string[1:len(string)-1]
    substrings = []
    while not (')' in string[:3]):
        substrings.append(string)
        string = string[2:len(string)-1]
    return substrings

string = "(a(b(p(m()()))))"
print(get_substrings(string))

#Output: ['a(b(p(m()())))', 'b(p(m()()))', 'p(m()())']

Answer 5

这是一个粗略的草图。我将设置一个增量变量。

increment = 1

然后，我将从a（在第一个括号之后）开始遍历字符串。每次遇到'（'我加1，每次遇到'）'都减去1。当遇到0时，我知道我有匹配的括号。

(a(b(p(m()()))))
1^2 3 4 54543210

有了这些，我就可以取出方括号之间的内容（我现在知道位置）。

a(b(p(m()())))

然后，我将递归调用相同的函数，并执行相同的步骤。然后将该递归调用的输出附加到我拥有的字符串中。

a(b(p(m()())))
 1^2 3 4343210

我们可以在m()()上尝试

m()()
 1010

在这种情况下，它将为我们提供两对匹配的括号。对于更复杂的示例，

x(q(y(w()())(k()()))())(a(z()())(d(f()())()))
 1^2 3 434323 4343212101 2 323212 3 434323210

现在，它可以在其中智能地找到q(y(w()())(k()()))()和a(z()())(d(f()())())。

编辑：我认为应该输入一些内容

def get_encapsulated_text(s):
    count = 0
    t = ""
    for c in s:
      if count != 0:
        t += c
      if c is '(':
        count += 1
      elif c is ')':
        count -= 1;
        if count == 0:
          output = t[:-1]
          t = ""
          if(output != ""):
            print(output)
            get_encapsulated_text(output)

我认为这里的关键只是递归。

智能获取两个字符之间的文本

5 个答案: