pv2ajsu8k
/
Point_24
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

添加 生成表达式 功能

Browse Source
main
zart 10 months ago
parent c22d011ee1
commit b3ae5007b2
3 changed files with 819 additions and 783 deletions
Show Stats Download Patch File Download Diff File

608
data.py
Unescape View File

@ -2,322 +2,348 @@
import math
import random
OPS = ['+', '-', '*', '/','^','sin','cos','tan']
OPS = ['+', '-', '*', '/', '^', 'sin', 'cos', 'tan']
def get_Aexps(nums=None):
ops = OPS[:4]
if nums is None:
nums = []
for i in range(4):
num = input("请输入第%d个数字：" % (i + 1))
if num.isdigit():
if 1 <= int(num) <= 9:
nums.append(num)
group_nums = get_nums_group(nums)
results = []
for nums in group_nums:
for op1 in ops:
for op2 in ops:
for op3 in ops:
Aexp = f"(({nums[0]}{op1}{nums[1]}){op2}{nums[2]}){op3}{nums[3]}" # 枚举表达式
try:
result = eval(Aexp)
if result == 24 and Aexp not in results:
results.append(Aexp)
except ZeroDivisionError:
continue # 跳过0除错误
if len(results) != 0:
return results
else:
return "无法得出24点"
ops = OPS[:4]
if nums is None:
nums = []
for i in range(4):
num = input("请输入第%d个数字：" % (i + 1))
if num.isdigit():
if 1 <= int(num) <= 9:
nums.append(num)
group_nums = get_nums_group(nums)
results = []
for nums in group_nums:
for op1 in ops:
for op2 in ops:
for op3 in ops:
Aexp = f"(({nums[0]}{op1}{nums[1]}){op2}{nums[2]}){op3}{nums[3]}" # 枚举表达式
try:
result = eval(Aexp)
if result == 24 and Aexp not in results:
results.append(Aexp)
except ZeroDivisionError:
continue # 跳过0除错误
if len(results) != 0:
return results
else:
return "无法得出24点"
def gen_exp(nums): # 生成表达式
ops = OPS[:4]
result = 0
group_nums = get_nums_group(nums)
for nums in group_nums:
for op1 in ops:
for op2 in ops:
for op3 in ops:
Aexp = f"(({nums[0]}{op1}{nums[1]}){op2}{nums[2]}){op3}{nums[3]}"
try:
result = eval(Aexp)
if result == 24:
return Aexp
except ZeroDivisionError:
continue # 跳过0除错误
if result != 24:
return "无法得出24点"
ops = OPS[:4]
result = 0
group_nums = get_nums_group(nums)
for nums in group_nums:
for op1 in ops:
for op2 in ops:
for op3 in ops:
Aexp = f"(({nums[0]}{op1}{nums[1]}){op2}{nums[2]}){op3}{nums[3]}"
try:
result = eval(Aexp)
if result == 24:
return Aexp
except ZeroDivisionError:
continue # 跳过0除错误
if result != 24:
return "无法得出24点"
def get_nums_group(nums): # 获取4个数的排列组合
group = []
for i in range(4):
for j in range(4):
for k in range(4):
for l in range(4):
if i != j and i != k and i != l and j != k and j != l and k != l:
group.append([nums[i], nums[j], nums[k], nums[l]])
return group
group = []
for i in range(4):
for j in range(4):
for k in range(4):
for l in range(4):
if i != j and i != k and i != l and j != k and j != l and k != l:
group.append([nums[i], nums[j], nums[k], nums[l]])
return group
class Node:
def __init__(self, treeNode_value):
self.NodeID = treeNode_value[0]
self.NodeType = treeNode_value[1]
self.Ops = treeNode_value[2]
self.LeftNodeID = treeNode_value[3]
self.RightNodeID = treeNode_value[4]
self.FaceValue = treeNode_value[5]
self.FaceColor = treeNode_value[6]
def __str__(self):
return f"NodeID: {self.NodeID}\t NodeType: {self.NodeType}\t Ops: {self.Ops}\t LeftNodeID: {self.LeftNodeID}\t RightNodeID: {self.RightNodeID}\t FaceValue: {self.FaceValue}\t FaceColor: {self.FaceColor}"
def __init__(self, treeNode_value):
self.NodeID = treeNode_value[0]
self.NodeType = treeNode_value[1]
self.Ops = treeNode_value[2]
self.LeftNodeID = treeNode_value[3]
self.RightNodeID = treeNode_value[4]
self.FaceValue = treeNode_value[5]
self.FaceColor = treeNode_value[6]
def __str__(self):
return (
f"NodeID: {self.NodeID}\t NodeType: {self.NodeType}\t Ops: {self.Ops}\t LeftNodeID: {self.LeftNodeID}\t "
f"RightNodeID: {self.RightNodeID}\t FaceValue: {self.FaceValue}\t FaceColor: {self.FaceColor}")
def split_exp(expression): # 将表达式拆分为数字和运算符
stack = []
current_number = ''
for char in expression:
if char.isdigit() or char == '.':
current_number += char
elif char.isalpha(): # 处理sin,cos等函数
current_number += char
elif char == '(':
if current_number:
stack.append(current_number)
current_number = ''
stack.append(char)
elif char == ')' and current_number:
stack.append(current_number)
stack.append(char)
current_number = ''
elif char in OPS:
if current_number:
stack.append(current_number)
current_number = ''
stack.append(char)
if current_number:
stack.append(current_number)
return stack
stack = []
current_number = ''
for char in expression:
if char.isdigit() or char == '.':
current_number += char
elif char.isalpha(): # 处理sin,cos等函数
current_number += char
elif char == '(':
if current_number:
stack.append(current_number)
current_number = ''
stack.append(char)
elif char == ')' and current_number:
stack.append(current_number)
stack.append(char)
current_number = ''
elif char in OPS:
if current_number:
stack.append(current_number)
current_number = ''
stack.append(char)
if current_number:
stack.append(current_number)
return stack
def get_postfix_expression_(expression): # 将中缀表达式转化为后缀表达式
expression = split_exp(expression) # 多位数拆分
precedence = {'+': 1, '-': 1, '*': 2, '/': 2}
postfix = []
stack = []
for char in expression:
if char.isdigit():
postfix.append(char)
elif char == '(':
stack.append(char)
elif char == ')':
while stack and stack[-1] != '(':
postfix.append(stack.pop())
stack.pop() # 弹出 '('
elif char in precedence:
while stack and stack[-1] != '(' and precedence[stack[-1]] >= precedence[char]:
'''这行代码的作用是在中缀表达式转换为后缀表达式的过程中，检查当前运算符与栈顶运算符的优先级。具体来说，它的功能是：
确保栈不为空（避免了索引错误）。
确保栈顶元素不是左括号 '('，因为左括号的优先级最低，不需要进行比较。
确保栈顶元素的优先级大于等于当前运算符的优先级，因为栈中的运算符都应该在当前运算符之前执行（栈顶元素的优先级大于等于当前运算符表示栈顶元素的操作要优先于当前操作执行）。'''
postfix.append(stack.pop())
stack.append(char)
while stack:
postfix.append(stack.pop())
return postfix
def get_postfix_expression(expression):
# 多位数拆分
expression = split_exp(expression)
precedence = {'+': 1, '-': 1, '*': 2, '/': 2, '^': 3, "sin": 4, "cos": 4, "tan": 4}
postfix = []
stack = []
def is_number(char):
try:
float(char);return True
except ValueError: return False
for char in expression:
if is_number(char):
postfix.append(char)
elif char == '(':
stack.append(char)
elif char == ')':
while stack and stack[-1] != '(':
postfix.append(stack.pop())
stack.pop() # 弹出 '('
elif char in precedence:
while stack and stack[-1] != '(' and precedence.get(stack[-1], 0) >= precedence.get(char, 0):
postfix.append(stack.pop())
stack.append(char)
while stack:
postfix.append(stack.pop())
return postfix
expression = split_exp(expression) # 多位数拆分
precedence = {'+': 1, '-': 1, '*': 2, '/': 2}
postfix = []
stack = []
for char in expression:
if char.isdigit():
postfix.append(char)
elif char == '(':
stack.append(char)
elif char == ')':
while stack and stack[-1] != '(':
postfix.append(stack.pop())
stack.pop() # 弹出 '('
elif char in precedence:
while stack and stack[-1] != '(' and precedence[stack[-1]] >= precedence[char]:
'''这行代码的作用是在中缀表达式转换为后缀表达式的过程中，检查当前运算符与栈顶运算符的优先级。具体来说，它的功能是：
确保栈不为空（避免了索引错误）。
确保栈顶元素不是左括号 '('，因为左括号的优先级最低，不需要进行比较。
确保栈顶元素的优先级大于等于当前运算符的优先级，因为栈中的运算符都应该在当前运算符之前执行（栈顶元素的优先级大于等于当前运算符表示栈顶元素的操作要优先于当前操作执行）。'''
postfix.append(stack.pop())
stack.append(char)
while stack:
postfix.append(stack.pop())
return postfix
def get_postfix_expression(expression): # 将中缀表达式转化为后缀表达式
# 多位数拆分
expression = split_exp(expression)
precedence = {'+': 1, '-': 1, '*': 2, '/': 2, '^': 3, "sin": 4, "cos": 4, "tan": 4}
postfix = []
stack = []
def is_number(char):
try:
float(char)
return True
except ValueError:
return False
for char in expression:
if is_number(char):
postfix.append(char)
elif char == '(':
stack.append(char)
elif char == ')':
while stack and stack[-1] != '(':
postfix.append(stack.pop())
stack.pop() # 弹出 '('
elif char in precedence:
while stack and stack[-1] != '(' and precedence.get(stack[-1], 0) >= precedence.get(char, 0):
postfix.append(stack.pop())
stack.append(char)
while stack:
postfix.append(stack.pop())
return postfix
def calculate(root, TreeNode): # 计算节点树表达式
if root.NodeType == 'Value':
return float(root.FaceValue) if root.FaceValue.replace('.', '').isdigit() else None # 将操作数转换为浮点数
elif root.NodeType == 'Operator':
if root.Ops in ('sin', 'cos', 'tan'): # 检查是否是三角函数
if root.LeftNodeID is not None:
operand_value = calculate(find_node_by_id(root.LeftNodeID, TreeNode), TreeNode)
else:
operand_value = calculate(find_node_by_id(root.RightNodeID, TreeNode), TreeNode)
if operand_value is None:
return None
if root.Ops == 'sin':
return math.sin(operand_value)
elif root.Ops == 'cos':
return math.cos(operand_value)
elif root.Ops == 'tan':
return math.tan(operand_value)
else:
left_value = calculate(find_node_by_id(root.LeftNodeID, TreeNode), TreeNode)
right_value = calculate(find_node_by_id(root.RightNodeID, TreeNode), TreeNode)
if left_value is None or right_value is None:
return None
if root.Ops == '+':
return left_value + right_value
elif root.Ops == '-':
return left_value - right_value
elif root.Ops == '*':
return left_value * right_value
elif root.Ops == '^':
return left_value ** right_value
elif root.Ops == '/':
if right_value == 0:
return None # 除数为0，返回None表示计算错误
return left_value / right_value
return None # 节点类型不合法，返回None表示计算错误
if root.NodeType == 'Value':
return float(root.FaceValue) if root.FaceValue.replace('.', '').isdigit() else None # 将操作数转换为浮点数
elif root.NodeType == 'Operator':
if root.Ops in ('sin', 'cos', 'tan'): # 检查是否是三角函数
if root.LeftNodeID is not None:
operand_value = calculate(find_node_by_id(root.LeftNodeID, TreeNode), TreeNode)
else:
operand_value = calculate(find_node_by_id(root.RightNodeID, TreeNode), TreeNode)
if operand_value is None:
return None
if root.Ops == 'sin':
return math.sin(operand_value)
elif root.Ops == 'cos':
return math.cos(operand_value)
elif root.Ops == 'tan':
return math.tan(operand_value)
else:
left_value = calculate(find_node_by_id(root.LeftNodeID, TreeNode), TreeNode)
right_value = calculate(find_node_by_id(root.RightNodeID, TreeNode), TreeNode)
if left_value is None or right_value is None:
return None
if root.Ops == '+':
return left_value + right_value
elif root.Ops == '-':
return left_value - right_value
elif root.Ops == '*':
return left_value * right_value
elif root.Ops == '^':
return left_value ** right_value
elif root.Ops == '/':
if right_value == 0:
return None # 除数为0，返回None表示计算错误
return left_value / right_value # 除法结果为浮点数
return None # 节点类型不合法，返回None表示计算错误
def find_node_by_id(node_id, TreeNode):
for node in TreeNode:
if node.NodeID == node_id:
return node
return None
def evaluate_postfix(expression): # 计算后缀表达式
stack = []
for char in expression:
if char.isdigit():
stack.append(int(char))
elif char in OPS:
operand2 = stack.pop()
operand1 = stack.pop()
if char == '+':
result = operand1 + operand2
elif char == '-':
result = operand1 - operand2
elif char == '*':
result = operand1 * operand2
elif char == '^':
result = operand1 ** operand2
elif char == '/':
result = operand1 / operand2 # 这里假设除法结果为浮点数
stack.append(result)
return stack.pop()
for node in TreeNode:
if node.NodeID == node_id:
return node
return None
def evaluate_postfix(expression): # 计算后缀表达式
stack = []
for char in expression:
if char.isdigit():
stack.append(int(char))
elif char in OPS:
operand2 = stack.pop()
operand1 = stack.pop()
if char == '+':
result = operand1 + operand2
elif char == '-':
result = operand1 - operand2
elif char == '*':
result = operand1 * operand2
elif char == '^':
result = operand1 ** operand2
elif char == '/':
result = operand1 / operand2 # 这里假设除法结果为浮点数
stack.append(result)
return stack.pop()
def exp_to_treeNode_dict(exp_ls): # 返回嵌套节点字典
stack = []
for char in exp_ls:
two = {}
if char.isdigit():
stack.append(char)
elif char in OPS:
right = stack.pop()
left = stack.pop()
root = char
two[root] = [left,right]
stack.append(two)
return stack.pop()
stack = []
for char in exp_ls:
two = {}
if char.isdigit():
stack.append(char)
elif char in OPS:
right = stack.pop()
left = stack.pop()
root = char
two[root] = [left, right]
stack.append(two)
return stack.pop()
# 写一个函数从TreeNode中还原出表达式
def get_expression(TreeNode):
stack = []
for node in TreeNode:
if node.NodeType == 'Value':
stack.append(node.FaceValue)
elif node.NodeType == 'Operator':
if node.Ops in ('sin', 'cos', 'tan'): # 三角函数
right = stack.pop() # 三角函数只有右操作数
stack.append(f"{node.Ops}({right})")
else:
right = stack.pop()
left = stack.pop()
stack.append(f"({left}{node.Ops}{right})")
return stack.pop()
def ExpressionAnalyse(exp_ls): # 返回语法树
stack = [] # 符合和数值栈
TreeNode = []
face_color = ['Club', 'Diamond', 'Heart', 'Spade']
id = 0
for char in exp_ls:
fc = random.sample(face_color, 1)
if char.replace('.', '').isdigit(): # 检查字符是否是数字（包括小数）
stack.append(char)
elif char in OPS:
if char in ('sin', 'cos', 'tan'): # 检查运算符是否是三角函数
operand = stack.pop()
if isinstance(operand, str) and operand.replace('.', '').isdigit():
TreeNode.append(Node([id, 'Value', None, None, None, operand, fc]))
op_id = id
id += 1
else:
op_id = operand
root = char
TreeNode.append(Node([id, 'Operator', root, None, op_id, None, None]))
root_id = id
id += 1
stack.append(root_id)
else:
right = stack.pop()
if isinstance(right, str) and right.replace('.', '').isdigit():
TreeNode.append(Node([id, 'Value', None, None, None, right, fc]))
r_id = id
id += 1
else:
r_id = right
left = stack.pop()
if isinstance(left, str) and left.replace('.', '').isdigit():
TreeNode.append(Node([id, 'Value', None, None, None, left, fc]))
l_id = id
id += 1
else:
l_id = left
root = char
TreeNode.append(Node([id, 'Operator', root, l_id, r_id, None, None]))
root_id = id
id += 1
stack.append(root_id)
return TreeNode
stack = [] # 符合和数值栈
TreeNode = []
face_color = ['Club', 'Diamond', 'Heart', 'Spade']
id = 0
for char in exp_ls:
fc = random.sample(face_color, 1)
if char.replace('.', '').isdigit(): # 检查字符是否是数字（包括小数）
stack.append(char)
elif char in OPS:
if char in ('sin', 'cos', 'tan'): # 检查运算符是否是三角函数
operand = stack.pop()
if isinstance(operand, str) and operand.replace('.', '').isdigit():
TreeNode.append(Node([id, 'Value', None, None, None, operand, fc]))
op_id = id
id += 1
else:
op_id = operand
root = char
TreeNode.append(Node([id, 'Operator', root, None, op_id, None, None]))
root_id = id
id += 1
stack.append(root_id)
else:
right = stack.pop()
if isinstance(right, str) and right.replace('.', '').isdigit():
TreeNode.append(Node([id, 'Value', None, None, None, right, fc]))
r_id = id
id += 1
else:
r_id = right
left = stack.pop()
if isinstance(left, str) and left.replace('.', '').isdigit():
TreeNode.append(Node([id, 'Value', None, None, None, left, fc]))
l_id = id
id += 1
else:
l_id = left
root = char
TreeNode.append(Node([id, 'Operator', root, l_id, r_id, None, None]))
root_id = id
id += 1
stack.append(root_id)
return TreeNode
if __name__ == '__main__':
# Aexps = get_Aexps()
# Aexp = '((2+92)*3)+35'
# treeNode = get_TreeNode(Aexp)
# for node in treeNode:
# print(node)
# print(get_ast("2+9"))
#
# print(get_ast('(2+9)*3'))
#
# print("表达式","((6*3)+8)-6")
# print(get_ast('((6*(3-2))+8)-6'))
# print(infix_to_postfix('((9+8*3)+8)-6'))
# exp = '6.1+2^3*3'
exp = 'cos(0)+sin(0)+5'
exp_ls = get_postfix_expression(exp)
print(exp_ls)
# print(exp_to_treeNode_dict(exp_ls))
# exp_ls = ['3.3', '2', '^', '3', '3', '*', '-']
TreeNode= ExpressionAnalyse(exp_ls)
result = calculate(TreeNode[-1], TreeNode)
print(result)
#
# # print(TreeNode)
for node in TreeNode:
print(node)
# print_tree(Aexp)
# Aexps = get_Aexps()
# Aexp = '((2+92)*3)+35'
# treeNode = get_TreeNode(Aexp)
# for node in treeNode:
# print(node)
# print(get_ast("2+9"))
#
# print(get_ast('(2+9)*3'))
#
# print("表达式","((6*3)+8)-6")
# print(get_ast('((6*(3-2))+8)-6'))
# print(infix_to_postfix('((9+8*3)+8)-6'))
# exp = '6.1+2^3*3'
exp = 'cos(0)+sin(0)+5'
exp_ls = get_postfix_expression(exp)
print(exp_ls)
# print(exp_to_treeNode_dict(exp_ls))
# exp_ls = ['3.3', '2', '^', '3', '3', '*', '-']
TreeNode = ExpressionAnalyse(exp_ls)
result = calculate(TreeNode[-1], TreeNode)
print(result)
#
# # print(TreeNode)
for node in TreeNode:
print(node)
# print_tree(Aexp)

104
graph_24.py
Unescape View File

@ -4,66 +4,66 @@ from PySide6.QtWidgets import QGraphicsItem
class RoundedRectangleItem(QGraphicsItem, QObject):
selected = Signal(int)
unselected = Signal(int)
def __init__(self, x, y, text, id):
QGraphicsItem.__init__(self)
QObject.__init__(self)
self.rect = QRectF(x, y, 70, 70)
self.radius = 10
self.text = text
self.id = id
self.isSelected = False # 是否被选中
selected = Signal(int)
unselected = Signal(int)
def boundingRect(self):
return self.rect
def __init__(self, x, y, text, id):
QGraphicsItem.__init__(self)
QObject.__init__(self)
self.rect = QRectF(x, y, 70, 70)
self.radius = 10
self.text = text
self.id = id
self.isSelected = False # 是否被选中
def shape(self):
path = QPainterPath()
path.addRoundedRect(self.rect, self.radius, self.radius)
return path
def boundingRect(self):
return self.rect
def paint(self, painter, option, widget):
painter.setRenderHint(QPainter.Antialiasing) # 设置抗锯齿
pen = QPen(Qt.black)
painter.setPen(pen)
def shape(self):
path = QPainterPath()
path.addRoundedRect(self.rect, self.radius, self.radius)
return path
if self.isSelected:
# 如果被选中，设置不同的填充颜色和边框样式
painter.setBrush(QColor(255, 0, 0, 255)) # 设置选中时的填充颜色
pen.setWidth(2) # 设置边框宽度
pen.setStyle(Qt.DashLine) # 设置虚线边框样式
painter.setPen(pen)
else:
painter.setBrush(QColor(0, 255, 0, 255)) # 设置默认的填充颜色
def paint(self, painter, option, widget):
painter.setRenderHint(QPainter.Antialiasing) # 设置抗锯齿
pen = QPen(Qt.black)
painter.setPen(pen)
# 绘制圆角矩形
painter.drawRoundedRect(self.rect, self.radius, self.radius)
if self.isSelected:
# 如果被选中，设置不同的填充颜色和边框样式
painter.setBrush(QColor(255, 0, 0, 255)) # 设置选中时的填充颜色
pen.setWidth(2) # 设置边框宽度
pen.setStyle(Qt.DashLine) # 设置虚线边框样式
painter.setPen(pen)
else:
painter.setBrush(QColor(0, 255, 0, 255)) # 设置默认的填充颜色
# 计算文本的位置
font = painter.font()
font.setPointSize(36)
painter.setFont(font)
metrics = QFontMetricsF(font)
text_bounding_rect = metrics.boundingRect(str(self.text))
text_width = text_bounding_rect.width()
text_height = text_bounding_rect.height()
text_x = self.rect.center().x() - text_width / 2
text_y = self.rect.center().y() + text_height / 4
# 绘制圆角矩形
painter.drawRoundedRect(self.rect, self.radius, self.radius)
# 绘制文本
painter.drawText(text_x, text_y, str(self.text))
# 计算文本的位置
font = painter.font()
font.setPointSize(36)
painter.setFont(font)
metrics = QFontMetricsF(font)
text_bounding_rect = metrics.boundingRect(str(self.text))
text_width = text_bounding_rect.width()
text_height = text_bounding_rect.height()
text_x = self.rect.center().x() - text_width / 2
text_y = self.rect.center().y() + text_height / 4
def mousePressEvent(self, event):
# 鼠标点击时切换选中状态
self.isSelected = not self.isSelected
self.update()
# 绘制文本
painter.drawText(text_x, text_y, str(self.text))
# 发射选中信号
if self.isSelected:
self.selected.emit(self.id)
else:
self.unselected.emit(self.id)
def mousePressEvent(self, event):
# 鼠标点击时切换选中状态
self.isSelected = not self.isSelected
self.update()
# 发射选中信号
if self.isSelected:
self.selected.emit(self.id)
else:
self.unselected.emit(self.id)
super().mousePressEvent(event)
super().mousePressEvent(event)

890
main.py
Unescape View File

@ -1,451 +1,461 @@
import random
from PySide6.QtGui import QPainter, QPen, QFont, QPixmap
from PySide6.QtGui import QFont
from PySide6.QtWidgets import QApplication, QMainWindow, QGraphicsLineItem, QMessageBox, QGraphicsScene
from main_ui import Ui_MainWindow
import data
from graph_24 import *
from main_ui import Ui_MainWindow
class MainWindow(QMainWindow, Ui_MainWindow):
def __init__(self):
super().__init__()
self.drawn_tree_id = set() # 已经绘制了树的节点
self.seq = 1 # 在有树的情况下，添加节点的序号，以确定新加的节点位置
self.trees_root = [] # 保存所有树的根节点
self.selected_id = [] # 选中的节点ID
self.adds_id = set() # 已经用过的ID
self.value_nodes = [] # 数值节点
# self.operator_nodes = []
self.selected_ops = None # 选择的运算符
self.selected_value = None # 当前选择的卡片值
self.r_count = 0 # 记录所有答案点击次数
self.offset = 0 # 语法树遍历时随深度平移长度，避免节点重合
self.TreeNode = []
self.Tree_4_nums = None
self.setupUi(self)
self.init_ui()
self.init_slot()
self.pushButton_q.clicked.connect(self.show_card)
self.pushButton_ex.clicked.connect(self.show_card)
self.pushButton_autosv.clicked.connect(self.AutoTest_9_10)
self.pushButton_dtree.clicked.connect(self.draw_tree)
self.pushButton_ast.clicked.connect(self.calculate_button)
self.pushButton_allan.clicked.connect(self.AutoTest)
self.clear_button.clicked.connect(self.secen_clear)
self.pushButton_add.clicked.connect(lambda :self.select_ops('+'))
self.pushButton_sub.clicked.connect(lambda :self.select_ops('-'))
self.pushButton_mul.clicked.connect(lambda :self.select_ops('*'))
self.pushButton_div.clicked.connect(lambda :self.select_ops('/'))
self.add_val_node.clicked.connect(self.add_value_node)
self.add_ops_node.clicked.connect(self.add_operator_node)
self.ex_node_value.clicked.connect(self.exchange_value_node)
self.ex_node_ops.clicked.connect(self.exchange_ops_node)
self.ex_node_self.clicked.connect(self.exchange_two_nodes)
def secen_clear(self):
self.scene.clear()
self.selected_id = []
self.value_nodes = []
self.TreeNode = []
self.adds_id = set()
self.trees_root = []
self.drawn_tree_id = set()
self.selected_value = None # 当前选择的卡片值.
self.selected_ops = None # 选择的运算符
# 清空运算符显示
self.lb_ops_selected.setText("")
def select_ops(self, ops):
self.lb_ops_selected.setText(ops)
self.selected_ops = ops
def add_value_node(self):
# self.scene.clear()
if self.selected_value is not None: # 选择了卡片值
self.value_nodes.append(self.selected_value) # 添加到节点数值列表
for i in range(len(self.adds_id)+1):
if i not in self.adds_id:
value = self.selected_value
nodet = RoundedRectangleItem(150*self.seq, 0, str(value), i)
self.seq += 1 # 序号加1
nodet.selected.connect(lambda id: self.selected_node(id)) # 连接信号
nodet.unselected.connect(lambda id: self.unselected_node(id))
node = data.Node([i, 'Value', None, None, None, value, None])
self.adds_id.add(i) # 添加全局id
self.TreeNode.append(node)
self.scene.addItem(nodet)
else:
QMessageBox.warning(self, '警告', '请先选择一张牌')
def judge_node_conn(self): # 判断节点是否已经连接
for id in self.selected_id:
for node in self.TreeNode:
if node.LeftNodeID == id or node.RightNodeID == id:
return True
def add_operator_node(self):
if self.selected_ops is not None:
if len(self.selected_id) == 2:
# 判断已选节点是否已经被连接
if self.judge_node_conn():
QMessageBox.warning(self, '警告', '节点已经连接')
return
for i in range(len(self.adds_id)+1): # 确保id唯一
if i not in self.adds_id:
node = data.Node([i, 'Operator', self.selected_ops, None, None, None, None])
self.TreeNode.append(node)
self.adds_id.add(i) # 全局ID
node.LeftNodeID = int(self.selected_id[1])
node.RightNodeID = int(self.selected_id[0])
self.flash_node(self.selected_id[0])
self.flash_node(self.selected_id[1])
self.selected_id = [] # 清空选中的节点
self.trees_root.append(node) # 保存根节点
# 从根节点列表中删去作为子节点连接的节点
node_to_remove = []
for root in self.trees_root:
if root.NodeID == node.LeftNodeID or root.NodeID == node.RightNodeID:
node_to_remove.append(root)
for root in node_to_remove:
self.trees_root.remove(root)
print("已用ID", self.adds_id)
self.scene.clear()
for i, root in enumerate(self.trees_root):
if self.has_both_operators(self.TreeNode):
self.offset = 35
self.ShowTree(root, self.TreeNode,i*300, 0)
self.offset = 0
self.seq = 1 # 重置序号
for noed in self.TreeNode:
print("运算符节点", noed)
else:
QMessageBox.warning(self, '警告', '请先选择两个节点')
else:
QMessageBox.warning(self, '警告', '请先选择一个运算符')
def exchange_value_node(self):
# 修改节点值
if len(self.selected_id) == 1:
if self.selected_value:
if self.TreeNode:
for node in self.TreeNode:
if node.NodeID == self.selected_id[0]:
node.FaceValue = self.selected_value
for nodet in self.scene.items():
if isinstance(nodet, RoundedRectangleItem):
if nodet.id == self.selected_id[0]:
nodet.text = str(self.selected_value)
nodet.update()
else:
QMessageBox.warning(self, '警告', '请先选择一张牌')
else:
QMessageBox.warning(self, '警告', '请先选择一个节点')
def exchange_ops_node(self):
# 修改节点运算符
if len(self.selected_id) == 1:
if self.selected_ops:
if self.TreeNode:
for node in self.TreeNode:
if node.NodeID == self.selected_id[0]:
node.Ops = self.selected_ops
for nodet in self.scene.items():
if isinstance(nodet, RoundedRectangleItem):
if nodet.id == self.selected_id[0]:
nodet.text = str(self.selected_ops)
nodet.update()
else:
QMessageBox.warning(self, '警告', '请先选择一个运算符')
else:
QMessageBox.warning(self, '警告', '请先选择一个节点')
def exchange_two_nodes(self):
# 交换选中两个节点FaceValue的值
if len(self.selected_id) == 2:
if self.TreeNode:
node_1 = None
node_2 = None
for node in self.TreeNode:
if node.NodeID == self.selected_id[0]:
if node.NodeType == 'Value':
node_1 = node
else:
QMessageBox.warning(self, '警告', '请选择两个数值节点')
return
elif node.NodeID == self.selected_id[1]:
if node.NodeType == 'Value':
node_2 = node
else:
QMessageBox.warning(self, '警告', '请选择两个数值节点')
return
if node_1 and node_2:
node_1.FaceValue, node_2.FaceValue = node_2.FaceValue, node_1.FaceValue
for item in self.scene.items():
if isinstance(item, RoundedRectangleItem):
if item.id == self.selected_id[0]:
item.text = str(node_1.FaceValue)
item.update()
elif item.id == self.selected_id[1]:
item.text = str(node_2.FaceValue)
item.update()
else:
QMessageBox.warning(self, '警告', '请选择两个节点')
def selected_node(self, id):
if len(self.selected_id) < 2:
self.selected_id.append(id)
else:
QMessageBox.warning(self, '警告', '不能选择超过3个节点')
for nodet in self.scene.items(): # 遍历场景中的所有图元
if isinstance(nodet, RoundedRectangleItem): # 如果是圆角矩形
if nodet.id == id: # 如果是当前选中的节点
nodet.isSelected = False # 取消选中
nodet.update() # 更新图元
def unselected_node(self, id):
self.selected_id.remove(id)
print(self.selected_id)
def flash_node(self, id): # 还原节点为未选中状态
for nodet in self.scene.items(): # 遍历场景中的所有图元
if isinstance(nodet, RoundedRectangleItem): # 如果是圆角矩形
if nodet.id == id: # 如果是当前选中的节点
nodet.isSelected = False # 取消选中
nodet.update() # 更新图元
def init_ui(self):
self.scene = QGraphicsScene()
self.graphicsView.setScene(self.scene)
def init_slot(self):
self.pushButton.clicked.connect(self.on_calc)
def load_image(self, path, Tree_4_nums, index):
def current_selection(value, path):
self.selected_value = value
self.p1_selected.setStyleSheet(f"border-image: url({path});")
self.pushButton_ast.setEnabled(False)
self.pushButton_allan.setEnabled(False)
self.pushButton_dtree.setEnabled(False)
self.pushButton_autosv.setEnabled(False)
print(value)
if index == 0:
self.p1.setStyleSheet(f"border-image: url({path});")
self.p1.clicked.connect(lambda :current_selection(Tree_4_nums[index], path))
elif index == 1:
self.p2.setStyleSheet(f"border-image: url({path});")
self.p2.clicked.connect(lambda :current_selection(Tree_4_nums[index], path))
elif index == 2:
self.p3.setStyleSheet(f"border-image: url({path});")
self.p3.clicked.connect(lambda :current_selection(Tree_4_nums[index], path))
elif index == 3:
self.p4.setStyleSheet(f"border-image: url({path});")
self.p4.clicked.connect(lambda :current_selection(Tree_4_nums[index], path))
def show_card(self):
self.pushButton_ast.setEnabled(True)
self.pushButton_allan.setEnabled(True)
self.pushButton_dtree.setEnabled(True)
self.pushButton_autosv.setEnabled(True)
self.p1_selected.setStyleSheet("border-image: none;")
# 原始数组
self.lineEdit.clear()
self.label_result.setText(" =? ")
self.label_TF.setText("")
original_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
face_card = ['Club', 'Diamond', 'Heart', 'Spade']
# 从原始数组中随机选择4个元素组成新列表
self.Tree_4_nums = random.sample(original_list, 4)
# 从花色中随机选择一个
for index, num in enumerate(self.Tree_4_nums):
card_face = random.choice(face_card)
if num == 11:
card_path = f"card/{card_face}/{card_face}j.png"
elif num == 12:
card_path = f"card/{card_face}/{card_face}q.png"
elif num == 13:
card_path = f"card/{card_face}/{card_face}k.png"
else:
card_path = f"card/{card_face}/{card_face}{num}.png"
self.load_image(card_path, self.Tree_4_nums, index)
# return self.Tree_4_nums
def AutoTest(self):
if self.Tree_4_nums is None:
QMessageBox.warning(self, '警告', '请先出题')
return
else:
results = data.get_Aexps(self.Tree_4_nums)
if results == "无法得出24点":
self.lineEdit.clear()
self.lineEdit.setText("无法得出24点")
return
else:
if self.r_count < len(results):
self.lineEdit.clear()
self.lineEdit.setText(f"{results[self.r_count]}")
self.on_calc() # 自动计算
self.draw_tree() # 绘制语法树
self.r_count += 1
else:
QMessageBox.information(self, '提示', '已经是最后一个表达式了')
self.r_count = 0
def AutoTest_9_10(self):
if self.Tree_4_nums is None:
QMessageBox.warning(self, '警告', '请先出题')
return
else:
aexp = data.gen_exp(self.Tree_4_nums)
if aexp == "无法得出24点":
self.lineEdit.clear()
self.lineEdit.setText("无法得出24点")
else:
self.lineEdit.clear()
self.lineEdit.setText(f"{aexp}")
self.on_calc() # 自动计算
self.draw_tree() # 绘制语法树
def calculate_button(self): #
self.scene.clear()
aexp = self.lineEdit.text()
try:
exp_ls = data.get_postfix_expression(aexp) # 获取后缀表达式列表
self.TreeNode = data.ExpressionAnalyse(exp_ls) # 将后缀表达式转化为节点树
result = data.calculate(self.TreeNode[-1], self.TreeNode)
self.label_result.setText(f"={result}")
except:
QMessageBox.warning(self, '警告', '表达式错误！')
return
if self.TreeNode:
root = self.TreeNode[-1]
result = data.calculate(root, self.TreeNode)
self.label_result.setText(f"={result}")
self.result_ToF(int(result))
if self.has_both_operators(self.TreeNode):
self.offset = 35
self.ShowTree(root, self.TreeNode)
self.offset = 0
def has_both_operators(self, TreeNode): # 判断是否同时有两个运算符
ops = data.OPS
def find_op_by_id(id): # 根据ID查找运算符
for node in TreeNode:
if node.NodeID == id and node.NodeType == "Operator":
return node.Ops
for node in TreeNode: # 遍历节点树
if node.NodeType == "Operator":
opl = find_op_by_id(node.LeftNodeID)
opr = find_op_by_id(node.RightNodeID)
if opl in ops and opr in ops:
return True
def draw_tree(self):
self.scene.clear()
aexp = self.lineEdit.text()
if aexp == "":
QMessageBox.warning(self, '警告', '请输入表达式')
return
try:
exp_ls = data.get_postfix_expression(aexp) # 获取后缀表达式列表
self.TreeNode = data.ExpressionAnalyse(exp_ls) # 将后缀表达式转化为节点树
root = self.TreeNode[-1]
if self.has_both_operators(self.TreeNode):
self.offset = 35
self.ShowTree(root, self.TreeNode, depth=0)
self.offset = 0
except Exception as e:
QMessageBox.warning(self, '警告', '表达式错误')
def ShowTree(self, root, TreeNode, startx=0, starty=0, depth=0):
# 绘制根节点
if root.NodeType == 'Value':
nds_root = RoundedRectangleItem(startx, starty, root.FaceValue, root.NodeID)
nds_root.selected.connect(lambda id: self.selected_node(id))
nds_root.unselected.connect(lambda id: self.unselected_node(id))
self.drawn_tree_id.add(root.NodeID)
else:
nds_root = RoundedRectangleItem(startx, starty, root.Ops, root.NodeID)
nds_root.selected.connect(lambda id: self.selected_node(id))
nds_root.unselected.connect(lambda id: self.unselected_node(id))
self.drawn_tree_id.add(root.NodeID)
nds_root.setZValue(1)
self.scene.addItem(nds_root)
# 计算节点间的水平偏移量
horizontal_offset = 100 - depth*self.offset
# 计算左子树和右子树的位置
left_x, left_y = startx - horizontal_offset, starty + 100
right_x, right_y = startx + horizontal_offset, starty + 100
# 绘制左子树
if root.LeftNodeID is not None:
left_child = next(node for node in TreeNode if node.NodeID == root.LeftNodeID)
self.ShowTree(left_child, TreeNode, left_x, left_y, depth + 1)
# 绘制左子树与根节点之间的连线
line_left = QGraphicsLineItem(startx + 35, starty + 35, left_x + 35, left_y + 35)
line_left.setZValue(-1)
line_left.setPen(QPen(Qt.red, 3))
self.scene.addItem(line_left)
# 绘制右子树
if root.RightNodeID is not None:
right_child = next(node for node in TreeNode if node.NodeID == root.RightNodeID)
self.ShowTree(right_child, TreeNode, right_x, right_y, depth + 1)
# 绘制右子树与根节点之间的连线
line_right = QGraphicsLineItem(startx + 35, starty + 35, right_x + 35, right_y + 35)
line_right.setZValue(-1)
line_right.setPen(QPen(Qt.red, 3))
self.scene.addItem(line_right)
def on_calc(self):
aexp = self.lineEdit.text()
if aexp == '':
QMessageBox.warning(self, '警告', '请输入表达式')
return
try:
result = eval(aexp)
self.label_result.setText(f"={int(result)}")
# 设置字体样式
self.result_ToF(result)
except Exception as e:
QMessageBox.warning(self, '警告', '表达式错误')
return
def result_ToF(self,result):
font = QFont('Microsoft YaHei', 16)
font.setBold(True) # 将字体设置为粗体
self.label_TF.setText('√' if result == 24 else '×')
# 将字体样式应用到 QLabel 上
self.label_TF.setFont(font)
# 将文本颜色设置为红色
self.label_TF.setStyleSheet("color: red;background-color:rgb(219, 205, 166)")
def __init__(self):
super().__init__()
self.drawn_tree_id = set() # 已经绘制了树的节点
self.seq = 1 # 在有树的情况下，添加节点的序号，以确定新加的节点位置
self.trees_root = [] # 保存所有树的根节点
self.selected_id = [] # 选中的节点ID
self.adds_id = set() # 已经用过的ID
self.value_nodes = [] # 数值节点
# self.operator_nodes = []
self.selected_ops = None # 选择的运算符
self.selected_value = None # 当前选择的卡片值
self.r_count = 0 # 记录所有答案点击次数
self.offset = 0 # 语法树遍历时随深度平移长度，避免节点重合
self.TreeNode = []
self.Tree_4_nums = None
self.setupUi(self)
self.init_ui()
self.init_slot()
self.pushButton_q.clicked.connect(self.show_card) # 显示卡片
self.pushButton_ex.clicked.connect(self.show_card) # 显示卡片
self.pushButton_autosv.clicked.connect(self.AutoTest_9_10) # 自动求解
self.pushButton_dtree.clicked.connect(self.draw_tree) # 绘制语法树
self.pushButton_ast.clicked.connect(self.calculate_button) # 生成语法树
self.pushButton_allan.clicked.connect(self.AutoTest) # 自动求解
self.clear_button.clicked.connect(self.secen_clear) # 清空画布
self.pushButton_add.clicked.connect(lambda: self.select_ops('+'))
self.pushButton_sub.clicked.connect(lambda: self.select_ops('-'))
self.pushButton_mul.clicked.connect(lambda: self.select_ops('*'))
self.pushButton_div.clicked.connect(lambda: self.select_ops('/'))
self.add_val_node.clicked.connect(self.add_value_node) # 添加数值节点
self.add_ops_node.clicked.connect(self.add_operator_node) # 添加运算符节点
self.ex_node_value.clicked.connect(self.exchange_value_node) # 修改数值节点
self.ex_node_ops.clicked.connect(self.exchange_ops_node) # 修改运算符节点
self.ex_node_self.clicked.connect(self.exchange_two_nodes) # 交换两个节点
self.pushButton_exp.clicked.connect(self.agent_exp) # 生成表达式
def secen_clear(self):
self.scene.clear()
self.selected_id = [] # 选中的节点ID
self.value_nodes = [] # 数值节点
self.TreeNode = [] # 所有节点
self.adds_id = set() # 已经用过的ID
self.trees_root = [] # 保存所有树的根节点
self.drawn_tree_id = set() # 已经绘制了树的节点
self.selected_value = None # 当前选择的卡片值.
self.selected_ops = None # 选择的运算符
# 清空运算符显示
self.lb_ops_selected.setText("") # 运算符显示
def select_ops(self, ops):
self.lb_ops_selected.setText(ops)
self.selected_ops = ops
def add_value_node(self):
# self.scene.clear()
if self.selected_value is not None: # 选择了卡片值
self.value_nodes.append(self.selected_value) # 添加到节点数值列表
for i in range(len(self.adds_id) + 1):
if i not in self.adds_id:
value = self.selected_value
nodet = RoundedRectangleItem(150 * self.seq, 0, str(value), i)
self.seq += 1 # 序号加1
nodet.selected.connect(lambda id: self.selected_node(id)) # 连接信号
nodet.unselected.connect(lambda id: self.unselected_node(id))
node = data.Node([i, 'Value', None, None, None, value, None])
self.adds_id.add(i) # 添加全局id
self.TreeNode.append(node)
self.scene.addItem(nodet)
else:
QMessageBox.warning(self, '警告', '请先选择一张牌')
def judge_node_conn(self): # 判断节点是否已经连接
for id in self.selected_id:
for node in self.TreeNode:
if node.LeftNodeID == id or node.RightNodeID == id:
return True
def add_operator_node(self): # 添加运算符节点
if self.selected_ops is not None:
if len(self.selected_id) == 2:
# 判断已选节点是否已经被连接
if self.judge_node_conn():
QMessageBox.warning(self, '警告', '节点已经连接')
return
for i in range(len(self.adds_id) + 1): # 确保id唯一
if i not in self.adds_id:
node = data.Node([i, 'Operator', self.selected_ops, None, None, None, None])
self.TreeNode.append(node)
self.adds_id.add(i) # 全局ID
node.LeftNodeID = int(self.selected_id[1])
node.RightNodeID = int(self.selected_id[0])
self.flash_node(self.selected_id[0])
self.flash_node(self.selected_id[1])
self.selected_id = [] # 清空选中的节点
self.trees_root.append(node) # 保存根节点
# 从根节点列表中删去作为子节点连接的节点
node_to_remove = []
for root in self.trees_root:
if root.NodeID == node.LeftNodeID or root.NodeID == node.RightNodeID:
node_to_remove.append(root)
for root in node_to_remove:
self.trees_root.remove(root)
print("已用ID", self.adds_id)
self.scene.clear()
for i, root in enumerate(self.trees_root):
if self.has_both_operators(self.TreeNode):
self.offset = 35
self.ShowTree(root, self.TreeNode, i * 300, 0)
self.offset = 0
self.seq = 1 # 重置序号
for noed in self.TreeNode:
print("运算符节点", noed)
exps = data.get_expression(self.TreeNode)
print("表达式", exps)
else:
QMessageBox.warning(self, '警告', '请先选择两个节点')
else:
QMessageBox.warning(self, '警告', '请先选择一个运算符')
def exchange_value_node(self):
# 修改节点值
if len(self.selected_id) == 1:
if self.selected_value:
if self.TreeNode:
for node in self.TreeNode:
if node.NodeID == self.selected_id[0]:
node.FaceValue = self.selected_value
for nodet in self.scene.items():
if isinstance(nodet, RoundedRectangleItem):
if nodet.id == self.selected_id[0]:
nodet.text = str(self.selected_value)
nodet.update()
else:
QMessageBox.warning(self, '警告', '请先选择一张牌')
else:
QMessageBox.warning(self, '警告', '请先选择一个节点')
def exchange_ops_node(self):
# 修改节点运算符
if len(self.selected_id) == 1:
if self.selected_ops:
if self.TreeNode:
for node in self.TreeNode:
if node.NodeID == self.selected_id[0]:
node.Ops = self.selected_ops
for nodet in self.scene.items():
if isinstance(nodet, RoundedRectangleItem):
if nodet.id == self.selected_id[0]:
nodet.text = str(self.selected_ops)
nodet.update()
else:
QMessageBox.warning(self, '警告', '请先选择一个运算符')
else:
QMessageBox.warning(self, '警告', '请先选择一个节点')
def exchange_two_nodes(self):
# 交换选中两个节点FaceValue的值
if len(self.selected_id) == 2:
if self.TreeNode:
node_1 = None
node_2 = None
for node in self.TreeNode:
if node.NodeID == self.selected_id[0]:
if node.NodeType == 'Value':
node_1 = node
else:
QMessageBox.warning(self, '警告', '请选择两个数值节点')
return
elif node.NodeID == self.selected_id[1]:
if node.NodeType == 'Value':
node_2 = node
else:
QMessageBox.warning(self, '警告', '请选择两个数值节点')
return
if node_1 and node_2:
node_1.FaceValue, node_2.FaceValue = node_2.FaceValue, node_1.FaceValue
for item in self.scene.items():
if isinstance(item, RoundedRectangleItem):
if item.id == self.selected_id[0]:
item.text = str(node_1.FaceValue)
item.update()
elif item.id == self.selected_id[1]:
item.text = str(node_2.FaceValue)
item.update()
else:
QMessageBox.warning(self, '警告', '请选择两个节点')
def selected_node(self, id):
if len(self.selected_id) < 2:
self.selected_id.append(id)
else:
QMessageBox.warning(self, '警告', '不能选择超过3个节点')
for nodet in self.scene.items(): # 遍历场景中的所有图元
if isinstance(nodet, RoundedRectangleItem): # 如果是圆角矩形
if nodet.id == id: # 如果是当前选中的节点
nodet.isSelected = False # 取消选中
nodet.update() # 更新图元
def unselected_node(self, id):
self.selected_id.remove(id)
print(self.selected_id)
def flash_node(self, id): # 还原节点为未选中状态
for nodet in self.scene.items(): # 遍历场景中的所有图元
if isinstance(nodet, RoundedRectangleItem): # 如果是圆角矩形
if nodet.id == id: # 如果是当前选中的节点
nodet.isSelected = False # 取消选中
nodet.update() # 更新图元
def init_ui(self):
self.scene = QGraphicsScene()
self.graphicsView.setScene(self.scene)
def init_slot(self):
self.pushButton.clicked.connect(self.on_calc)
def load_image(self, path, Tree_4_nums, index):
def current_selection(value, path):
self.selected_value = value
self.p1_selected.setStyleSheet(f"border-image: url({path});")
self.pushButton_ast.setEnabled(False)
self.pushButton_allan.setEnabled(False)
self.pushButton_dtree.setEnabled(False)
self.pushButton_autosv.setEnabled(False)
# print(value)
if index == 0:
self.p1.setStyleSheet(f"border-image: url({path});")
self.p1.clicked.connect(lambda: current_selection(Tree_4_nums[index], path))
elif index == 1:
self.p2.setStyleSheet(f"border-image: url({path});")
self.p2.clicked.connect(lambda: current_selection(Tree_4_nums[index], path))
elif index == 2:
self.p3.setStyleSheet(f"border-image: url({path});")
self.p3.clicked.connect(lambda: current_selection(Tree_4_nums[index], path))
elif index == 3:
self.p4.setStyleSheet(f"border-image: url({path});")
self.p4.clicked.connect(lambda: current_selection(Tree_4_nums[index], path))
def show_card(self):
self.pushButton_ast.setEnabled(True)
self.pushButton_allan.setEnabled(True)
self.pushButton_dtree.setEnabled(True)
self.pushButton_autosv.setEnabled(True)
self.p1_selected.setStyleSheet("border-image: none;")
# 原始数组
self.lineEdit.clear()
self.label_result.setText(" =? ")
self.label_TF.setText("")
original_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
face_card = ['Club', 'Diamond', 'Heart', 'Spade']
# 从原始数组中随机选择4个元素组成新列表
self.Tree_4_nums = random.sample(original_list, 4)
# 从花色中随机选择一个
for index, num in enumerate(self.Tree_4_nums):
card_face = random.choice(face_card)
if num == 11:
card_path = f"card/{card_face}/{card_face}j.png"
elif num == 12:
card_path = f"card/{card_face}/{card_face}q.png"
elif num == 13:
card_path = f"card/{card_face}/{card_face}k.png"
else:
card_path = f"card/{card_face}/{card_face}{num}.png"
self.load_image(card_path, self.Tree_4_nums, index)
# return self.Tree_4_nums
def AutoTest(self):
if self.Tree_4_nums is None:
QMessageBox.warning(self, '警告', '请先出题')
return
else:
results = data.get_Aexps(self.Tree_4_nums)
if results == "无法得出24点":
self.lineEdit.clear()
self.lineEdit.setText("无法得出24点")
return
else:
if self.r_count < len(results):
self.lineEdit.clear()
self.lineEdit.setText(f"{results[self.r_count]}")
self.on_calc() # 自动计算
self.draw_tree() # 绘制语法树
self.r_count += 1
else:
QMessageBox.information(self, '提示', '已经是最后一个表达式了')
self.r_count = 0
def AutoTest_9_10(self):
if self.Tree_4_nums is None:
QMessageBox.warning(self, '警告', '请先出题')
return
else:
aexp = data.gen_exp(self.Tree_4_nums)
if aexp == "无法得出24点":
self.lineEdit.clear()
self.lineEdit.setText("无法得出24点")
else:
self.lineEdit.clear()
self.lineEdit.setText(f"{aexp}")
self.on_calc() # 自动计算
self.draw_tree() # 绘制语法树
def calculate_button(self): # 计算生成语法树
self.scene.clear()
aexp = self.lineEdit.text()
try:
exp_ls = data.get_postfix_expression(aexp) # 获取后缀表达式列表
self.TreeNode = data.ExpressionAnalyse(exp_ls) # 将后缀表达式转化为节点树
result = data.calculate(self.TreeNode[-1], self.TreeNode)
self.label_result.setText(f"={round(result, 2)}")
except:
QMessageBox.warning(self, '警告', '表达式错误！')
return
if self.TreeNode: # 如果节点树不为空
root = self.TreeNode[-1]
result = data.calculate(root, self.TreeNode) # 计算表达式的值
self.label_result.setText(f"={round(result, 2)}")
self.result_ToF(int(result)) # 判断结果是否为24
if self.has_both_operators(self.TreeNode):
self.offset = 35
self.ShowTree(root, self.TreeNode)
self.offset = 0
def has_both_operators(self, TreeNode): # 判断是否同时有两个运算符
ops = data.OPS
def find_op_by_id(id): # 根据ID查找运算符
for node in TreeNode:
if node.NodeID == id and node.NodeType == "Operator":
return node.Ops
for node in TreeNode: # 遍历节点树
if node.NodeType == "Operator":
opl = find_op_by_id(node.LeftNodeID)
opr = find_op_by_id(node.RightNodeID)
if opl in ops and opr in ops:
return True
def draw_tree(self):
self.scene.clear()
aexp = self.lineEdit.text()
if aexp == "":
QMessageBox.warning(self, '警告', '请输入表达式')
return
try:
exp_ls = data.get_postfix_expression(aexp) # 获取后缀表达式列表
self.TreeNode = data.ExpressionAnalyse(exp_ls) # 将后缀表达式转化为节点树
root = self.TreeNode[-1]
if self.has_both_operators(self.TreeNode):
self.offset = 35
self.ShowTree(root, self.TreeNode, depth=0)
self.offset = 0
except Exception as e:
QMessageBox.warning(self, '警告', '表达式错误')
def ShowTree(self, root, TreeNode, startx=0, starty=0, depth=0):
self.selected_id = [] # 清空选中的节点
self.drawn_tree_id = set() # 清空已绘制的节点ID
# 绘制根节点
if root.NodeType == 'Value':
nds_root = RoundedRectangleItem(startx, starty, root.FaceValue, root.NodeID)
nds_root.selected.connect(lambda id: self.selected_node(id))
nds_root.unselected.connect(lambda id: self.unselected_node(id))
self.drawn_tree_id.add(root.NodeID)
self.adds_id.add(root.NodeID)
else:
nds_root = RoundedRectangleItem(startx, starty, root.Ops, root.NodeID)
nds_root.selected.connect(lambda id: self.selected_node(id))
nds_root.unselected.connect(lambda id: self.unselected_node(id))
self.drawn_tree_id.add(root.NodeID)
self.adds_id.add(root.NodeID)
nds_root.setZValue(1)
self.scene.addItem(nds_root)
# 计算节点间的水平偏移量
horizontal_offset = 100 - depth * self.offset
# 计算左子树和右子树的位置
left_x, left_y = startx - horizontal_offset, starty + 100
right_x, right_y = startx + horizontal_offset, starty + 100
# 绘制左子树
if root.LeftNodeID is not None:
left_child = next(node for node in TreeNode if node.NodeID == root.LeftNodeID)
self.ShowTree(left_child, TreeNode, left_x, left_y, depth + 1)
# 绘制左子树与根节点之间的连线
line_left = QGraphicsLineItem(startx + 35, starty + 35, left_x + 35, left_y + 35)
line_left.setZValue(-1)
line_left.setPen(QPen(Qt.red, 3))
self.scene.addItem(line_left)
# 绘制右子树
if root.RightNodeID is not None:
right_child = next(node for node in TreeNode if node.NodeID == root.RightNodeID)
self.ShowTree(right_child, TreeNode, right_x, right_y, depth + 1)
# 绘制右子树与根节点之间的连线
line_right = QGraphicsLineItem(startx + 35, starty + 35, right_x + 35, right_y + 35)
line_right.setZValue(-1)
line_right.setPen(QPen(Qt.red, 3))
self.scene.addItem(line_right)
def on_calc(self):
aexp = self.lineEdit.text()
if aexp == '':
QMessageBox.warning(self, '警告', '请输入表达式')
return
try:
result = eval(aexp)
self.label_result.setText(f"={int(result)}")
# 设置字体样式
self.result_ToF(result)
except Exception as e:
QMessageBox.warning(self, '警告', '表达式错误')
return
def result_ToF(self, result):
font = QFont('Microsoft YaHei', 16)
font.setBold(True) # 将字体设置为粗体
self.label_TF.setText('√' if result == 24 else '×')
# 将字体样式应用到 QLabel 上
self.label_TF.setFont(font)
# 将文本颜色设置为红色
self.label_TF.setStyleSheet("color: red;background-color:rgb(219, 205, 166)")
def agent_exp(self):
if self.TreeNode is not None:
exp_str = data.get_expression(self.TreeNode)
if exp_str is not None:
self.label_result.clear() # 清空显示结果
self.lineEdit.clear() # 清空显示表达式
self.lineEdit.setText(exp_str) # 显示表达式
else:
QMessageBox.warning(self, '警告', '无法生成表达式')
else:
QMessageBox.warning(self, '警告', '当前无语法树')
if __name__ == '__main__':
app = QApplication()
window = MainWindow()
window.show()
app.exec()
app = QApplication()
window = MainWindow()
window.show()
app.exec()

Write Preview
Loading…
Cancel
Save