def peek(stack: Stack) -> Optional[Any]:
"""Return the top item on the given stack.
If the stack is empty, return None.
Unlike Stack.pop, this function should leave the stack unchanged when the
function ends. You can (and should) still call pop and push, just make
sure that if you take any items off the stack, you put them back on!
>>> stack = Stack()
>>> stack.push(1)
>>> stack.push(2)
>>> peek(stack)
2
>>> stack.pop()
2
"""
temp1 = Stack()
temp2 = Stack()
if stack.is_empty():
return None
while not stack.is_empty():
temp1.push(stack.pop())
while not temp1.is_empty():
value = temp1.pop()
stack.push(value)
temp2.push(value)
return temp2.pop()
def reverse_top_two(stack: Stack) -> None:
"""Reverse the top two elements on <stack>.
Precondition: <stack> has at least two items.
>>> stack = Stack()
>>> stack.push(1)
>>> stack.push(2)
>>> reverse_top_two(stack)
>>> stack.pop()
1
>>> stack.pop()
2
>>> stack.is_empty()
True
"""
stack_help = Stack()
last_item = stack.pop()
while not stack.is_empty():
stack_help.push(stack.pop())
first_item = stack_help.pop()
stack.push(last_item)
while not stack_help.is_empty():
stack.push(stack_help.pop())
stack.push(first_item)
def test_add_in_order() -> None:
"""Test is the doctest given in add_in_order."""
stack = Stack()
lst = [1, 2]
add_in_order(stack, lst)
results = [stack.pop(), stack.pop()]
assert lst == results
assert stack.is_empty()
stack = Stack()
lst = [1]
add_in_order(stack, lst)
results = [stack.pop()]
assert lst == results
assert stack.is_empty()
def check_params(lines):
parenthesis_stack = Stack()
for idx, line in enumerate(lines):
for cidx, character in enumerate(line):
if character == '(':
parenthesis_stack.push(character)
elif character == ')' and not parenthesis_stack.is_empty():
parenthesis_stack.pop()
elif character == ')' and parenthesis_stack.is_empty():
print(
f'You have are closing a parenthesis without opening one on line {idx} on position {cidx}'
)
return False
if parenthesis_stack.is_empty():
return True
else:
return False
def test_reverse_top_two_doctest() -> None:
"""This is the doctest given in reverse_top_two."""
stack = Stack()
stack.push(1)
stack.push(2)
reverse_top_two(stack)
assert stack.pop() == 1
assert stack.pop() == 2
assert stack.is_empty()
def reverse_top_two(stack: Stack) -> None:
"""Reverse the top two elements on <stack>.
Precondition: <stack> has at least two items.
>>> stack = Stack()
>>> stack.push(1)
>>> stack.push(2)
>>> reverse_top_two(stack)
>>> stack.pop()
1
>>> stack.pop()
2
>>> stack.is_empty()
True
"""
popped = list()
for x in range(0, 2):
if not stack.is_empty():
popped.append(stack.pop())
for x in popped:
stack.push(x)
def peek(stack: Stack) -> Optional[Any]:
"""Return the top item on the given stack.
If the stack is empty, return None.
Unlike Stack.pop, this function should leave the stack unchanged when the
function ends. You can (and should) still call pop and push, just make
sure that if you take any items off the stack, you put them back on!
>>> stack = Stack()
>>> stack.push(1)
>>> stack.push(2)
>>> peek(stack)
2
>>> stack.pop()
2
"""
if stack.is_empty():
return None
else:
top_item = stack.pop()
stack.push(top_item)
return top_item
def reverse_top_two(stack: Stack) -> None:
"""Reverse the top two elements on <stack>.
Precondition: <stack> has at least two items.
>>> stack = Stack()
>>> stack.push(1)
>>> stack.push(2)
>>> reverse_top_two(stack)
>>> stack.pop()
1
>>> stack.pop()
2
>>> stack.is_empty()
True
"""
if stack.is_empty():
pass
else:
firstvar = stack.pop()
secondvar = stack.pop()
stack.push(firstvar)
stack.push(secondvar)
class StackQueue(Container):
"""
An implementation of the class Queue but using Stacks to store the
content.
"""
def __init__(self) -> None:
"""
Initialize this StackQueue.
>>> q = StackQueue()
>>> q.is_empty()
True
"""
# Create 2 stacks as attributes
# self._add_to: This will be the stack that we always add to when
# add() is called.
# self._remove_from: This will be the stack that we use to remove from
# when remove() is called.
self._add_to = Stack()
self._remove_from = Stack()
def add(self, value: object) -> None:
"""
Add value to this StackQueue.
>>> q = StackQueue()
>>> q.add(5)
>>> q.add(3)
>>> q.remove()
5
>>> q.remove()
3
"""
# Simply add to self._add_to for add()
self._add_to.add(value)
def remove(self) -> object:
"""
Remove the item at the front of this StackQueue.
>>> q = StackQueue()
>>> q.add(5)
>>> q.add(3)
>>> q.remove()
5
>>> q.remove()
3
"""
# Empty out self._add_to and put all of the items into self._remove_from
# In this case, you'll be adding the items in reverse order.
# If self._add_to looked like Top -> 4, 3, 2, 1
# Then removing from it would give Top -> 3, 2, 1
# Adding that to self._remove_from would make it Top -> 4
# Removing the next item from self._add_to would make it Top -> 2, 1
# And adding that to self._remove_from would make it Top -> 3, 4
# So by the time self._add_to is empty, self._remove will have the
# items in reverse order.
# Empty our self._add_to
while not self._add_to.is_empty():
# Add the item removed into self._remove_from
self._remove_from.add(self._add_to.remove())
# We remove from self._remove_from to get the 'first item' in our Queue
return_value = self._remove_from.remove()
# And then we put self._add_to back in its original order sans that
# first item (e.g. empty our self._remove_from into self._add_to)
# Empty our self._remove_from
while not self._add_to.is_empty():
# Add the item removed into self._add_to
self._add_to.add(self._remove_from.remove())
return return_value
def is_empty(self) -> bool:
"""
Return whether this StackQueue is empty or not.
>>> q = StackQueue()
>>> q.is_empty()
True
>>> q.add(5)
>>> q.is_empty()
False
"""
# Since we always add to self._add_to, we just return whether that's
# empty or not
return self._add_to.is_empty()
