def parseFactor():
global count
global input_tokens
if ((input_tokens[count] in numbers)
or (input_tokens[count] in identifiers)):
try:
node1 = TreeNode(input_tokens[count])
return node1
# return tokens[count]
finally:
count = count + 1
elif (input_tokens[count] == "("):
bracketTree = TreeNode("()")
if (input_tokens[count + 1] == "-"):
count = count + 1
unaryTree = TreeNode(input_tokens[count])
count = count + 1
node4 = TreeNode(input_tokens[count])
node3 = TreeNode("0")
unaryTree.addChild(node3)
unaryTree.addChild(node4)
count = count + 1
# print(unaryTree)
bracketTree.addChild(unaryTree)
if (input_tokens[count] == ")"):
count = count + 1
print(bracketTree)
return bracketTree
else:
print("Expected \')\' but got", tokens[count])
sys.exit()
else:
count = count + 1
node2 = parseSubtraction()
bracketTree.addChild(node2)
# num1 = parseSubtraction()
if (input_tokens[count] == ")"):
count = count + 1
return bracketTree
else:
print("Expected \')\' but got", tokens[count])
sys.exit()
else:
print("Expected number but got ", tokens[count])
sys.exit()
def parseSubtraction():
global count
global input_tokens
# num1 = parseFactor()
node1 = parseAddition()
subtractTree = TreeNode("-")
subtractTree.addChild(node1)
if (count == len(input_tokens)):
# return num1
return subtractTree
if (input_tokens[count] == "-"):
count = count + 1
node2 = parseAddition()
subtractTree.addChild(node2)
if (count == len(input_tokens)):
return subtractTree
while (input_tokens[count] == "-"):
tree2 = TreeNode(input_tokens[count])
count = count + 1
node3 = parseAddition()
tree2.addChild(node3)
subtractTree.addChild(tree2)
# num2 = parseFactor()
# num1 = float(num1)/float(num2)
if (count == len(input_tokens)):
# return num1
return subtractTree
# return num1
return subtractTree
def parseAddition():
global count
global input_tokens
# num1 = parseFactor()
node1 = parseMultiplication()
addTree = TreeNode("+")
addTree.addChild(node1)
if (count == len(input_tokens)):
# return num1
return addTree
if (input_tokens[count] == "+"):
count = count + 1
node2 = parseMultiplication()
addTree.addChild(node2)
if (count == len(tokens)):
return addTree
while (input_tokens[count] == "+"):
tree2 = TreeNode(input_tokens[count])
count = count + 1
node3 = parseMultiplication()
tree2.addChild(node3)
addTree.addChild(tree2)
# num2 = parseFactor()
# num1 = float(num1)/float(num2)
if (count == len(input_tokens)):
# return num1
return addTree
# return num1
return addTree
def parseDivision():
global count
global input_tokens
# num1 = parseFactor()
node1 = parseFactor()
divTree = TreeNode("/")
divTree.addChild(node1)
if (count == len(input_tokens)):
# return num1
return divTree
if (input_tokens[count] == "/"):
count = count + 1
node2 = parseFactor()
divTree.addChild(node2)
if (count == len(input_tokens)):
return divTree
while (input_tokens[count] == "/"):
tree2 = TreeNode(input_tokens[count])
count = count + 1
node3 = parseFactor()
tree2.addChild(node3)
divTree.addChild(tree2)
# num2 = parseFactor()
# num1 = float(num1)/float(num2)
if (count == len(input_tokens)):
# return num1
return divTree
# return num1
return divTree
def parsePuts():
global count
global input_tokens
putsTree = TreeNode("<puts>")
if (count == len(input_tokens)):
return putsTree
elif (input_tokens[count] == "puts"):
node1 = TreeNode(input_tokens[count])
putsTree.addChild(node1)
count = count + 1
node2 = parseOpeningBracket()
putsTree.addChild(node2)
if (input_tokens[count] in identifiers
or input_tokens[count] in numbers):
node3 = TreeNode(input_tokens[count])
putsTree.addChild(node3)
count = count + 1
node4 = parseClosingBracket()
putsTree.addChild(node4)
return putsTree
else:
print("Expected number or identifier in \'puts\' but got ",
input_tokens[count])
sys.exit()
def parseRelational():
global count
global input_tokens
relationalTree = TreeNode("<relational>")
if (count == len(input_tokens)):
return relationalTree
elif ((input_tokens[count] in identifiers)
or (input_tokens[count] in numbers)):
node1 = TreeNode(input_tokens[count])
relationalTree.addChild(node1)
count = count + 1
if (input_tokens[count] in relationalOperators):
node2 = TreeNode(input_tokens[count])
relationalTree.addChild(node2)
count = count + 1
if ((input_tokens[count] in identifiers)
or (input_tokens[count] in numbers)):
node3 = TreeNode(input_tokens[count])
relationalTree.addChild(node3)
count = count + 1
return relationalTree
else:
print("Expected number or identifier but got ",
input_tokens[count])
sys.exit()
else:
print("Expected a relational operator but got ",
input_tokens[count])
sys.exit()
else:
print("Expected number or identifier before relational but got ",
input_tokens[count])
sys.exit()
elif nodes[i][1] == root.gfv():
root.addChild(
add_nodes(TreeNode(nodes[i], 1), nodes[0:i] + nodes[i + 1:]))
return root
f = open("Day24DB")
cm = []
for l in f.readlines():
t = l.split('/')
cm.append((int(t[0]), int(t[1]), 0))
cm = sorted(cm, key=sum, reverse=True)
begs = filter(lambda x: x[0] == 0 or x[1] == 0, cm)
cm = filter(lambda x: not (x[0] == 0 or x[1] == 0), cm)
rts = map(lambda x: TreeNode(x, zdir(x)), begs)
t = TreeNode((0, 0), 2)
for root in rts:
t.addChild(
add_nodes(
root, filter(lambda x: not (x[0] == root.l and x[1] == root.r),
cm)))
print "Looking for max"
print t.gwgh()
print t.glen()
print t.glnw()
def parseMain():
global count
global input_tokens
mainNode = TreeNode("<main>")
if (input_tokens[count] == "main"):
node1 = TreeNode(input_tokens[count])
mainNode.addChild(node1)
count = count + 1
node2 = parseOpeningBracket()
mainNode.addChild(node2)
node3 = parseClosingBracket()
mainNode.addChild(node3)
node4 = parseOpeningBrace()
mainNode.addChild(node4)
node5 = parseStatements()
mainNode.addChild(node5)
node6 = parseClosingBrace()
mainNode.addChild(node6)
if (count == len(input_tokens)):
return mainNode
elif (input_tokens[count]):
print("Additional tokens detected at", input_tokens[count])
sys.exit()
return mainNode
else:
print("Expected main but got ", input_tokens[count])
sys.exit()
def parseAssignment():
global count
global input_tokens
assignmentTree = TreeNode("<assignment>")
if (count == len(input_tokens)):
return assignmentTree
elif (input_tokens[count] == "int" or input_tokens[count] == "float"
or input_tokens[count] == "double"):
node1 = TreeNode(input_tokens[count])
assignmentTree.addChild(node1)
count = count + 1
if (input_tokens[count] in identifiers):
node2 = TreeNode(input_tokens[count])
assignmentTree.addChild(node2)
count = count + 1
if (input_tokens[count] == "="):
node3 = TreeNode(input_tokens[count])
assignmentTree.addChild(node3)
count = count + 1
node4 = parseSubtraction()
assignmentTree.addChild(node4)
return assignmentTree
# if((input_tokens[count] in numbers or input_tokens[count] in identifiers)):
# if(input_tokens[count+1] in arithmeticOperators):
# node5 = parseSubtraction()
# assignmentTree.addChild(node5)
# return assignmentTree
# else:
# if((input_tokens[count] in numbers or input_tokens[count] in identifiers)):
# node4 = TreeNode(input_tokens[count])
# assignmentTree.addChild(node4)
# count = count + 1
# return assignmentTree
# else:
# print("Expected positive integer,decimal or arithmetic expression but got ",input_tokens[count])
# # elif(parseArithmetic()==True):
# # return
# else:
# print("Expected positive integer,decimal or arithmetic expression but got ",input_tokens[count])
else:
print("Expected \'=\' but got ", input_tokens[count])
sys.exit()
else:
print("Expected identifier but got ", input_tokens[count])
sys.exit()
elif (input_tokens[count] in identifiers):
node6 = TreeNode(input_tokens[count])
assignmentTree.addChild(node6)
count = count + 1
if (input_tokens[count] == "="):
node7 = TreeNode(input_tokens[count])
assignmentTree.addChild(node7)
count = count + 1
node8 = parseSubtraction()
assignmentTree.addChild(node8)
return assignmentTree
# if((input_tokens[count] in numbers or input_tokens[count] in identifiers)):
# if(input_tokens[count+1] in arithmeticOperators):
# node8 = parseSubtraction()
# assignmentTree.addChild(node8)
# return assignmentTree
# else:
# if((input_tokens[count] in numbers or input_tokens[count] in identifiers)):
# node9 = TreeNode(input_tokens[count])
# assignmentTree.addChild(node9)
# count = count + 1
# return assignmentTree
# else:
# print("Expected positive integer,decimal or arithmetic expression but got ",input_tokens[count])
else:
print("Expected \'=\' but got ", input_tokens[count])
sys.exit()
else:
print(
"Expected \'int\' or \'float\' or \'double\' or identifier but got ",
input_tokens[count])
sys.exit()
def parseWhileStatements():
global count
global input_tokens
whileStatement = TreeNode("<while-statements>")
if (count == len(input_tokens)):
return TreeNode(" ")
while (input_tokens[count] == "int" or input_tokens[count] == "float"
or input_tokens[count] == "double" or input_tokens[count] == "while"
or input_tokens[count] == "puts"
or input_tokens[count] in identifiers):
if (input_tokens[count] == "int" or input_tokens[count] == "float"
or input_tokens[count] == "double"
or input_tokens[count] in identifiers):
try:
node1 = parseAssignment()
# whileStatement.addChild(node1)
# print(repr(TreeNode("while-statements").addChild(node1)))
# return (TreeNode("<while-statements").addChild(node1))
except:
print("Syntax error when assigning near ", input_tokens[count])
sys.exit()
finally:
whileStatement.addChild(node1)
# parseWhileStatements()
elif (input_tokens[count] == "while"):
node2 = TreeNode(" ")
try:
node2 = parseWhile()
# whileStatement.addChild(node2)
# print(repr(TreeNode("while-statements").addChild(node2)))
# return (TreeNode("<while-statements>").addChild(node2))
except:
print("Syntax error in while loop near", input_tokens[count])
sys.exit()
finally:
whileStatement.addChild(node2)
# parseWhileStatements()
elif (input_tokens[count] == "puts"):
node3 = TreeNode(" ")
try:
node3 = parsePuts()
# whileStatement.addChild(node3)
# print(repr((TreeNode("while-statements").addChild(node3))))
# return (TreeNode("while-statements").addChild(node3))
# whileStatement.addChild(node3)
except:
print("Syntax error in puts statement near",
input_tokens[count])
sys.exit()
finally:
whileStatement.addChild(node3)
# parseWhileStatements()
elif (input_tokens[count] == "}"):
return TreeNode(" ")
else:
print("Syntax error.Expected a valid statement near ",
input_tokens[count])
sys.exit()
return whileStatement
def parseWhile():
global count
global input_tokens
whileTree = TreeNode("<while>")
if (count == len(input_tokens)):
return whileTree
elif (input_tokens[count] == "while"):
node1 = TreeNode(input_tokens[count])
whileTree.addChild(node1)
count = count + 1
node2 = parseOpeningBracket()
whileTree.addChild(node2)
node3 = parseRelational()
whileTree.addChild(node3)
node4 = parseClosingBracket()
whileTree.addChild(node4)
node5 = parseOpeningBrace()
whileTree.addChild(node5)
node6 = parseWhileStatements()
whileTree.addChild(node6)
# print(repr(node6))
node7 = parseClosingBrace()
whileTree.addChild(node7)
return whileTree
