class QueueFromStack:
def __init__(self):
self.in_storage = Stack()
self.out_storage = Stack()
def size(self):
return self.in_storage.size() + self.out_storage.size()
def enqueue(self, value):
self.in_storage.push(value)
def dequeue(self):
if self.out_storage.size() == 0:
while self.in_storage.size() != 0:
self.out_storage.push(self.in_storage.pop())
return self.out_storage.pop()
def parentheses_checker(string):
opening_stack = Stack()
closing_stack = Stack()
opening_curly_braces = Stack()
closing_curly_braces = Stack()
for char in string:
if re.match(r'\(', char):
opening_stack.push(char)
elif re.match(r'\)', char):
closing_stack.push(char)
elif re.match(r'\{', char):
opening_curly_braces.push(char)
elif re.match(r'\}', char):
closing_curly_braces.push(char)
if opening_stack.size() == closing_stack.size(
) and opening_curly_braces.size() == closing_curly_braces.size():
return True
return False
def reverseString (my_string):
reverse_str=""
x=Stack()
""" we are using variable x as a stack variable as object of the
previously defined stack class"""
for s in my_string :
x.push(s)
for item in range(x.size()):
reverse_str=reverse_str+x.pop()
return reverse_str
def is_balanced(string):
"""Check that the paranthesis in a strigng are balanced."""
s = Stack()
match_dict = {')': '(', ']': '[', '}': '{'}
for char in string:
if char in match_dict.values():
s.push(char)
elif char in match_dict.keys():
if s.size() == 0:
return print('The paranthesis are not balanced')
elif s.size() != 0 and char != s.peek():
s.pop()
else:
pass
if s.is_empty():
return print('The paranthesis are balanced')
class Deck:
"A bilota deck of cards."
def __init__(self):
self.cards = Stack()
for s in suits:
for r in ranks:
self.cards.push(Card(r, s))
def shuffle(self):
"""Shuffles the Deck only if it has max size."""
if self.cards.size() == 32:
shuffle(self.cards.items)
raise RuntimeError('Only a full Deck can be shuffled.')
def get_card(self):
"""Gets a card from the Deck."""
return self.cards.pop()
def test_size_returns_correct_number_for_many_item_stack(self):
test_obj = Stack()
test_data0 = 'data0'
test_data1 = 'data1'
test_data2 = 'data2'
test_data3 = 'data3'
test_data4 = 'data4'
test_data5 = 'data5'
test_data6 = 'data6'
test_data7 = 'data7'
test_data8 = 'data8'
test_data9 = 'data9'
test_obj.push(test_data0)
test_obj.push(test_data1)
test_obj.push(test_data2)
test_obj.push(test_data3)
test_obj.push(test_data4)
test_obj.push(test_data5)
test_obj.push(test_data6)
test_obj.push(test_data7)
test_obj.push(test_data8)
test_obj.push(test_data9)
self.assertEqual(10, test_obj.size())
def test_size_returns_1_for_1_item_stack(self):
test_obj = Stack()
test_data = 'data1'
test_obj.push(test_data)
self.assertEqual(1, test_obj.size())
self.assertEqual(False, test_obj.is_empty())
def test_size_handles_empty_stack(self):
test_obj = Stack()
self.assertEqual(0, test_obj.size())
self.assertEqual(True, test_obj.is_empty())
