使用堆栈检查Python中的用户输入是否存在任何不平衡的错误

Am需要使用堆栈来检查用户输入中是否存在任何不平衡的括号。代码的逻辑应该使用stack

push

方法向堆栈中添加一个左括号，并在遇到右括号时将其弹出。当开始括号和结束括号不平衡时，代码应中断并打印

括号不平衡

。 我试图用这个代码作弊，但最后一个测试用例把我抓获了

mytext="))((("#this string input is just sample, the real input is captured from user
if(mytext.count(")")!=mytext.count("(")):
    print("The paranthesis are not balanced")
else:
    print("The parenthesis are balanced")

因此，我决定用自己的方法艰难地构建一个堆栈类，我一直在捕获开头括号

“（“

并将其添加到堆栈中，然后扫描输入以查找结尾括号

””

），然后调用pop从堆栈中移除开头括号。我觉得对于输出平衡括号的代码，堆栈应该是空的，对于输出不平衡括号，堆栈应该是空的。代码如下

##First you need to create a stack class
class Stack:
    def __init__(self):
        self.items=[]
    def is_empty(self):
        return self.items==[]
    def push(self,item):
        self.items.insert(0,item)
    def pop(self):
        self.items.pop()#removes last element added
    def print_stack(self):#print function for debugging
        print(self.items)







def balanced(expression):#This function checks whether input from user has balanced parenthesis
    #create a stack object
     mystack=Stack()
    #scan user input for opening bracket and add to stack
    #I need help from this point onwards
    if "(" in expression:#if opening bracket exists in input, i feel like i should iterate through the expression
       mystack.push(0,"(")
    if ")" in expression:#remove the previously added opening bracket
       mystack.pop(0):
     ##implement empty_check and return accordingly
        
print(balanced(input()))

我还觉得我应该使用一个列表来扫描

”（“

从字符串中将它们添加到列表中，扫描相反的语法

”）

并对它们的长度进行一些比较

mytext="))((("#this string input is just sample, the real input is captured from user
if(mytext.count(")")!=mytext.count("(")):
    print("The paranthesis are not balanced")
else:
    print("The parenthesis are balanced")

它失败的原因之一是，它没有检查-

）

不应该出现在

（

）之前

您可以使用的一种简单方法是，创建一个初始值为0的计数器变量。现在在用户字符串和每个

（

do

counter++

&每个

）

do

计数器--

在任何迭代

计数器<0

时中断

现在在循环外部，如果

计数器==0

，则其有效值为else无效

---

示例代码：

mytext="((()()))"

ctr = 0
for c in mytext:
    if c == ')':
        ctr -= 1
    elif c == '(':
        ctr += 1
    print("c={}, ctr={}".format(c,ctr))
    if ctr < 0:
        break
if ctr == 0:
    print("Valid")
else:
    print("Not valid")

mytext=“（（（））”
ctr=0
对于mytext中的c：
如果c=='）'：
ctr-=1
elif c=='（'：
ctr+=1
打印（“c={}，ctr={}”。格式（c，ctr））
如果ctr<0：
打破
如果ctr==0：
打印（“有效”）
其他：
打印（“无效”）

它失败的原因之一是，它没有检查-

）

不应该出现在

（

）之前

您可以使用的一种简单方法是，创建一个初始值为0的计数器变量。现在在用户字符串和每个

（

do

counter++

&每个

）

do

计数器--

在任何迭代

计数器<0

时中断

现在在循环外部，如果

计数器==0

，则其有效值为else无效

---

示例代码：

mytext="((()()))"

ctr = 0
for c in mytext:
    if c == ')':
        ctr -= 1
    elif c == '(':
        ctr += 1
    print("c={}, ctr={}".format(c,ctr))
    if ctr < 0:
        break
if ctr == 0:
    print("Valid")
else:
    print("Not valid")

mytext=“（（（））”
ctr=0
对于mytext中的c：
如果c=='）'：
ctr-=1
elif c=='（'：
ctr+=1
打印（“c={}，ctr={}”。格式（c，ctr））
如果ctr<0：
打破
如果ctr==0：
打印（“有效”）
其他：
打印（“无效”）

您可以尝试以下代码

def check_paranthesis(data):
    stack = []
    pairs = {
        '}': '{',
        ']': '[',
        ')': '('
    }
    for i in data:
        if i in ('(', '[', '{'):
            stack.append(i)
        elif not stack or pairs[i] != stack.pop():
            return False
    
if stack:
        return False
return True


print(check_paranthesis('[()]'))    # True
print(check_paranthesis('[({})]')) # True
print(check_paranthesis('[(})}]'))  # False
print(check_paranthesis('[(])'))  # False
print(check_paranthesis('[()'))  # False
print(check_paranthesis('[(]'))  # False
print(check_paranthesis(']['))  # False
print(check_paranthesis('[['))  # False

想法很简单，继续将左对应项推到堆栈中，当您在表达式中遇到右对应项时，立即弹出堆栈，查看它是否是该方括号/花括号/圆括号对应的右对应项

最后，如果堆栈为空，则表示表达式已平衡。

您可以尝试下面的代码

def check_paranthesis(data):
    stack = []
    pairs = {
        '}': '{',
        ']': '[',
        ')': '('
    }
    for i in data:
        if i in ('(', '[', '{'):
            stack.append(i)
        elif not stack or pairs[i] != stack.pop():
            return False
    
if stack:
        return False
return True


print(check_paranthesis('[()]'))    # True
print(check_paranthesis('[({})]')) # True
print(check_paranthesis('[(})}]'))  # False
print(check_paranthesis('[(])'))  # False
print(check_paranthesis('[()'))  # False
print(check_paranthesis('[(]'))  # False
print(check_paranthesis(']['))  # False
print(check_paranthesis('[['))  # False

想法很简单，继续将左对应项推到堆栈中，当您在表达式中遇到右对应项时，立即弹出堆栈，查看它是否是该方括号/花括号/圆括号对应的右对应项

---

---

最后，如果堆栈为空，则表示表达式是平衡的。

不，只要从左到右扫描字符串并在遇到（）时按下/pop，您可以发布如何执行此操作的代码吗？，请：））好的，您的想法很好。你只需要在循环中对每个字符进行检查，而不是在中检查

。不，只要从左到右扫描字符串，然后在遇到（）时按下/pop，你可以发布如何执行的代码吗？，请：））好的，你的想法很好。您只需在循环中对每个字符执行这些检查，而不是在

中检查

。代码通过了7个测试用例，失败了最后一个测试用例，这是第八个测试用例。让我应用您建议的更改。如果您只在answer@Source_Code_001当然之前没有正确的系统访问权限。代码通过了7个测试用例，失败了最后一个测试用例，这是第八个测试用例。让我应用您建议的更改如果您只在您的网站上发布代码和建议，编辑会更容易answer@Source_Code_001当然之前没有正确的系统访问权限。能否修改为只检查这些类型的括号（“

”）（“您是指一个开括号，如果是，那么它也可以用于打印（“（”）。#False。这个` ` ` `）'）（“您需要在

stack.pop（）之前进行底流检查”

（不需要第一个if）。你可以修改为只检查这些类型的括号

”（“

你是指一个开括号吗，如果是，那么它也适用于

打印（检查（“（”）。#False

。这个` ` ` ` `）呢？（你需要在

stack.pop（）

（不需要第一个if）.