四则运算题目生成

四则运算题目生成——李安琪

PSP表格

PSP2.1	Personal Software Process Stages	预估耗时（分钟）	实际耗时（分钟）
Planning	计划	5	20
· Estimate	· 估计这个任务需要多少时间	5	5
Development	开发	1210	1295
· Analysis	· 需求分析 (包括学习新技术)	30	30
· Design Spec	· 生成设计文档	60	50
· Design Review	· 设计复审 (和同事审核设计文档)	10	20
· Coding Standard	· 代码规范 (为目前的开发制定合适的规范)	10	10
· Design	· 具体设计	30	45
· Coding	· 具体编码	1000	1060
· Code Review	· 代码复审	30	20
· Test	· 测试（自我测试，修改代码，提交修改）	40	60
Reporting	报告	80	70
· Test Report	· 测试报告	30	30
· Size Measurement	· 计算工作量	30	20
· Postmortem & Process Improvement Plan	· 事后总结, 并提出过程改进计划	20	20
	合计	1295	1385

实际花在代码编写、测试、修改的时间比预期要多，因为在预期阶段没有考虑到算法上的难度和细节上的小bug。但实际时间并没有比预期多很多，相差时间在合理范围内。

实验环境：

Dev-c++

QT Creator 4.12.2 (community)

Windows 10 家庭版

实验目标（三阶段）

第1阶段

写一个能自动生成小学四则运算题目的命令行 “软件”， 分别满足下面的各种需求。

下面这些需求都可以用命令行参数的形式来指定：

a) 一次可以出一千道道题目，并且没有重复的，把题目写入一个文件中。

任何两道题目不能通过有限次交换+和×左右的算术表达式变换为同一道题目。例如，23 + 45 = 和45 + 23 = 是重复的题目，6 × 8 = 和8 × 6 = 也是重复的题目。3+(2+1)和1+2+3这两个题目是重复的，由于+是左结合的，1+2+3等价于(1+2)+3，也就是3+(1+2)，也就是3+(2+1)。但是1+2+3和3+2+1是不重复的两道题，因为1+2+3等价于(1+2)+3，而3+2+1等价于(3+2)+1，它们之间不能通过有限次交换变成同一个题目。

b) 当有多于一个运算符的时候，如何对一个表达式求值？逐步扩展功能和可以支持的表达式类型，最后希望能支持下面类型的题目 （最多 10 个运算符，括号的数量不限制）：

     25 - 3 * 4 - 2 / 2 + 89 = ？
     1/2 + 1/3 - 1/4 = ？ 
    （5 - 4 ） * （3 +28） =？

c) 除了整数以外，还要支持真分数的四则运算。 （例如： 1/6 + 1/8 = 7/24 )

d) 让程序能接受用户输入答案，并判定对错。 最后给出总共 对/错 的数量。

第2阶段

增加一个运算符，要支持乘方(power)运算。乘方运算的优先级高于乘除法。如何表示乘方，有两种表示方法：

4 ^ 2 = 16,   4 的二次方等于 16。  这里， ^ 表示乘方
4 ** 2 = 16,   4 的二次方等于16。  这里， **  表示乘方 （** 之间不能有空格，否则是错误的算式）

两种表示方法都要支持，可以通过设置来选择。

第3阶段

结对的同学商量一下，从以下几个方向中选择一个，对程序进行扩展。

• 把程序变成一个 Windows/Mac/Linux 电脑图形界面的程序 (取决于你目前使用的电脑)，同时增加 “倒计时” 功能， 每个题目必须在 20 秒钟完成，如果完不成，则得0 分并进入下一题。增加“历史纪录” 功能， 把用户做题的成绩记录下来并可以展现历史记录。
• 把程序变成一个智能手机程序 （你正在用什么手机， 就写那个手机的程序）， 增加倒计时，和历史纪录功能（见上）。
• 把程序变成一个网页程序， 用户通过设定参数，就可以得到各种题目。
• 选一个你从来没有学过的编程语言，试一试实现基本功能。 估计做好这个软件需要的时间，并且写出大概的设计步骤和实现算法。
• 把这个程序的思路变成一个可以一步一步演示的动画。写一个带有图形界面的程序：

  输入：一个正常的四则运算句子
  输出：程序用动画表示计算的过程，后序转换的过程，处理不同运算符优先级的过程， 根据调度场工作的原理，逐步算出得出结果的过程。

实验过程（三阶段）

第1阶段

1.数据结构

核心的数据结构是四则运算二叉树，叶节点为数字，非叶节点为运算符。节点结构如下：

    int type=0;//type==0,整数   type==1,分数  type==2,运算符
    int fenzi=0;
    //type==0,整数的值=分子的值
    //type==1，分数的值=分子的值/分母的值
    int fenmu=0;
    //只有type==1时该值有意义
    int op=0;
    //type==2，op==0：+  op==1：-    op==2：*   op==3：/
    //只有type=2时该值有意义
    struct node* leftchild;
    struct node* rightchild;
}NODE;

使用该数据结构随机生成二叉树，将二叉树的根节点存入数组，实现存储所有算式的功能，以便于之后的打印、计算等功能的实现。

2.随机生成算式

为便于调试和验证，生成算式的数量通过scanf()函数输入。由main函数将生成算式的数量传入gentree()函数中，生成指定数目的二叉树并将根节点存入数组中。

void gentree(int total)
{
    for(int i=0;i<total;i++)
    {
        //srand((unsigned) time());
        int opnum=rand();
        int len=opnum+1;
        //NODE root=(NODE*)malloc(sizeof(NODE));
        int depth=rand()%3+2;
        int type;
        if(rand()%2==0)
            type=0;
        else
            type=1;
        NODE* root=gen(depth,type);
        NODE* root_copy=copy_tree(root);

        if(checkIfDuplicated(root,i-1)==1)//如果发现重复了，这里改了
        {
            i--;
            continue;
        }
        else
        {
            calcu(root);
            if(root->type==-1)
            {
                i--;
                continue;
            }
            else
            {

                roots[i] = root;
                cop[i] = root_copy;
            }
        }

    }
}

gentree()函数调用gen()函数，递归生成一棵完整的二叉树。

NODE* gen(int depth,int type)
//op=1是字符，type=0是整数，type=1是分数
{

    NODE* tmp=(NODE*)malloc(sizeof(NODE));
    if(depth<=0)//叶节点
    {
        tmp->leftchild=NULL;
        tmp->rightchild=NULL;
        if(type==0)//整数
        {
            tmp->type=0;
            tmp->fenzi=rand()%99+1;
        }
        else if(type==1)//分数
        {
            tmp->type=1;
            tmp->fenmu=rand()%18+2;
            tmp->fenzi=rand()%tmp->fenmu;
        }
    }
    else
    {
        tmp->type=2;//符号
        tmp->op=rand()%4;
        if(rand()%2==0)
            tmp->leftchild=gen(0,type);
        else
            tmp->leftchild=gen(depth-1,type);
        if(rand()%2==0)
            tmp->rightchild=gen(0,type);
        else
            tmp->rightchild=gen(depth-1,type);
    }
    return tmp;
}

3.判断重复

生成算式的二叉树后，需要先与之前生成的算式进行判重操作，若重复则需要放弃该算式，不存入数组，重新生成下一条算式

该部分由队友完成

4.计算与判断有效性（除零操作）

四则运算不能有除零操作，不只是不能在除号后跟0，如5/0，也不能在除号后有结果为零的子算式，如5/(4-4)。后一种在生成时无法判断，需要在计算过程中才能发现。因此，我们在将算式存入数组、写入文件之前先进行运算，若发现除零操作，则放弃该算式重新生成，若无除零操作，则存储结果。

calcu()函数通过后序遍历的方式递归调用自身，进行计算并判断是否有除零操作。

void calcu(NODE *nd)
{
    if(nd->leftchild->type==2)
    {
        calcu(nd->leftchild);
    }
    if(nd->rightchild->type