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
"""
# This is wrong
temp1 = Stack()
temp2 = Stack()
temp1.push(stack.pop())
temp1.push(stack.pop())
temp2.push(temp1.pop())
temp2.push(temp1.pop())
stack.push(temp2.pop())
stack.push(temp2.pop())
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_reverse_top_two_doctest2() -> None:
"""This is not the doctest given in reverse_top_two."""
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(4)
reverse_top_two(stack)
assert stack.pop() == 1
assert stack.pop() == 2
assert stack.pop() == 4
assert stack.is_empty()
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 test_peek_general(items: List[int]) -> None:
"""Test that peek works for a large range of stack sizes."""
stack = Stack()
for item in items:
stack.push(item)
assert peek(stack) == items[-1]
assert stack.pop() == items[-1]
def test_peek_doctest() -> None:
"""This is the doctest given in peek."""
stack = Stack()
stack.push(1)
stack.push(2)
assert peek(stack) == 2
assert stack.pop() == 2
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 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
"""
top_most = stack.pop()
second = stack.pop()
stack.push(top_most)
stack.push(second)
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:
item = stack.pop()
stack.push(item)
stack.push(item)
return stack.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
"""
if stack.is_empty():
pass
else:
firstvar = stack.pop()
secondvar = stack.pop()
stack.push(firstvar)
stack.push(secondvar)
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 remove_all_but_one(queue: Queue) -> None:
"""Remove all items from the given queue except the last one.
Precondition: <queue> contains at least one item.
or: not queue.is_empty()
>>> queue = Queue()
>>> queue.enqueue(1)
>>> queue.enqueue(2)
>>> queue.enqueue(3)
>>> remove_all_but_one(queue)
>>> queue.is_empty()
False
>>> queue.dequeue()
3
>>> queue.is_empty()
True
"""
temp = Stack()
while not queue.is_empty():
temp.push(queue.dequeue())
queue.enqueue(temp.pop())