def depth_first_search(root):
nodes = Stack()
nodes.append(root)
while not nodes.empty():
current_node = nodes.pop()
for child in current_node.children:
nodes.append(child)
def isValid(self, s):
st = Stack()
paren_map = {")": "(", "]": "[", ">": "<", "}": "{"}
for c in s:
if c not in paren_map:
st.append(c)
elif not st.list or paren_map[c] != st.pop():
return False
return not st.list
def dfs_iterative_2(root, result):
'''depth first search iterative implementation
children are traversed in a different order to previous algorithms (but its more efficient)'''
todo = Stack()
todo.append(root)
while len(todo):
node = todo.pop()
result.append(node.visit())
for node in node.children:
todo.append(node)
def dfs_iterative(root, result):
'''depth first search iterative implementation
in same order as for recursion'''
todo = Stack()
todo.append(root)
while len(todo):
node = todo.pop()
result.append(node.visit())
for node in reversed(node.children): #reversal makes it match dfs_recursive
todo.append(node)
def evaluate_posfix_expression(expression):
elements = [x for x in expression.split(' ') if x]
operands = ['+', '-', '*', '/']
stack = Stack()
for e in elements:
if e.isdigit():
stack.append(e)
elif e in operands:
n1 = stack.pop()
n2 = stack.pop()
res = str(eval(n1 + e + n2))
stack.append(res)
return int(stack.pop())
def print_in_line(self):
if not self.size:
print('')
return
from stack import Stack
from queue import Queue
q = Queue()
q.append(self.head)
A = Stack()
A.append(self.head.key)
while q.size:
cur = q.popleft()
for nei in [cur.left, cur.right]:
if nei is not None:
q.append(nei)
A.append(nei.key)
return A.arr
def test_append(self):
A = Stack()
A.append(3)
A.append(101)
self.assertEqual(A.arr, [3, 101])
A = Stack()
with self.assertRaises(AssertionError):
A.append('qwerty')
A.append((3, {3: 0}))
self.assertEqual(A.arr, [(3, {3: 0})])
def isCorrespond(string: str):
left = ['[', '{', '(']
# right = ['}', '}', ')']
pair = ["[]", "{}", "()"]
stack = Stack()
for symbol in string:
if symbol in left:
stack.append(symbol)
else:
leftSymbol = stack.pop()
if leftSymbol is None:
return False
elif leftSymbol + symbol in pair:
continue
else:
return False
if stack.is_empty():
return True
else:
return False
def inorder_iterative_visit1(root, result):
'''
in-order, iterative implementation.
requires a visited flag to be added to each node.
not very elegant, but obvious solution to cycling problem.
In python I don't think this solution is better than the recursive one,
because we still have a stack -> so mem usage is the same.
In C++ or java, the stack should be declared on the heap...
otherwise I don't see what is the gain.
'''
todo = Stack()
todo.append( root )
while len(todo):
node = todo.peek()
if node:
if not node.visited:
node.visited = True
todo.append( node.left )
else:
result.append( node.visit() ) # changed to node.visit to make more general
todo.pop()
todo.append( node.right )
else:
print 'none'
todo.pop()
def inorder_iterative_visit2(root, result):
'''cleaner and more understandable than visit1, but there is still
a visited flag'''
todo = Stack()
todo.append( root )
while len(todo):
node = todo.pop()
if node:
if not node.visited:
node.visited = True
todo.append( node ) # re-adding the node for second visit
todo.append( node.left )
else:
result.append( node.visit() ) # changed to node.visit to make more general
todo.append( node.right )
def inorder_iterative(root, result):
'''Finally, without the visited flag...
took me some time to find this one...'''
todo = Stack()
todo.append( root )
last = None
while len(todo):
node = todo.pop()
if node:
if not last or (last.left is node or last.right is node):
todo.append( node )
todo.append( node.left )
else:
result.append( node.visit() ) # changed to node.visit to make more general
todo.append( node.right )
last = node
def infixToPostfix(string: str) -> str:
""" Convert infix operations to postfix operations
"""
precedence = {}
precedence["*"] = 3
precedence["/"] = 3
precedence["+"] = 2
precedence["-"] = 2
precedence["("] = 1
operationStack = Stack()
output = []
tokenList = string.split("").strip()
for token in tokenList:
if token in letters:
output.append(token)
elif token == LEFT_PAREN:
operationStack.append(token)
elif token == RIGHT_PAREN:
topToken = operationStack.pop()
while topToken != LEFT_PAREN:
output.append(token)
topToken = operationStack.pop()
else:
top = operationStack.peek()
while not operationStack.isEmpty(
) and precedence[top] >= precedence[token]:
output.append(operationStack.pop())
operationStack.append(token)
while not operationStack.isEmpty():
output.append(operationStack.pop())
return " ".join(output)
def test_all():
s = Stack()
s.append(10) #integer test
s.append(10.1) #float test
s.append("String Test") #string test
string = s.pop() #pop string
float = s.pop() #pop float
integer = s.pop() #pop integer
print(string, float, integer)
def preorder_iterative(root, result):
'''pre-order, iterative implementation'''
todo = Stack()
todo.append(root)
while len(todo):
node = todo.pop()
if node.right:
todo.append(node.right)
if node.left:
todo.append(node.left)
result.append( node.visit() )
def graham_hull(points):
points = transform_points(points)
stack = Stack()
stack.append(points[0])
stack.append(points[1])
stack.append(points[2])
for i in range(3, len(points)):
while len(stack) > 1 and ccw(stack.one_below_top(), stack.top(), points[i]) < 0:
stack.pop()
stack.append(points[i])
return stack
def postorder_iterative_1(root, result):
'''We effectively find the nodes from last to first
so when we find each node we append to the start of the result not the back
This version uses visited'''
todo = Stack()
todo.append( root )
while len(todo):
node = todo.peek()
if node:
if not node.visited:
node.visited = True
result.insert(0,node.visit()) #add to back
todo.append( node.right )
else:
todo.pop()
todo.append( node.left )
else:
todo.pop()
def postorder_iterative(root, result):
'''version without visited
we find the nodes from last to first
so each node is inserted at the start of the result not the back
an alternative might be to reverse the result at the end'''
todo = Stack()
todo.append( root )
last = None
while len(todo):
node = todo.peek()
if node:
if not last or last.right is node or last.left is node:
result.insert(0,node.visit())
todo.append( node.right )
else:
todo.pop()
todo.append( node.left )
last=node
else:
todo.pop()
def infix_to_postfix(expression, precedence='normal'):
# characters = list(expression.replace(' ', ''))
precedences = {
'equal': {
'+': 0,
'-': 0,
'*': 0,
'/': 0,
'(': -1
},
'normal': {
'+': 0,
'-': 0,
'*': 1,
'/': 1,
'(': -1
},
'reverse': {
'+': 1,
'-': 1,
'*': 0,
'/': 0,
'(': -1
}
}
if precedence not in precedences:
raise ValueError(
"Precedence argument must be one of ['normal', 'equal', 'reverse']"
)
operands_precedence = precedences[precedence]
characters = list(expression)
postfix = ""
stack = Stack()
for c in characters:
if c.isdigit():
postfix += c
elif c == ' ':
postfix += c
elif c == '(':
stack.append(c)
elif c == ')':
while not stack.is_empty() and stack.top() != '(':
top = stack.pop()
postfix += ' '
postfix += top
if not stack.is_empty() and stack.top() == '(':
stack.pop()
elif c in operands_precedence: # Operator
while not stack.is_empty() and \
operands_precedence[c] <= operands_precedence[stack.top()]:
postfix += ' '
postfix += stack.pop()
stack.append(c)
while not stack.is_empty():
postfix += ' '
postfix += stack.pop()
return postfix
def test_integers():
s = Stack()
s.append(5)
t = s.pop()
print(t)
def test_strings():
s = Stack()
s.append("Test String")
t = s.pop()
print(t)
def test_floats():
s = Stack()
s.append(3.14)
t = s.pop()
print(t)
class Menu:
"Show the calculator interface, handles user input"
STATUS_LINE_Y = 0
STACK_X = 0
STACK_SIZE = 5
MSG_LINE_Y = STATUS_LINE_Y + STACK_SIZE + 2
def __init__(self):
"Initialize an empty stack"
self.stack = Stack()
self.message_line = ""
def get_status_line(self):
"Show angle unit at top of calculator"
if self.stack.conv == 1.0:
return "RAD"
else:
return "DEG"
def get_input(self, prompt="> "):
"""Handles user input key by key :
- [esc] or "q" to quit the calculator
- [enter] to duplicate last stack element or to lauch the command being constituted
- [backspace] to remove last stack element
- +, -, * and / operands to execute the operation
- any other key to constitute the command or a stack element"""
result = ""
prompt_y = self.STATUS_LINE_Y + 1 + self.STACK_SIZE
while True:
self.stdscr.addstr(prompt_y, self.STACK_X,
" ")
self.stdscr.addstr(prompt_y, self.STACK_X, prompt + result)
curses.flushinp()
key = self.stdscr.getch()
if key == 27 or (chr(key) == "q" and result == ""):
result = "q"
break
elif key == 127 or key == 263:
if result == "":
result = "drop"
break
else:
result = result[:-1]
elif key == 13 or key == 10:
break
elif chr(key) in ["+", "-", "*", "/", "!"]:
if result == "":
result = chr(key)
else:
result += " " + chr(key)
break
else:
result += chr(key)
self.message_line = ""
return result
def print_stack(self):
"Print stack content on screen, plus status and message lines"
self.stdscr.addstr(self.STATUS_LINE_Y, self.STACK_X,
self.get_status_line())
for y in range(0, self.STACK_SIZE):
line_y = self.STATUS_LINE_Y + self.STACK_SIZE - y
try:
self.stdscr.addstr(line_y, self.STACK_X,
str(self.stack[-y - 1]))
except:
break
self.stdscr.addstr(self.MSG_LINE_Y, self.STACK_X, self.message_line)
def will_it_float(self, str):
"Indicate wether a string can be converted to float or not"
try:
float(str)
return True
except ValueError:
return False
def run(self):
"Handles user input wher the [enter] key is pressed"
self.stdscr = curses.initscr()
curses.noecho()
curses.cbreak()
self.stdscr.keypad(True)
try:
while True:
self.stdscr.clear()
self.print_stack()
cmds = self.get_input()
for cmd in cmds.split(" "):
saved_stack = copy.deepcopy(self.stack)
try:
if self.will_it_float(cmd):
self.stack.append(float(cmd))
else:
self.stack.execute_command(cmd)
except StackUnderflowException as e:
self.message_line = str(e)
self.stack = saved_stack
except ZeroDivisionError as e:
self.message_line = "division by zero"
self.stack = saved_stack
except AngleUnitChangeException as e:
pass # Nothing to do, just re-show stack
except UnknownCommandException as e:
self.message_line = str(e)
except QuitException as e:
self.message_line = str(e)
exit(0)
except Exception as e:
self.message_line = str(e)
self.stack = saved_stack
finally:
self.stdscr.keypad(False)
curses.nocbreak()
curses.echo()
curses.endwin()
def test_pop(self):
A = Stack()
self.assertEqual(A.pop(), None)
A.append(2)
self.assertEqual(A.pop(), 2)
class Gaot(object):
def __init__(self):
self.stack = Stack([])
self.instructions = None
self.ipointer = 0
self.move = 1
self.BAA = re.compile(r"ba{2,}")
self.BLEET = re.compile(r"ble{2,}t")
self.commands = [self._add, #2
self._subtract, #3
self._continue, #4
self._exit, #5
self._reverse, #6
self._skiptrue, #7
self._skipfalse, #8
self._printnum, #9
self._printchar, #10
self._getnum, #11
self._getchar, #12
self._dupe, #13
self._swap, #14
self._reverse_stack,#15
self._rotate_stack] #16
self.ccount = 0
def run(self, program):
self.instructions = program.split()
while self.ipointer < len(self.instructions):
c = self.instructions[self.ipointer]
if self.BAA.search(c): # is a "baa" command
self.stack.append(len(c) - 2)
elif self.BLEET.search(c): # is a "bleet" command
n = len(c) - 3
self.commands[n-2]()
self.ipointer += self.move
def get_code(self):
if "--file" in sys.argv:
code = open(sys.argv[sys.argv.index("--file") + 1]).read()
input_index = sys.argv.index("--file")
sys.argv.pop(sys.argv.index("--file") + 1)
sys.argv.pop(sys.argv.index("--file"))
elif len(sys.argv) >= 2:
code = sys.argv[1]
input_index = 2
else:
code = raw_input("Code: ")
try:
self.input = sys.argv[input_index:]
except:
self.input = []
return code
# --------------------------------------
def _add(self):
self.stack.push(self.stack.pop() + self.stack.pop())
def _subtract(self):
self.stack.push(self.stack.pop() - self.stack.pop())
def _continue(self):
self.ipointer += self.move
def _exit(self):
exit()
def _reverse(self):
self.move *= -1
def __skip(self, state):
self.ipointer += self.move*(self.stack.pop() == state)
def _skiptrue(self):
self.__skip(True)
def _skipfalse(self):
self.__skip(False)
def _printnum(self):
sys.stdout.write(unicode(self.stack.pop()))
sys.stdout.flush()
def _printchar(self):
sys.stdout.write(unicode(chr(self.stack.pop())))
sys.stdout.flush()
def _getnum(self):
self.stack.push(float(raw_input()))
def _getchar(self):
_ = ord(getch())
self.stack.append(_*(_!=4))
def _dupe(self):
self.stack.push(self.stack.peek())
def _swap(self):
x,y = self.stack.pop(), self.stack.pop()
self.stack.push(y)
self.stack.push(x)
def _reverse_stack(self):
self.stack = Stack(self.stack.get()[::-1])
def _rotate_stack(self):
_ = self.stack.get()
self.stack = Stack(x[1:]+x[0])
from stack import Stack
from path import root
from Tree import Node
from check import checker
start = root
end = str(input("between b-f"))
s = Stack()
count = 1
s.append(root)
x = s.print()
while len(x) != 0:
if len(x) == 0:
print("no Solution")
else:
y = s.stack[-1]
print(y.data)
result = checker(y.data, end)
print(result)
if result is True:
print(f"element found at {count}")
exit()
else:
s.pop()
if y.child1 is not None:
s.append(y.child1)
if y.child2 is not None:
class Gaot(object):
def __init__(self):
self.stack = Stack([])
self.instructions = None
self.ipointer = 0
self.move = 1
self.BAA = re.compile(r"ba{2,}")
self.BLEET = re.compile(r"ble{2,}t")
self.commands = [
self._add, # 2
self._subtract, # 3
self._continue, # 4
self._exit, # 5
self._reverse, # 6
self._skiptrue, # 7
self._skipfalse, # 8
self._printnum, # 9
self._printchar, # 10
self._getnum, # 11
self._getchar, # 12
self._dupe, # 13
self._swap, # 14
self._reverse_stack, # 15
self._rotate_stack,
] # 16
self.ccount = 0
def run(self, program):
self.instructions = program.split()
while self.ipointer < len(self.instructions):
c = self.instructions[self.ipointer]
if self.BAA.search(c): # is a "baa" command
self.stack.append(len(c) - 2)
elif self.BLEET.search(c): # is a "bleet" command
n = len(c) - 3
self.commands[n - 2]()
self.ipointer += self.move
def get_code(self):
if "--file" in sys.argv:
code = open(sys.argv[sys.argv.index("--file") + 1]).read()
input_index = sys.argv.index("--file")
sys.argv.pop(sys.argv.index("--file") + 1)
sys.argv.pop(sys.argv.index("--file"))
elif len(sys.argv) >= 2:
code = sys.argv[1]
input_index = 2
else:
code = raw_input("Code: ")
try:
self.input = sys.argv[input_index:]
except:
self.input = []
return code
# --------------------------------------
def _add(self):
self.stack.push(self.stack.pop() + self.stack.pop())
def _subtract(self):
self.stack.push(self.stack.pop() - self.stack.pop())
def _continue(self):
self.ipointer += self.move
def _exit(self):
exit()
def _reverse(self):
self.move *= -1
def __skip(self, state):
self.ipointer += self.move * (self.stack.pop() == state)
def _skiptrue(self):
self.__skip(True)
def _skipfalse(self):
self.__skip(False)
def _printnum(self):
sys.stdout.write(unicode(self.stack.pop()))
sys.stdout.flush()
def _printchar(self):
sys.stdout.write(unicode(chr(self.stack.pop())))
sys.stdout.flush()
def _getnum(self):
self.stack.push(float(raw_input()))
def _getchar(self):
_ = ord(getch())
self.stack.append(_ * (_ != 4))
def _dupe(self):
self.stack.push(self.stack.peek())
def _swap(self):
x, y = self.stack.pop(), self.stack.pop()
self.stack.push(y)
self.stack.push(x)
def _reverse_stack(self):
self.stack = Stack(self.stack.get()[::-1])
def _rotate_stack(self):
_ = self.stack.get()
self.stack = Stack(x[1:] + x[0])
def LEXdfs(graph, start):
"""
Does DFS search of graph, beginning at start.
Implemented from Algorithm 1 in
"Finding compact communities in large graphs"
by Creusefond, Largillier and Peyronnet.
http://dx.doi.org/10.1145/2808797.2808868
"""
#
# Create and initialize VISITED and LEX for all nodes
#
attrs = { VISITED: {},
LEX: {}}
node = graph.BegNI()
while node < graph.EndNI():
attrs[VISITED][node.GetId()] = 0
attrs[LEX][node.GetId()] = "0"
node.Next()
# initialize DFS variables
stack = Stack()
stack.append( start.GetId() )
i = 1
# do the search
while len(stack) > 0:
# print "stack:"
# print node_list_to_str(graph, stack, attrs)
# print
# print
# process top node
# print
# stack.print_all()
# print
node_id = stack.pop()
node = graph.GetNI(node_id)
attrs[VISITED][node_id] = i
array = []
# find unvisited neighbors of node
for in_id in range(node.GetOutDeg()):
out_id = node.GetOutNId(in_id)
out_node = graph.GetNI(out_id)
if attrs[VISITED][out_id] == 0:
# will raise exception if out_node not there
try:
# print "Trying to remove", node_to_str(graph, out_id, attrs)
stack.remove(out_id)
# print "Removed", node_to_str(graph, out_id, attrs)
except ValueError as e:
# expected to occur
pass
attrs[LEX][out_id] = str(i) + attrs[LEX][out_id]
array.append(out_id)
# end of unvisited neighbor
# end of neighbors
# print "Not sure if this is correct. Needs to randomize order for ties"
# print "Before"
# print node_list_to_str(graph, array, attrs)
array.sort(key = lambda n_id: attrs[LEX][n_id])
randomize_equal_neighbors(graph, array, attrs)
# print "After"
# print node_list_to_str(graph, array, attrs)
# print
# print
stack.extend(array)
i = i + 1
# print "stack:"
# print node_list_to_str(graph, stack, attrs)
# print
# print
# end of stack processing
return attrs
