Balanced Parentheses Python DataStructures Project

Question

Project: Parentheses are balanced, if all opening parentheses have their corresponding closing parentheses.
Someone please help! I'm stuck in this test.
There are a total of seven test cases. Five of them are correct but two of them are not going well in any way.
Can anyone explain what's wrong with my code?
Here's my code:
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):
return self.items.pop(0)
def stack(self):
return self.items
def balanced(expression):
s = Stack()
for i in expression:
if i == '(':
s.push(i)
if i == ')':
if s.stack()[0] == '(':
s.pop()
else:
s.push(i)
if not s.stack():
return True
else:
return False

Answer 1

You have to check if '(' or opening bracket is in the stack in every element, not just in the first element.
If there is no '(' in stack, it will automatically become False because it means that ')' was found but there was no '(' that would pair it, i.e. not balance.
If this is still unclear please feel free to ask. Thanks.
https://code.sololearn.com/cWYv4qILZT90/?ref=app

Answer 2

class stack:
def __init__(self):
self.items = []
def push(self,item):
self.items.insert(0,item)
def pop(self):
return self.items.pop(0)
def __call__(self):
return self.items
def balanced(expression):
# your code goes here
x = stack()
for char in expression:
if char == '(':
x.push(char)
if char == ')':
if '(' in x():
x.pop()
else:
return False
if not x():
return True
return False
print(balanced(input()))

Answer 3

class stack: # defining the stack class
def __init__(self):
self.items = []
def is_empty(self): # returns true if self.items is empty
return self.items == []
def push(self, item): # adds item to the stack
self.items.insert(0, item)
def pop(self): # removes item from the stack
return self.items.pop(0)
def __str__(self): # makes stack printable
return "|%s|" %(' | '.join([f'"{item}"' for item in self.items]))
def __call__(self): # makes stack callable as a function like a list
return self.items
# keep in mind that you can still implement all of the stack functionality without creating a class.
def balanced(expression): # balanced function
paren = stack() # initialize
for char in expression: # iterate through expression to filter out parentheses
if char == '(':
paren.push(char) # push opening parenthesis to stack
if char == ')':
if '(' in paren():
paren.pop() # pop from stack if stack is not empty
else:
return False # return false if pop attempted on empty stack
if not paren():
return True # return true if stack is empty
return False # return false if an opening parenthesis is found
if __name__ == "__main__": # the main function
print(balanced(input()))
this code worked for me. added comments for easy reading

Answer 4

This code work for all cases, pay attention to the indexerror exception
def balanced(expression):
#your code goes here
bracket_stack = []
for char in expression:
if char == "(":
bracket_stack.insert(0, char)
elif char == ")":
try:
bracket_stack.pop(0)
except IndexError:
return False
return bracket_stack == []
print(balanced(input()))

Answer 5

If input() == ')' :
s.stack()[0] instruction will raise an IndexError: list index out of range.
Since we only push the left parenthesis into the list, we just need to check whether there is a left parenthesis still in the items, when the right parenthesis appears.

Answer 6

#write exactly like this:
def balanced(expression):
#your code goes here
s=[]
for i in expression:
if i not in "()":
continue
if i =='(':
s.insert(0,i)
else:
if not s:
return False
else:
s.pop(0)
return not s
print(balanced(input()))

Answer 7

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(0)
def print_stack(self):
print(self.items)
def balanced(expression):
#your code goes here
s = Stack()
for i in expression:
if i == "(":
s.push("i")
elif i ==")":
if s.is_empty():
return False
else:
s.pop()
return s.is_empty()
print(balanced(input()))
I tried to use only the functions from the Stack class. Hope it helps!

Answer 8

class stack: # defining the stack class
def __init__(self):
self.items = []
def push(self, item): # adds item to the stack
self.items.insert(0, item)
def pop(self): # removes item from the stack
return self.items.pop(0)
def __call__(self): # makes stack callable as a function like a list
return self.items
def balanced(expression): # balanced function
paren = stack() # initialize
for char in expression: # iterate through expression to filter out parentheses
if char == '(':
paren.push(char) # push opening parenthesis to stack
if char == ')':
if '(' in paren():
paren.pop() # pop from stack if stack is not empty
else:
return False # return false if pop attempted on empty stack
if not paren():
return True # return true if stack is empty
return False # return false if an opening parenthesis is found
print(balanced(input()))

Answer 9

def balanced(expression):
result = None
stack = []
try:
for x in expression:
if x == "(":
stack.insert(0,x)
elif x == ")":
stack.pop(0)
except IndexError:
result = False
else:
if len(stack) == 0:
result = True
else:
result = False
return result
print(balanced(input())
Hope it helps someone? :)

Answer 10

This one is tricky.

Answer 11

def balanced(expression):
#your code goes here
item = []
for i in expression:
if i == '(':
item.insert(0,i)
if i == ')':
if '(' in item:
item.pop()
else:
return False
return not item
print(balanced(input()))

Answer 12

def balanced(expression):
if expression.count('(')==expression.count(')'):
print('True')
else:
print('False')
balanced(input())
SHALL WE CAN USE THIS CODE???

Answer 13

it can be solved just by using the normal list as suggested in the hint:
def balanced(expression):
#your code goes here
list = []
for i in expression:
if(i == "(" ):
list.insert(0,i)
if(i == ")"):
if "(" in list:
list.pop(0)
else:
list.insert(0,i)
if(len(list)!=0):
return("False")
else:
return("True")
print(balanced(input()))

Answer 14

def balanced (expression):
if balanced:
return("True")
else:
return("False")
print(balanced(input()))
*this is correct only for Test Case #1 and #4

Answer 15

def balanced(expression):
lists=[]
p=0
for i in expression :
if i == "(" :
lists.insert(0, i)
elif i == ")" and lists!=[] :
lists.pop(0)
elif i == ")" and lists==[] :
p+=1
return lists==[] and p==0
print(balanced(input()))

Answer 16

def balanced (expression):
s = []
for el in expression:
if el == "(":
s.insert(0, el)
if el == ")":
if "(" in s:
s.pop()
else:
return False
if s:
return False
else:
return True
print(balanced(input()))

Answer 17

def balanced(expression):
#your code goes here
item = []
for i in expression:
if i == '(':
item.insert(0,i)
if i == ')':
if '(' in item:
item.pop()
else:
return False
if item:
return False
else:
return True
print(balanced(input()))

Answer 18

Here is my code , This satisfies 6 out of 7 cases but fail in seventh test case, What is the issue?? Help
class stack:
def __init__(self):
self.items = [] # creating a list
def is_empty(self):
return self.items == [] # creating a function to check whether the stack is empty
def push(self, item):
self.items.insert(0, item) # pushing an item to the top of the stack
def pop(self):
self.items.pop(0) # popping the item from the top of the stack
def print_stack(self):
print(self.items)
def balanced(expression):
op_para = stack() # creating a stack to keep opening paranthesis
k = False
for items in expression:
if items == "(":
op_para.push("(")
for i in expression:
if i == ")":
k = True
if op_para.is_empty() and not k:
return True
for items in expression:
if not op_para.is_empty():
if items == ")":
op_para.pop()
elif items == ")":
return False
if op_para.is_empty():
return True
else:
return False
print(balanced(input()))

Answer 19

SO MY Answer is
def balanced(expression):
#your code goes here
bracket_stack = []
for char in expression:
if char == "(":
bracket_stack.insert(0, char)
elif char == ")":
try:
bracket_stack.pop(0)
except IndexError:
return False
return bracket_stack == []
print(balanced(input()))

Answer 20

class Stack:
def __init__(self):
self.items = []
def is_empty(self):
return self.items == []
def push(self,items):
self.items.insert(0,items)
def pop(self):
return self.items.pop(0)
def array(self):
return self.items
def balanced(expression):
s = Stack()
for x in expression:
if x == '(':
s.push(x)
if x == ')':
if '(' in s.array():
s.pop()
else:
return False
# array must be [] (harus kosong arraynya)
if s.array()== []:
return True
else:
return False
print(balanced(input("Masukan expresi => ")))