0

私が持っているのは、たとえば次のような文字列です。{[]}{([])}()ループして、開きかっこか閉じかっこかを調べて、リストに追加します。私が今やりたいのは、どれが最も深い嫌悪感であるかを見つけて、それを印刷することです。したがって、この例では真ん中を印刷しますが、{([その方法がわかりません。開いた括弧の先頭を追加してからリセットすることはできますが、それらのいくつかを比較して、最大のものを印刷する方法

私のコード：

def is_nested(str):
    stack = []
    deepest =[]
    index=1
    open=0
    for c in str:
        if c == "{" or c == "(" or c == "[" or c =="<":
            stack.append(c) # this is push
            deepest.append(c)
            open +=1
            index +=1
        elif c == "}":
            x = stack.pop()
            index +=1
            if x != "{":
                index -=1
                x2=parens(x)
                return "False: expected %s at character index %d, but received } instead." %(x2,index)
        elif c == "]":
            x = stack.pop()
            index +=1
            if x != "[":
                index -=1
                x2=parens(x)
                return "False: expected %s at character index %d, but received ] instead." %(x2,index)
        elif c == ">":
            x = stack.pop()
            index +=1
            if x != "<":
                index -=1
                x2=parens(x)
                return "False: expected %s at character index %d, but received > instead." %(x2,index)
        elif c == ")":
            x = stack.pop()
            index +=1
            if x != "(":
                index -=1
                x2=parens(x)
                return "False: expected %s at character index %d, but received ) instead." %(x2,index)

    check(str)
    return True
def check(str):
    deepest =[]
    for c in str:
        if c == "{" or c == "(" or c == "[" or c =="<":
            deepest.append(c)
    print deepest


def parens(x):
    if x == "<":
        return ">"
    elif x =="(":
        return ")"
    elif x == "{":
        return "}"
    elif x == "[":
        return "]"


print is_nested("{[()}")
print is_nested("([)")
print is_nested("{[]({})}")
print is_nested("<()>")
print is_nested("{(<)}")
4

4 に答える 4

2

私があなたの願いを正しく理解しているかどうかはわかりませんが、これは連続する開き括弧の最長のシーケンスを見つけます：

In [20]: import re

In [21]: s = '{[]}{([])}()'

In [22]: max(re.findall("[\(\[\{]+",s),key=len)
Out[22]: '{(['
于 2013-01-29T21:33:20.623 に答える
1

開いている括弧の現在の数を繰り返して更新し、ループ中に持っていた最大値を維持する必要があります。スタックとして使用する文字列にすべての開いたブラケットを配置し、長さが現在の最大長よりも大きい場合は、この文字列で最大を更新できます。

OPEN = "<[({"
CLOSED = ">])}"
def is_nested(str):
    stack = []
    deepest =[]
    for c in str:
        if c in OPEN:
            stack.append(c)
            if len(stack)>len(deepest):
                deepest.append(c)
        elif c in CLOSED:
            x = stack.pop()
            if OPEN.index(x) != CLOSED.index(c):
                return "Error"
    return ''.join(deepest)
于 2013-01-29T20:57:01.860 に答える
0

このようなもの？

def is_nested(nested_str):
    opening = ['(', '{', '[', '<']
    closing = {'(':')','{':'}', '[':']', '<':'>'}
    braces = []
    depth = 0
    max_depth = 0
    max_depth_index = None
    for index, char in enumerate(nested_str):
        if char in opening:
            braces.append(char)
            depth += 1
        elif char == closing[braces[-1]]:
            braces.pop()
            depth -= 1
        else:
            raise ValueError("This is not a valid str")
        if depth > max_depth:
            max_depth = depth
            max_depth_index = index
    return max_depth, max_depth_index

この関数は、中括弧のみの文字列を受け取り、ネストの最も深いレベルと、そのレベルのネストの最初のインスタンスの開始中括弧のインデックスを示します。ボーナスとして、文字列の形式が間違っているとエラーが発生します。

>>> is_nested('{[][]}')
(2, 1)
>>> is_nested('{[][<()()>]()}[]()')
(4, 5)
>>> is_nested('{(})')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "nesting.py", line 16, in is_nested
ValueError: This is not a valid str

ブレース以外の文字をエラーと定義しましたが、else条件を変更することで簡単に変更できます。

于 2013-01-29T21:11:42.770 に答える
0 
def is_nested(in_str):
    stack = []
    deepest = tuple()

    open_b = ('(','[','{','<')
    close_b = (')',']','}','>')

    for i in in_str:
        print stack, i
        if i in open_b:
            stack.append(i)
            if len(stack) > len(deepest):
                deepest = tuple(stack)
        else:
            p = stack.pop()
            print p
            print open_b.index(p)
            print close_b[open_b.index(p)]
            if i != close_b[open_b.index(p)]:
                raise Exception('Wrongly nested')
    if len(stack) > 0:
        raise Exception('Wrongly nested')
    return deepest
于 2013-01-29T21:12:14.897 に答える