import os
import sys
import argparse
from tree import Tree
from file import File
from calc import Calculation
parser = argparse.ArgumentParser()
parser.add_argument('-n', dest='amount', type=int, default=10, help='生成题目的数量')
parser.add_argument('-r', dest='range', type=int, default=10, help='生成题目中的数值，自然数以及真分数分母的范围')
args = parser.parse_args()
if __name__ == '__main__':
question_path = os.path.join(os.getcwd(), 'Questions.txt')
answer_path = os.path.join(os.getcwd(), 'Answers.txt')
score_path = os.path.join(os.getcwd(), 'Score.txt')
print("Welcome to T1e9u & Hed9eh0g's program!")
print("Input Hed9eh0g_is_handsome to exit")
t = Tree()
student_answers = list()
generatives, answers = t.create(args.range, args.amount) # 题目以及答案的生成
File.write_file(generatives, answers, question_path, answer_path) # 题目文件以及答案文件的生成
for i in range(args.amount):
print(generatives[i], end='')
answer = input()
student_answers.append(answer)
correct, wrong = Calculation.score(student_answers, answers) # 成绩的统计
File.write_grade_file(score_path, correct, wrong) # 保存答题结果
class Individual:
STANDING_LIMITS = {'min': 1, 'max': 10, 'starting': 5}
def __init__(self, exp_class, exp_args=[]):
self.exp_class = exp_class
self.exp_args = exp_args
self._error = 0
self._standing = None
@property
def error(self):
return self._error
@property
def standing(self):
return self._standing
def increment_standing(self):
self._standing = min(self._standing + 1, self.STANDING_LIMITS['max'])
def decrement_standing(self):
self._standing = max(self._standing - 1, self.STANDING_LIMITS['min'])
def init_experiment(self):
self._error = 0
self.experiment = self.exp_class(*self.exp_args)
self.experiment.initialize()
def generate(self, extra_terminal_set=[], extra_function_set=[], tree_depth=3, tree_function_bias=1):
self._standing = self.STANDING_LIMITS['starting']
self.init_experiment()
self.tree = Tree()
self.tree.create(self.experiment.get_terminal_set() + extra_terminal_set,
self.experiment.get_function_set() + extra_function_set,
function_bias=tree_function_bias, max_depth=tree_depth)
def clone(self):
clone = self.__class__(self.exp_class, self.exp_args)
clone._standing = self._standing
clone.init_experiment()
clone.tree = Tree()
clone.tree.clone(self.tree)
return clone
def mutate(self):
mutant = self.__class__(self.exp_class, self.exp_args)
mutant._standing = self._standing
mutant.init_experiment()
mutant.tree = Tree()
mutant.tree.mutate(self.tree)
return mutant
def reproduce(self, other_individual):
child = self.__class__(self.exp_class, self.exp_args)
child._standing = int(numpy.average([self._standing, other_individual._standing]))
child.init_experiment()
child.tree = Tree()
child.tree.subtree_crossover(self.tree, other_individual.tree)
return child
def get_func(self, function_name):
return self.experiment.function_lookup(function_name)
def evaluate(self):
loop = True
while loop:
self._error += self.experiment.norm_error(self.tree.execute(self))
loop = self.experiment.next()
def evaluate_data(self):
samples = []
loop = True
self.experiment.initialize()
while loop:
actual_value = self.tree.execute(self)
sample = {'value': actual_value, 'error': self.experiment.norm_error(actual_value)}
if self.experiment.index() != None:
sample['index'] = self.experiment.index()
samples.append(sample)
loop = self.experiment.next()
return samples
def simplify(self):
self.tree.simplify(self)
from tree import Tree from linkedlist import LinkedList tree = Tree() tree.create() def createDepthLinkedList(): nodesAtDepth = LinkedList() nodesAtDepth.insertNode(tree.root.data) q=[] q.append(tree.root) depthLinkedList =[nodesAtDepth] condition = True while condition: children = [] while (q): node= q.pop(0) if(node.left != None): children.append(node.left) if(node.right != None): children.append(node.right) condition = True if children else False if(condition): nodesAtDepth = LinkedList() for node in children: nodesAtDepth.insertNode(node.data) depthLinkedList.append(nodesAtDepth) q.extend(children) for linkedlist in depthLinkedList: linkedlist.display()
# self.left = None
# self.right = None
class Solution:
def diameterOfBinaryTree(self, root: TreeNode) -> int:
"""
对每个结点，计算左子树高度 + 右子树高度 + 1
后序遍历
"""
self.result = 1
def dfs(root):
if root is None:
return 0
left = dfs(root.left)
right = dfs(root.right)
length = left + right + 1
self.result = max(self.result, length)
return max(left, right) + 1
dfs(root)
return self.result - 1
s = Solution()
t = Tree()
t.create([1, 2, 3, 4, 5])
print(s.diameterOfBinaryTree(t.root))
# self.val = x
# self.left = None
# self.right = None
class Solution:
def mergeTrees(self, t1, t2):
"""
:param t1: TreeNode
:param t2: TreeNode
:return: TreeNode
"""
if not t1:
return t2
if not t2:
return t1
root = TreeNode(t1.val + t2.val)
root.left = self.mergeTrees(t1.left, t2.left)
root.right = self.mergeTrees(t1.right, t2.right)
return root
t1 = Tree()
t2 = Tree()
t1.create([1, 3, 2, 5])
t2.create([2, 1, 3, None, 4, None, 7])
s = Solution()
res = s.mergeTrees(t1.root, t2.root)
print(TreeNode.levelOrder(res))
