Extract chuỗi bên trong dấu ngoặc lồng nhau

Question

tôi cần phải trích xuất chuỗi từ dấu ngoặc lồng nhau như vậy:

[ this is [ hello [ who ] [what ] from the other side ] slim shady ] 

quả (thứ tự không quan trọng):

This is slim shady 
Hello from the other side 
Who 
What 

Lưu ý, các chuỗi có thể có N dấu ngoặc và chúng sẽ luôn hợp lệ, nhưng có thể hoặc không được lồng nhau. Ngoài ra, chuỗi không phải bắt đầu bằng một khung.

Các giải pháp mà tôi đã tìm thấy trực tuyến cho một vấn đề tương tự đề xuất một regex, nhưng tôi không chắc rằng nó sẽ hoạt động trong trường hợp này.

Tôi đã nghĩ đến việc thực hiện điều này tương tự như cách chúng tôi kiểm tra xem một chuỗi có tất cả dấu ngoặc đơn hợp lệ:

Walk qua chuỗi. Nếu chúng ta thấy một [chúng ta đẩy chỉ mục của nó trên ngăn xếp, nếu chúng ta thấy một], chúng ta chuỗi con từ đó đến vị trí hiện tại.

Tuy nhiên, chúng tôi cần phải xóa chuỗi con đó khỏi chuỗi gốc để chúng tôi không nhận được chuỗi đó như một phần của bất kỳ đầu ra nào. Vì vậy, thay vì đẩy chỉ đẩy chỉ mục vào ngăn xếp, tôi đã nghĩ đến việc tạo một LinkedList khi chúng ta đi cùng, và khi chúng ta tìm thấy [chúng ta chèn Node đó vào LinkedList. Điều này sẽ cho phép chúng ta dễ dàng xóa chuỗi con khỏi LinkedList.

Đây có phải là cách tiếp cận tốt hay có giải pháp sạch hơn, được biết đến không?

EDIT:

'[ this is [ hello [ who ] [what ] from the other [side] ] slim shady ][oh my [g[a[w[d]]]]]' 

nên trở (thứ tự không quan trọng):

this is slim shady 
hello from the other 
who 
what 
side 
oh my 
g 
a 
w 
d 

không gian trắng không quan trọng, đó là tầm thường để loại bỏ sau đó. Điều quan trọng là có thể phân biệt các nội dung khác nhau trong các dấu ngoặc đơn. Hoặc bằng cách tách chúng thành các dòng mới hoặc có danh sách các chuỗi.

Answer 1

Mã này quét văn bản bằng cách nhân vật và đẩy một sản phẩm nào list vào ngăn xếp cho mỗi mở [ và bật các được đẩy lần cuối list từ ngăn xếp cho mỗi lần đóng ].

text = '[ this is [ hello [ who ] [what ] from the other side ] slim shady ]' 

def parse(text): 
    stack = [] 
    for char in text: 
     if char == '[': 
      #stack push 
      stack.append([]) 
     elif char == ']': 
      yield ''.join(stack.pop()) 
     else: 
      #stack peek 
      stack[-1].append(char) 

print(tuple(parse(text))) 

Đầu ra;

(' who ', 'what ', ' hello from the other side ', ' this is slim shady ') 
(' who ', 'what ', 'side', ' hello from the other ', ' this is slim shady ', 'd', 'w', 'a', 'g', 'oh my ') 

Answer 2

Điều này có thể khá thoải mái được giải quyết sử dụng regex:

import re 

s= '[ this is [ hello [ who ] [what ] from the other [side] ] slim shady ][oh my [g[a[w[d]]]]]' 

result= [] 
pattern= r'\[([^[\]]*)\]' #regex pattern to find non-nested square brackets 
while '[' in s: #while brackets remain 
    result.extend(re.findall(pattern, s)) #find them all and add them to the list 
    s= re.sub(pattern, '', s) #then remove them 
result= filter(None, (t.strip() for t in result)) #strip whitespace and drop empty strings 

#result: ['who', 'what', 'side', 'd', 'hello from the other', 'w', 'this is slim shady', 'a', 'g', 'oh my'] 

Answer 3

Bạn có thể đại diện cho trận đấu bằng cách sử dụng một cấu trúc cây như thế nào.

class BracketMatch: 
    def __init__(self, refstr, parent=None, start=-1, end=-1): 
     self.parent = parent 
     self.start = start 
     self.end = end 
     self.refstr = refstr 
     self.nested_matches = [] 
    def __str__(self): 
     cur_index = self.start+1 
     result = "" 
     if self.start == -1 or self.end == -1: 
      return "" 
     for child_match in self.nested_matches: 
      if child_match.start != -1 and child_match.end != -1: 
       result += self.refstr[cur_index:child_match.start] 
       cur_index = child_match.end + 1 
      else: 
       continue 
     result += self.refstr[cur_index:self.end] 
     return result 

# Main script 
haystack = '''[ this is [ hello [ who ] [what ] from the other side ] slim shady ]''' 
root = BracketMatch(haystack) 
cur_match = root 
for i in range(len(haystack)): 
    if '[' == haystack[i]: 
     new_match = BracketMatch(haystack, cur_match, i) 
     cur_match.nested_matches.append(new_match) 
     cur_match = new_match 
    elif ']' == haystack[i]: 
     cur_match.end = i 
     cur_match = cur_match.parent 
    else: 
     continue 
# Here we built the set of matches, now we must print them 
nodes_list = root.nested_matches 
# So we conduct a BFS to visit and print each match... 
while nodes_list != []: 
    node = nodes_list.pop(0) 
    nodes_list.extend(node.nested_matches) 
    print("Match: " + str(node).strip()) 

Kết quả của chương trình sẽ là:

trận đấu: đây là mỏng râm
trận đấu: hello từ phía bên kia
trận đấu: người
trận đấu: những gì

Answer 4

a = '[ this is [ hello [ who ] [what ] from the other side ] slim shady ]' 
lvl = -1 
words = [] 
for i in a: 
    if i == '[' : 
     lvl += 1 
     words.append('') 
    elif i == ']' : 
     lvl -= 1 
    else: 
     words[lvl] += i 

for word in words: 
    print ' '.join(word.split()) 

Điều này cho phép o/p -

này là mỏng râm

chào từ phía bên kia

người gì