def test_empty_after_multiple_pops():
s = Stack()
s.push('hello world')
s.push('multiple values woah')
s.pop()
s.pop()
assert s.top == None
def test_pop_too_many():
letters = Stack()
letters.push('A')
letters.push('B')
letters.push('C')
assert letters.pop() == 'C'
assert letters.pop() == 'B'
assert letters.pop() == 'A'
assert letters.pop() is None
def test_stacks_and_queues_3 ():
stack = Stack()
stack.push('a')
stack.push('b')
stack.push('c')
stack.pop()
actual = stack.top.value
expected = 'b'
assert actual == expected
def test_pop_all():
letters = Stack()
letters.push('A')
letters.push('B')
letters.push('C')
assert letters.pop() == 'C'
assert letters.pop() == 'B'
assert letters.pop() == 'A'
assert print_all(letters) == ''
def test_pop_some():
s = Stack()
s.push("apple")
s.push("banana")
s.push("cucumber")
s.pop()
actual = s.pop()
expected = "banana"
assert actual == expected
def test_stacks_and_queues_4 ():
stack = Stack()
stack.push('a')
stack.push('b')
stack.push('c')
stack.pop()
stack.pop()
stack.pop()
actual = stack.top
expected = None
assert actual == expected
def test_pop_until_empty():
s = Stack()
s.push("apple")
s.push("banana")
s.push("cucumber")
s.pop()
s.pop()
s.pop()
actual = s.is_empty()
expected = True
assert actual == expected
def test_can_successfully_pop_from_a_stack():
new_stack = Stack()
new_stack.push('red')
new_stack.push('orange')
new_stack.push('green')
new_stack.push('blue')
new_stack.pop()
expected = 'green'
actual = new_stack.peek()
assert expected == actual
def test_pop_to_empty():
stck2 = Stack()
stck2.push(9)
stck2.push(8)
stck2.push(10)
stck2.push(11)
stck2.pop()
stck2.pop()
stck2.pop()
stck2.pop()
assert stck2.top == None
assert stck2.is_empty() == True
class PseudoQueue(object):
def __init__(self):
self._stack1 = Stack()
self._stack2 = Stack()
def enqueue(self, val):
self._stack1.push(val)
def dequeue(self):
if not self._stack2.peek():
while self._stack1.peek():
self._stack2.push(self._stack1.pop())
return self._stack2.pop()
def multi_bracket_validation(input):
stack = Stack()
b = {')': '(', ']': '[', '}': '{'}
for i in range(len(input) - 1):
if input[i] in b.values():
stack.push(input[i])
if input[i] in b.keys():
if stack.peek() == b[input[i]]:
stack.pop()
else:
return False
if stack.peek() == None:
return True
else:
return False
def test_can_successfully_empty_a_stack_after_multiple_pops():
new_stack = Stack()
new_stack.push('red')
new_stack.push('orange')
new_stack.push('green')
new_stack.push('blue')
new_stack.pop()
new_stack.pop()
new_stack.pop()
new_stack.pop()
expected = True
actual = new_stack.isempty()
assert expected == actual
def test_pop_stack():
stck2 = Stack()
stck2.push(9)
stck2.push(8)
stck2.push(10)
assert stck2.pop() == 10
assert stck2.top.value == 8
def multi_bracket_validation(input):
'''
Input: string Output: boolean stating True if brackets are balanced in the input string
'''
bracket_tower = Stack()
for char in input:
if char in ['(', '[', '{']:
bracket_tower.push(char)
elif char in [')', ']', '}']:
if bracket_tower.is_empty():
return False
removed_char = bracket_tower.pop()
if char == ')' and removed_char != '(':
return False
elif char == ']' and removed_char != '[':
return False
elif char == '}' and removed_char != '{':
return False
if bracket_tower.is_empty():
return True
return False
class Queue():
def __init__(self):
self.input_stack = Stack()
self.output = Stack()
def enqueue(self, value):
self.input_stack.push(value)
def dequeue(self):
if self.output.peek() is not None:
return output.pop()
if self.input_stack.peek() is not None:
while self.input_stack.peek() is not None:
self.output.push(self.input_stack.pop())
return self.output.pop()
return None
def depth_first(self, start):
visited = []
s = Stack()
s.push(start)
visited.append(start)
while s.is_empty() == False:
curr = s.peek()
flag = False
for neighbor in self.get_neighbors(curr):
if neighbor[0] not in visited and flag == False:
s.push(neighbor[0])
visited.append(neighbor[0])
flag = True
if flag == False:
s.pop()
return visited
class PseudoQueue:
'''
This PseudoQueue class definition can be used to create an instance of a queue data strucsture. It will be composed of nodes and has the methods of enqueue, dequeue, is_empty, and peek. It has attritubes of rear and front. As an additional challenge... this class of PseudoQueues uses two stacks at its implementation layer.
'''
def __init__(self):
self.front_stack = Stack()
self.rear_stack = Stack()
self.front = self.rear = None
def enqueue(self, value=None):
node = Node(value)
if self.rear_stack.top:
self.rear_stack.top.next_node = node
self.rear_stack.top = node
if not self.front_stack.top:
self.front_stack.top = node
self.front = self.front_stack.top
def is_empty(self):
return self.front_stack.is_empty()
def dequeue(self, ):
if self.front_stack.top == self.rear_stack.top:
self.rear_stack.top = None
value = self.front_stack.pop()
print("front stack top is:")
return value
def peek(self):
return self.front_stack.peek()
def bracket_validation(input):
letters= []
s = Stack()
for x in input:
if x is '{' or x is '(' or x is '[':
s.push(x)
if x is '}':
temp=s.peek()
if temp is '{':
s.pop()
else:
return False
if x is ']':
# return True
temp=s.peek()
if temp is '[':
s.pop()
else:
return False
if x is ')':
temp=s.peek()
if temp is '(':
s.pop()
else:
return False
if s.peek() is None:
return True
else:
return False
class PseudoQueue():
def __init__(self):
self.stack1 = Stack()
self.stack2 = Stack()
def enqueue(self, value):
self.stack1.push(value)
def dequeue(self):
while self.stack1.peek():
if self.stack1.top.next == None:
return self.stack1.top.value
else:
temp = self.stack1.pop()
self.stack2.push(temp)
continue
def test_stack_pop():
s = Stack()
s.push('hello world')
s.push('multiple values woah')
s.pop()
assert s.top.value == 'hello world'
def test_pop_empty():
s = Stack()
with pytest.raises(InvalidOperationError) as e:
s.pop()
assert str(e.value) == "Not allowed on empty structure"
def test_pop_single():
s = Stack()
s.push("apple")
actual = s.pop()
expected = "apple"
assert actual == expected
def test_stacks_and_queues_7 ():
stack = Stack()
actual = stack.pop()
expected = None
assert actual == expected
def test_pop():
letters = Stack()
letters.push('A')
letters.push('B')
letters.push('C')
assert letters.pop() == 'C'
def test_stack_pop():
stack3 = Stack()
stack3.push(0)
assert stack3.pop() == 0
assert stack3.top == None
def test_pop_or_peek_empty_stack():
stack = Stack()
with pytest.raises(EmptyStackException):
stack.peek()
with pytest.raises(EmptyStackException):
stack.pop()
def test_pop_empty():
s = Stack()
with pytest.raises(InvalidOperationError) as e:
s.pop()
assert str(e.value) == "Method not allowed on empty collection"
def test_stack_pop_exception():
stack4 = Stack()
with pytest.raises(Exception) as excep:
stack4.pop()
assert "EmptyStack" in excep
def test_empty_stack_pop():
s = Stack()
assert s.pop() == 'this stack is empty buddy'
def test_pop_on_empty_raises_exception():
new_stack = Stack()
expected = 'Exception'
actual = new_stack.pop()
assert expected == actual
