def construct_parse_tree(expression):
operators = ['(', ')', '+', '-', '*', '/']
# expr_list = expression.split()
parse_tree = BinaryTree(None)
current_tree = parse_tree
path = Stack()
path.push(parse_tree)
for token in expression:
if token == '(':
current_tree.insert_left(' ')
path.push(current_tree)
current_tree = current_tree.get_left()
elif token not in operators:
try:
current_tree.set_root(int(token))
current_tree = path.pop()
except ValueError:
raise ValueError("Token '{0}' is not a valid integer".format(token))
elif token == ')':
current_tree = path.pop()
elif token in operators:
current_tree.set_root(token)
path.push(current_tree)
current_tree.insert_right(' ')
current_tree = current_tree.get_right()
return parse_tree
def generate_workout(n: int):
pyramid = Stack()
data_file = open("generator/data.json")
data = json.load(data_file)
#apilando
start_stack = time.perf_counter()
for i in range(n):
exercise = random.choice(data["random_exercises"])
pyramid.push(exercise)
if (i % 10000 == 0):
print("batch", i)
end_stack = time.perf_counter()
#desapilando
start_unstack = time.perf_counter()
while (pyramid.size > 0):
current_exercise = pyramid.pop()
if (pyramid.size % 10000 == 0):
print("se han desapilado: ", (n - pyramid.size))
end_unstack = time.perf_counter()
print(f"Stack time in {end_stack-start_stack:0.4f} seconds")
print(f"Unstack time in {end_unstack-start_unstack:0.4f} seconds")
def check_parentheses(symbol_string):
s = Stack()
balanced = True
index = 0
matcher = {
'}': '{',
']': '[',
')': '(',
}
while index < len(symbol_string) and balanced:
symbol = symbol_string[index]
if symbol in ['(', '[', '{']:
s.push(symbol)
elif symbol in [')', ']', '}']:
if s.is_empty() or matcher[symbol] != s.peek():
balanced = False
else:
s.pop()
index = index + 1
if balanced and s.is_empty():
return True
else:
return False
class MaxStack(Stack):
def __init__(self) -> None:
super().__init__()
self.max_stack = Stack()
def peek(self):
return super().peek()
def push(self, item: Any):
if self.max_stack.empty():
self.max_stack.push(item)
else:
self.max_stack.push(max(item, self.max_stack.peek()))
super().push(item)
def pop(self):
self.max_stack.pop()
return super().pop()
def max(self):
"""
Получить максимальный элемент. Не извлекает его из стека.
"""
return self.max_stack.peek()
def empty(self):
return super().empty()
def __len__(self):
return super().__len__()
def __bool__(self):
return super().__bool__()
def top_sort(adj_list):
n = len(adj_list)
colors = ['w'] * n
stack = Stack()
for i0 in range(n):
is_cycle = dfs_colored_step(i0, adj_list, colors, stack)
if is_cycle:
raise ValueError('Cycle was found')
ii_order = stack.to_list()
return ii_order
def test_pop(self):
a = Stack()
a.push(5)
self.assertEqual(a.pop(), 5)
a.push(4)
a.push(8)
self.assertEqual(a.pop(), 8)
self.assertEqual(a.pop(), 4)
def find_linked_components(adj_list):
# only for nonor graphs
n = len(adj_list)
colors = ['w'] * n
components = []
for i0 in range(n):
stack = Stack()
dfs_colored_step(i0, adj_list, colors, stack)
component = set(stack.to_list())
if component:
components.append(component)
return components
def quick_sort_iterative(x):
i_left, i_right = 0, len(x) - 1
stack = Stack()
stack.push((i_left, i_right))
while stack:
i_left, i_right = stack.pop()
if i_right <= i_left:
continue
i, j = partitioning(x, i_left, i_right)
stack.push((i_left, j))
stack.push((i, i_right))
def test_pop():
my_stack = Stack()
my_stack.push(0)
my_stack.push(1)
popped = my_stack.pop()
assert popped == 1
assert my_stack.peek() == 0
def test_push():
my_stack = Stack()
my_stack.push(0)
my_stack.push(1)
assert my_stack.items == [0, 1]
assert my_stack.size() == 2
assert my_stack.is_empty() is False
def convert_decimal_to_binary(decimal_number):
s = Stack()
while decimal_number > 0:
s.push(decimal_number % 2)
decimal_number = decimal_number // 2
num = ""
while not s.is_empty():
num = num + str(s.pop())
return num
def convert_decimal_to_base(decimal_number, base):
digits = "0123456789ABCDE"
s = Stack()
while decimal_number > 0:
s.push(decimal_number % base)
decimal_number = decimal_number // base
num = ""
while not s.is_empty():
num = num + digits[s.pop()]
return num
def evaluate_postfix_expr(post_expr):
expr = post_expr.split(' ')
operands = Stack()
ops = '+-/*'
for token in expr:
if token not in ops:
operands.push(token)
else:
second_operand = operands.pop()
first_operand = operands.pop()
result = 0
if token == '+':
result = int(first_operand) + int(second_operand)
elif token == '-':
result = int(first_operand) - int(second_operand)
elif token == '*':
result = int(first_operand) * int(second_operand)
elif token == '/':
result = int(first_operand) / int(second_operand)
operands.push(result)
print(operands.pop())
def resolve(s: str):
stack = Stack()
first_open_pos = 0
open_brackets, close_brackets = ['(', '[', '{'], [')', ']', '}']
for i, ch in enumerate(s, 1):
if ch in open_brackets:
if stack.empty():
first_open_pos = i
stack.push(ch)
else:
if stack.empty():
return i
else:
opened = stack.pop()
if open_brackets.index(opened) != close_brackets.index(ch):
return i
if stack.empty():
return 'Success'
else:
return first_open_pos
def find_iterative(lst: List[int]) -> int:
"""
Ищет высоту дерева. Итеративный алгоритм без построения дерева.
Имеет сложность О(n^2).
"""
root_value, root_depth = lst.index(-1), 1
max_depth = 1
tasks = Stack()
tasks.push((root_value, root_depth))
while tasks:
v = tasks.pop()
value, depth = v[0], v[1]
if max_depth < depth:
max_depth = depth
for i in range(len(lst)):
if lst[i] == value:
tasks.push((i, depth + 1))
return max_depth
def check_parentheses_bk(symbol_string):
s = Stack()
balanced = True
index = 0
while index < len(symbol_string) and balanced:
symbol = symbol_string[index]
if symbol in '{[(':
s.push(symbol)
elif symbol in ')]}':
if s.is_empty() or not matches(s.pop(), symbol):
balanced = False
index = index + 1
if balanced and s.is_empty():
return True
else:
return False
def find_iterative_building_tree(lst: List[int]) -> int:
"""
Ищет высоту дерева. Итеративный алгоритм с постоением дерева. Сложность
алгоритма О(n).
"""
root = build_tree(lst)
root.level = 1
max_level = 1
tasks = Stack()
tasks.push(root)
while tasks:
node = tasks.pop()
if max_level < node.level:
max_level = node.level
for child in node.children:
child.level = node.level + 1
tasks.push(child)
return max_level
def parens_matched(x):
# Read a string from left to right and decide whether left and right parentheses are balanced.
stack = Stack()
matched = True
for char in x:
if char == '(':
stack.push(0)
elif char == ')':
popped = stack.pop()
if popped == []:
matched = False
break
return matched and stack.size() == 0
def dec_to_binary(x):
# Return binary representation of base 10 (decimal) number.
exponents = Stack()
while x > 0:
remainder = x % 2
exponents.push(remainder)
x = x // 2
binary = ''
while not exponents.is_empty():
binary += str(exponents.pop())
return binary
def __init__(self,
ID,
date,
timeslot,
theater,
film,
freeplaces=None,
tickets=None):
self.ID = ID
self.date = date
self.timeslot = timeslot
self.fulldate = datetime.datetime(date.year, date.month, date.day,
timeslot.hour, timeslot.minute)
self.theater = theater
self.film = film
if freeplaces == None:
freeplaces = theater.places
self.freeplaces = freeplaces
# this number is managed by the 'parent' cinema
if tickets == None:
tickets = Stack()
self.tickets = tickets
def validate_html_tags(html_code: str):
tags = Stack()
balanced = True
start_index = int(html_code.find('<')) + 1
end_index = int(html_code.find('>'))
while balanced and start_index > 0 and end_index > 0:
tag = html_code[start_index:end_index]
# print("start -> {} , End -> {} ; Tag -> {}".format(str(start_index), str(end_index), tag))
if not tag.startswith('/'):
tags.push(tag)
else:
if tags.is_empty():
balanced = False
break
peek_tag = '/' + tags.pop()
if peek_tag != tag:
balanced = False
start_index = int(html_code.find('<', end_index)) + 1
end_index = int(html_code.find('>', start_index))
return balanced
def test_isEmpty(self):
a = Stack()
self.assertTrue(a.isEmpty())
a.push(5)
self.assertFalse(a.isEmpty())
a.push(5)
self.assertFalse(a.isEmpty())
a.pop()
a.pop()
self.assertTrue(a.isEmpty())
def test_push(self):
a = Stack()
self.assertTrue(a.push(4))
self.assertTrue(a.push(6))
self.assertTrue(a.push("foo"))
def test_top(self):
a = Stack()
a.push(5)
self.assertEqual(a.top(), 5)
a.push(9)
self.assertEqual(a.top(), 9)
a.push("foo")
self.assertEqual(a.top(), "foo")
def __init__(self) -> None:
super().__init__()
self.max_stack = Stack()
def convert_infix_to_prefix(infix_expression):
reverse = reverse_string(infix_expression)
operators = Stack()
prefix_expr = []
ops = '(+-*/**)'
expr_list = list(reverse)
for token in expr_list:
if token not in ops:
prefix_expr.append(token)
elif token == ')':
operators.push(token)
elif token == '(':
while operators.peek() != ')':
prefix_expr.append(operators.pop())
operators.pop()
else:
while (not operators.is_empty()
) and precedence[operators.peek()] > precedence[token]:
prefix_expr.append(operators.pop())
operators.push(token)
while not operators.is_empty():
prefix_expr.append(operators.pop())
return reverse_string(''.join(prefix_expr))
from structures.linkedList import List
from structures.queue import Queue
from structures.stack import Stack
mylist = List()
for i in range(5):
mylist.add(i)
mylist.add(5)
mylist.add(7, 1)
for i in mylist:
print(i)
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
queue.enqueue(4)
for i in range(queue.size):
print(queue.dequeue())
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)
stack.push(4)
for i in range(stack.size):
print(stack.pop())
def convert_infix_to_postfix(infix_expr):
op = Stack()
postfix = []
infix = list(infix_expr)
for index in range(len(infix)):
if infix[index] in ops:
while (not op.is_empty()) and precedence[op.peek()] >= precedence[infix[index]]:
if op.peek() == '(':
op.pop()
else:
postfix.append(op.pop())
if infix[index] != ')':
op.push(infix[index])
elif infix[index] != ' ':
postfix.append(infix[index])
while op.size() > 0:
postfix.append(op.pop())
print(''.join(postfix))
def convert_infix_to_postfix_new(infix_expr):
op = Stack()
postfix = []
infix = list(infix_expr)
for index in range(len(infix)):
token = infix[index]
if token not in ops:
postfix.append(token)
elif token == '(':
op.push(token)
elif token == ')':
while op.peek() != '(':
postfix.append(op.pop())
op.pop()
else:
while (not op.is_empty()) and precedence[op.peek()] >= precedence[infix[index]]:
postfix.append(op.pop())
op.push(token)
while not op.is_empty():
postfix.append(op.pop())
print(''.join(postfix))
from structures.stack import Stack
open_brackets = ["{", "[", "("]
closed_brackets = ["}", "]", ")"]
brackets_dict = {"{": "}", "[": "]", "(": ")"}
brackets = "{[]}"
open_brackets_stack = Stack()
closed_brackets_stack = Stack()
# before starting lets verify that brackets are even
if len(brackets) % 2 != 0:
print("baasa")
exit()
for i in brackets:
if i in open_brackets:
open_brackets_stack.push(i)
else:
closed_brackets_stack.push(i)
# lets verify that there is the same amount of open and close brackets
if open_brackets_stack.__sizeof__() != closed_brackets_stack.__sizeof__():
print("baasa")
exit()
i = open_brackets_stack.pop()
# check if brackets from open eq closed barckets end pop represented in brackets_dict
while i:
barckets_dict_pop = brackets_dict.get(i)
