class MaxStack:
def __init__(self, data=None):
self.stack = Stack()
self.max_stack = Stack()
if data is not None:
self.push(data)
def push(self, data):
self.stack.push(data)
latest_max = self.max_stack.peek()
if latest_max is not None:
if latest_max.data[0] >= data:
node = self.max_stack.pop()
node_data = node.data
node_data[1] += 1
self.max_stack.push(node_data)
else:
self.max_stack.push([data, 1])
else:
self.max_stack.push([data, 1])
def pop(self):
popped_node = self.stack.pop()
latest_max = self.max_stack.peek()
if latest_max is not None:
node = self.max_stack.pop()
node_data = node.data
node_data[1] -= 1
if node_data[1] > 0:
self.max_stack.push(node_data)
return popped_node
def max(self):
latest_max = self.max_stack.peek()
return latest_max.data[0]
def test_peek_empty_stack():
stack = Stack()
with pytest.raises(IndexError) as exc:
stack.peek()
assert str(exc.value) == "peek from empty list"
def all_nearest_smaller_values_v2(a):
"""Compute all nearest smaller values of array a using a Stack."""
r = []
s = Stack()
for ix, x in enumerate(a):
while not s.is_empty() and s.peek()[1] >= x:
s.pop()
if s.is_empty():
r.append((None, None)) # (-1, None)
else:
r.append(s.peek())
s.push((ix, x))
return r
def test_peek():
stk = Stack(5)
stk.push(0)
stk.push(1)
stk.push(2)
stk.push(3)
stk.push(4)
with pytest.raises(IndexError):
stk.peek(5)
assert stk.peek(0) == 0
assert stk.peek(2) == 2
assert stk.peek(4) == 4
def test_push(self):
stack = Stack()
stack.push(1)
self.assertEqual(stack.peek(), 1)
stack.push(50)
self.assertEqual(stack.peek(), 50)
stack.push(30)
self.assertEqual(stack.peek(), 30)
stack.push(70)
self.assertEqual(stack.peek(), 70)
def is_parentheses_balanced(input_string: str) -> bool:
"""Checks a string for balanced brackets of 3 different kinds: (),{},[].
Args:
input_string: a string to be checked
Returns:
True if parenthesis are balanced, False in other case
"""
if input_string is None or not isinstance(input_string, str):
raise ValueError('Incorrect input parameter! Shall be string')
brackets_stack = Stack()
par_dict = {'}': '{', ')': '(', ']': '['}
for char in input_string:
if char in par_dict.values():
brackets_stack.push(char)
elif char in par_dict.keys():
last_element = brackets_stack.peek()
if last_element == par_dict[char]:
brackets_stack.pop()
else:
return False
else:
continue
return brackets_stack.is_empty()
def test_peek():
s = Stack()
s.push("apple")
s.push("banana")
actual = s.peek()
expected = "banana"
assert actual == expected
def test_peek():
stack = Stack()
stack.push("a")
stack.push("b")
assert stack.peek() == "b"
assert len(stack) == 2
def test_change():
stk = Stack(5)
stk.push(0)
stk.push(1)
stk.push(2)
stk.push(3)
stk.push(4)
with pytest.raises(IndexError):
stk.change(5, 5)
stk.change(1, -1)
stk.change(2, -2)
stk.change(4, -4)
assert stk.peek(1) == -1
assert stk.peek(2) == -2
assert stk.peek(4) == -4
def test_push_peek(self):
#Arrange
my_stack = Stack()
my_stack.push(1)
my_stack.push(2)
#Act
peek = my_stack.peek()
#Assert
self.assertEqual(2, peek, "peek did not return expected value")
def test_pop(self):
stack = Stack()
stack.push(1)
stack.push(50)
stack.push(30)
stack.push(70)
self.assertEqual(stack.pop(), 70)
self.assertEqual(stack.pop(), 30)
stack.push(75)
self.assertEqual(stack.peek(), 75)
self.assertEqual(stack.pop(), 75)
self.assertEqual(stack.pop(), 50)
stack.push(876)
self.assertEqual(stack.peek(), 876)
self.assertEqual(stack.pop(), 876)
self.assertEqual(stack.pop(), 1)
def test_pop_item(self):
stack = Stack()
stack.push("item")
assert len(stack) > 0
assert len(stack) == 1
value = stack.pop()
assert value == "item"
assert len(stack) == 0
assert stack.peek() == None
def postfix_calculator(expression: str) -> int:
stack = Stack()
for char in expression.split(" "):
if char.isdigit():
stack.push(int(char))
else:
# I'm assuming that user input is valid. In "real world" project
# it's necessary to check if is a valid operator.
right = stack.pop()
left = stack.pop()
result = eval(f"{left}{char}{right}")
stack.push(result)
return stack.peek()
class TestStack(TestCase):
def setUp(self):
super().setUp()
self.stack = Stack()
def test_pop(self):
self.stack.push(1)
self.stack.push(2)
self.assertEqual(self.stack.pop(), 2)
self.assertEqual(self.stack.pop(), 1)
def test_pop_empty(self):
self.assertIsNone(self.stack.pop())
def test_peek(self):
self.stack.push(1)
self.stack.push(2)
self.assertEqual(self.stack.peek(), 2)
self.stack.pop()
self.assertEqual(self.stack.peek(), 1)
def test_size(self):
self.stack.push(1)
self.stack.push(2)
self.assertEqual(self.stack.size(), 2)
def test_is_empty(self):
self.assertTrue(self.stack.is_empty())
self.stack.push(1)
self.assertFalse(self.stack.is_empty())
self.stack.pop()
def is_balanced(symbols):
"""
>>> is_balanced('([{}])')
True
>>> is_balanced('([]{}())')
True
>>> is_balanced('((()))')
True
>>> is_balanced('(([{])')
False
>>> is_balanced('[}([){]')
False
>>> is_balanced('[')
False
"""
if not isinstance(symbols, str):
raise TypeError('symbols must be a string')
if len(symbols) == 0:
raise ValueError('symbols must have at least one symbol')
stack = Stack()
for symbol in symbols:
if stack.is_empty():
stack.push(symbol)
else:
top_symbol = stack.peek()
if allowed_symbols.get(top_symbol, None) == symbol:
stack.pop()
else:
stack.push(symbol)
if stack.is_empty():
return True
return False
def test_peek_empty():
s = Stack()
with pytest.raises(InvalidOperationError) as e:
s.peek()
assert str(e.value) == "Method not allowed on empty collection"
from data_structures.stack import Stack
size = int(input("Enter the size of the stack: "))
stack = Stack(size)
while True:
choice = int(input("Enter your choice [0 - show menu]: "))
if choice == 0:
print("1. Push element")
print("2. Pop element")
print("3. Peek element")
print("4. Display all elements")
print("Any other number to exit")
elif choice == 1:
element = input("Enter the element to push: ")
stack.push(element)
elif choice == 2:
element = stack.pop()
if element is not None:
print("Element popped is:", element)
elif choice == 3:
element = stack.peek()
if element is not None:
print("Top element is:", element)
elif choice == 4:
stack.display()
else:
print("Exited")
break
def test_peek(self):
stack = Stack()
stack.push('test')
self.assertEqual(stack.peek().data, 'test')
def test_peek_is_none(self):
stack = Stack()
with self.assertRaises(ValueError):
stack.peek()
from data_structures.stack import Stack
# creating a new stack
stack = Stack()
print('Pushing some values into the stack.')
stack.push('A')
stack.push('B')
stack.push('C')
print('Peeking into the stack.')
print(stack.peek())
print('Popping the values from the stack.')
print(stack.pop())
print(stack.pop())
print(stack.pop())
def test_push_item(self):
stack = Stack()
stack.push("item")
assert len(stack) > 0
assert stack.peek() == "item"
