结对项目-ExamGeneration-四则运算试题生成与计算程序

最新推荐文章于 2024-11-13 21:40:45 发布
最新推荐文章于 2024-11-13 21:40:45 发布
阅读量184 收藏
点赞数
文章标签： 数据结构与算法 移动开发 内存管理
原文链接：http://www.cnblogs.com/HelloGaveu/p/9726847.html
版权

目录

ExamGeneration

Github地址
博客地址
-Gaveu博客主页地址
Chernobyl博客主页地址
由@Chernobyl与@-Gaveu合力完成的四则运算题目与答案生成程序，难度可控，刷题体验良好。

妈妈再也不用担心我的学习

进展

实现了题目生成、计算、查重、问题与答案本地文件存储、对错判断的功能。目前进行收尾。

  • 修复了漏显第一题的bug

  • 修复了-n -r单独使用时报错的bug，添加了部分默认规则。-n 下默认生成数值10以内的题目,-r默认生成10道题目

  • 修复了opt_handler.h中的逻辑错误

  • 新增无控制台输出头文件opt_handler_simplify.h，用于测试纯后台运算速度

  • 改进了题目字符串化的算法

  • 添加了查重模块，对应文件StrRepeatCheck.h、StrRepeatCheck.cpp

功能

ExamGeneration.exe -n 20 //生成20道数值为10以内的题目，题目与答案存放在程序同目录下的Exercises.txt文件与Answers.txt文件中

ExamGeneration.exe -r 50 //生成10道数值为50以内的题目，题目与答案存放在程序同目录下的Exercises.txt文件与Answers.txt文件中

ExamGeneration.exe -n 10 -r 50 //生成10道数值为50以内的题目，题目与答案存放在程序同目录下的Exercises.txt文件与Answers.txt文件中

ExamGeneration.exe -e Exercises.txt -a Answers.txt //根据Exercises.txt中的题目，验证Answers.txt中的答案，分别列出正确与错误的题目数目和标号

调用示例

  • 生成10道运算数值最大值为20的题目及计算其答案，并分别存放在程序同目录下的Exercises.txt文件与Answers.txt文件中：
.\ExamGeneration.exe -n 10 -r 20

​ 运行结果：

1.  ( 2`9/10 * 8`4/6 ) - 6`1/8 = 19'1/120
2.  5`1/4 + ( 8/9 / 4`1/2 ) = 5'145/324
3.  7`1/3 * ( 7 + 7 ) = 102'2/3
4.  2/9 + ( 6 / 3 ) = 2'2/9
5.  5 * 4`6/8 - 9 = 14'3/4
6.  9`1/5 + ( 1`8/10 / 9 ) = 9'2/5
7.  ( 2`2/7 * 6`1/3 ) * 1`7/9 = 25'139/189
8.  2 + ( 7`5/7 - 7`1/5 ) = 2'18/35
9.  8 / ( 3`3/9 / 7 ) = 16'4/5
10.  1 * ( 2 + 3 ) = 5
Press any key to continue . . .
  • 验证本地的Exercises.txt题目与Answers.txt中的答案：
ExamGeneration.exe -e .\Exercises.txt -a .\Answers.txt

​ 运行结果：

Correct: 10 ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 )
Error: 0 ( )

PSP表格

Chernobyl：

PSP2.1Personal Software Process Stages预估耗时（分钟）实际耗时（分钟）
Planning计划1030
· Estimate· 估计这个任务需要多少时间1030
Development开发410450
· Analysis· 需求分析 (包括学习新技术)3020
· Design Spec· 生成设计文档3050
· Design Review· 设计复审 (和同事审核设计文档)3030
· Coding Standard· 代码规范 (为目前的开发制定合适的规范)00
· Design· 具体设计6080
· Coding· 具体编码130
· Code Review· 代码复审3030
· Test· 测试（自我测试，修改代码，提交修改）6060
Reporting报告6070
· Test Report· 测试报告3030
· Size Measurement· 计算工作量4010
· Postmortem & Process Improvement Plan· 事后总结, 并提出过程改进计划2030
合计480560

-Gaveu：

PSP2.1Personal Software Process Stages预估耗时（分钟）实际耗时（分钟）
Planning计划3030
· Estimate· 估计这个任务需要多少时间600540
Development开发350240
· Analysis· 需求分析 (包括学习新技术)2010
· Design Spec· 生成设计文档3050
· Design Review· 设计复审 (和同事审核设计文档)3020
· Coding Standard· 代码规范 (为目前的开发制定合适的规范)010
· Design· 具体设计6080
· Coding· 具体编码200160
· Code Review· 代码复审3060
· Test· 测试（自我测试，修改代码，提交修改）3040
Reporting报告6020
· Test Report· 测试报告3020
· Size Measurement· 计算工作量1010
· Postmortem & Process Improvement Plan· 事后总结, 并提出过程改进计划2030
合计900780

结对分工

成员模块对应文件
Chernobyl（设计、开发、测试）计算模块node.h
命令行参数处理与执行模块opt_handler.h、main.cpp
-Gaveu（开发、测试、文档）题目生成模块ExamGen.h、ExamGen.cpp
计算结果字串查重模块StrRepeatCheck.h、StrRepeatCheck.cpp

功能模块详解

Chernobyl：

流程

CalculateModulePic01.jpg

计算模块

计算模块使用了算式生成树的实现方法，通过递归的方式进行深度优先的遍历实现优先级的分配和计算。每个数值/符号用一个结构体进行存储，结构体定义如下

struct Node
{
    bool is_sign;//是否为符号节点
    bool re_granted;//是否重新生成算式  
    unsigned int sign_pri;//符号权重
    char sign;//符号
    unsigned int up_num;//分子值
    unsigned int button_num;//分母值
    struct Node* left;//左子节点
    struct Node* right;//右子节点
};

在生成算式树时，相同的节点能够简化实现。

计算类声明如下

class caculator
{
public:
    vector<struct Node*> tmp_res;//存储临时构建的节点
    struct Node* result;//存储生成树的根节点
    string equation;//输入的等式
    string final_result;//存储最终结果
    void output_equation();//输出函数
    unsigned int tonum(const string& in);//字符串转为数字
    vector<struct Node*>::size_type find_last(const vector<struct Node*>& items, unsigned int begin, unsigned int end);//寻找临时符号节点中权重最小的节点，返回位置
    struct Node* createTree(const vector<struct Node*>& items, unsigned int begin, unsigned int end);//创建算式生成树
    vector<string> split(string str, const string& find_pattern=" ");//分割字符串
    vector<struct Node*> analyzed();//算式分析，返回临时节点数组
    struct Node* createNode(const string& in_str, const unsigned int pri);//创建节点
    struct Node* caculate_process(struct Node* left, struct Node* right, char sign);//先序遍历计算函数
    void caculate(struct Node* head);//计算具体实现
    void destory_tree(struct Node* p);//销毁生成树
    unsigned int measure(unsigned int x, unsigned int y);//计算最大公因数
    void start_process(string equation);//启动计算过程
};

用STL代替传统的数组，在简化代码的同时也能利用内置实现进行计算大量题目时的内存管理分配。

重点函数实现说明

算式字符串处理

使用自实现的分割函数vector<string> split(string str, const string& find_pattern=" ")以空格为分隔符进行字符串分割。

vector<string> caculator::split(string str, const string& find_pattern)
{
    /*
    字符串分割函数
    传入参数：待分割字符串，分隔符（默认为空格）
    返回值：分割后字符串序列
    */
    string::size_type pos;
    vector<string> result;
    str += find_pattern;//扩展字符串以方便操作，防止末尾无法匹配
    string::size_type size = str.size();

    for (int i = 0; i < size; i++)
    {
        pos = str.find(find_pattern, i);
        if (pos < size)
        {
            std::string s = str.substr(i, pos - i);//通过内置的substr()实现分割
            result.push_back(s);
            i = pos + find_pattern.size() - 1;
        }
    }
    return result;
}

针对每个子字串进行分析，分为三种类型：数值、分数和符号首先对符号和数值进行区分，对符号优先级进行判别

vector<struct Node*>  caculator::analyzed()
{
    /*
    算式分析函数
    传入参数：无
    返回值：包含算式所有运算符/数字构成节点的序列
    */
    vector<string> tmp = split(this->equation);//将传入的字符串进行分割，分隔符为空格
    vector<struct Node*> rtn;
    unsigned int pri = 5;//运算符的基础权重，越靠后权重越小，越靠近于生成树的根。该实现仅支持不多于五个加减乘除符号的四则运算，后续扩展可增大该权重的值
    for (string x : tmp)
    {
        if (x._Equal("=")||x._Equal(" ")||x.size() == 0)
            continue;
        if (x._Equal("("))//遇到左括号提高优先级
        {
            pri += 20;
            continue;
        }
        else if (x._Equal(")"))//遇到右括号降低优先级
        {
            pri -= 20;
            continue;
        }

        if (x._Equal("*") || x._Equal("/"))//乘/除优先级高于加/减
        {
            pri += 10;
            rtn.push_back(createNode(x, pri));
            pri -= 11;
        }

        else if (x._Equal("+") || x._Equal("-"))
        {
            rtn.push_back(createNode(x, pri));
            pri -= 1;
        }

        else
            rtn.push_back(createNode(x,0));
    }
    return rtn;
}

生成结点时，根据结点的类型分为数值和符号结点，数值结点统一化成分数形式以便实现分数功能和计算

struct Node* caculator::createNode(const string& in_str, const unsigned int pri=0)
{
    /*
    节点创建函数
    传入参数：符号/数字字符串，节点权重
    返回值：根据传入参数生成的节点
    */
    struct Node* tmp = new Node;
    tmp->left = NULL;
    tmp->right = NULL;
    tmp->re_granted = false;
    if (in_str._Equal("*") || in_str._Equal("/") || in_str._Equal("+") || in_str._Equal("-"))//创建符号节点
    {
        tmp->is_sign = true;
        tmp->sign_pri = pri;
        tmp->sign = in_str[0];
        tmp->button_num = 0;
        tmp->up_num = 0;
        return tmp;
    }
    string::size_type pos = in_str.find('/');
    if (pos != string::npos)//分式
    {
        string::size_type dot_pos = in_str.find('`');
        if (dot_pos != string::npos)//假分式
        {
            string up_num_1 = in_str.substr(0, dot_pos);
            string up_num_2 = in_str.substr(dot_pos+1, pos-dot_pos-1);
            string down_num = in_str.substr(pos + 1);
            tmp->button_num = tonum(down_num);
            tmp->up_num = tonum(up_num_1)*tmp->button_num + tonum(up_num_2);
        }
        else
        {
            string up_num = in_str.substr(0, pos);
            string down_num = in_str.substr(pos + 1);
            tmp->up_num = tonum(up_num);
            tmp->button_num = tonum(down_num);
        }
        tmp->is_sign = false;
        tmp->sign = '\0';
        return tmp;
    }
    else//数字
    {
        tmp->up_num = tonum(in_str);
        tmp->button_num = 1;
        tmp->is_sign = false;
        tmp->sign = '\0';
    }
    return tmp;
}
计算过程

对容器内结点进行迭代，根据结点的权重生成计算树。首先取出结点容器总权重最小的作为树的根节点

vector<struct Node*>::size_type caculator::find_last(const vector<struct Node*>& items, unsigned int begin, unsigned int end)
{
    /*
    寻找节点序列中权重最小符号的位置
    传入参数：节点序列
    返回值：权重最小符号节点的位置
    */;
    vector<struct Node*>::size_type rtn_pos = 0;
    vector<struct Node*>::size_type pos = begin;
    unsigned int pri = 999;
    for (;pos!=end;pos++)
    {
        if (!items[pos]->is_sign)
            continue;
        if (items[pos]->sign_pri < pri)
        {
            pri = items[pos]->sign_pri;
            rtn_pos = pos;
        }
    }
    return rtn_pos;
}

使用递归的方式构建子树，注意三种情况：左临界，右临界和两边空余

struct Node* caculator::createTree(const vector<struct Node*>& items,unsigned int begin, unsigned int end)
{
    /*
    创建算式的计算树
    传入参数：节点序列
    返回值：树根节点
    */
    if (end - begin == 3)//递归终点，直接构建子树
    {
        items[begin+1]->left = items[begin];
        items[begin+1]->right = items[begin+2];
        return items[begin+1];
    }

    vector<struct Node*>::size_type pos = find_last(items,begin,end);

    if (pos == begin + 1)//符号位于开头，左临界状态。左子树为数字，右子树进行递归生成
    {
        items[pos]->left = items[begin];
        items[pos]->right = createTree(items,pos + 1,end);
        return items[pos];
    }

    if (pos == end - 2)//符号位于末尾，右临界状态。右子树为数字，左子树进行递归生成
    {
        items[pos]->right = items[pos + 1];
        items[pos]->left = createTree(items, begin, begin + pos);
        return items[pos];
    }

    else//运算符处于中间，左右都有高优先运算符。对左右子树进行递归生成
    {
        items[pos]->left = createTree(items, begin, begin + pos);
        items[pos]->right = createTree(items, begin + pos + 1, end);
        return items[pos];
    }
}

计算时，对算式生成树进行深度优先遍历以实现运算符优先级

void caculator :: caculate(struct Node* head)
{
    /*
    使用深度优先先序遍历计算等式
    传入参数：树根节点
    返回值:无，但是会修改树根节点的类型
    */
    if (head->left->is_sign)
        caculate(head->left);
    if (head->right->is_sign)
        caculate(head->right);
    Node* tmp = caculate_process(head->left, head->right, head->sign);
    if (tmp == NULL)
    {
        cout << "Caculate Failed!";
        return;
    }
    head->up_num = tmp->up_num;
    head->button_num = tmp->button_num;
    head->is_sign = false;
    head->sign = '\0';
    head->re_granted = tmp->re_granted;
    delete tmp;
    return;
}

递归的重点为左右子树均不为符号结点，组成为数值+符号+数值。计算后需要修改符号结点类型为数值结点，同时修改符号结点的数值

struct Node* caculator :: caculate_process(struct Node* left, struct Node* right, char sign)
{
    /*
    处理叶子节点的计算
    传入参数：左子节点，右子节点，计算符号
    返回值：包含计算结果的数值节点
    */
    if (left->is_sign || right->is_sign)//若该节点的子节点非数字，则报错
    {
        cout << "Node Error!" << endl;
        return NULL;
    }

    //初始化操作
    struct Node* tmp_struct = new Node;
    unsigned int tmp_result_up = 0;
    unsigned int tmp_result_button = 0;
    unsigned int tmp_left_up = left->up_num;
    unsigned int tmp_left_button = left->button_num;
    unsigned int tmp_right_up = right->up_num;
    unsigned int tmp_right_button = right->button_num;
    unsigned int tmp = 0;
    tmp_struct->is_sign = false;
    tmp_struct->left = NULL;
    tmp_struct->right = NULL;
    tmp_struct->re_granted = false;
    if (left->re_granted || right->re_granted)
        tmp_struct->re_granted = true;

    //通分
    tmp_left_up *= tmp_right_button;
    tmp_right_up *= tmp_left_button;
    tmp = tmp_left_button;
    tmp_left_button *= tmp_right_button;
    tmp_right_button *= tmp;

    //计算
    switch (sign)
    {
    case '+':
        tmp_result_up = tmp_left_up + tmp_right_up;
        tmp_result_button = tmp_left_button;
        break;

    case '-':
        if (tmp_left_up < tmp_right_up)
            tmp_struct->re_granted = true;
        tmp_result_up = tmp_left_up - tmp_right_up;
        tmp_result_button = tmp_left_button;
        break;

    case '*':
        tmp_result_up = left->up_num * right->up_num;
        tmp_result_button = left->button_num * right->button_num;
        break;

    case '/':
        tmp_result_up = left->up_num * right->button_num;
        tmp_result_button = left->button_num * right->up_num;
        break;
    }

    //赋值并返回
    tmp_struct->up_num = tmp_result_up;
    tmp_struct->button_num = tmp_result_button;
    return tmp_struct;
}
结果处理

计算完成后，树根结点存储了计算的结果，同时包含了错误信息。后续结果输出时直接对该结点进行信息读取和处理即可

    unsigned int up = this->result->up_num;
    unsigned int down = this->result->button_num;
    if (down == 0)//分母为0，重新生成算式
        this->result->re_granted = true;
    else if (up % down)//分子除以分母无法除尽，进行转换
    {
        unsigned int div = this->measure(down, up%down);//求最大公因数
        if (up > down)//转化为假分数
            this->final_result = to_string(up / down) + "'" + to_string((up%down)/div) + "/" + to_string(down/div);
        else//真分数
            this->final_result = to_string(up/div) + "/" + to_string(down/div);
    }
    else//整数
        this->final_result = to_string(up / down);
命令行参数处理与执行模块
参数处理

将程序执行的main函数声明为main(int argc, char** argv)后，可以获取到命令行的参数信息。随后，将信息传入到命令行参数处理类。处理类opt_handler声明如下

class opt_handler
{
public:
    int argc=0;
    char** argv=0;
    unsigned int problem_num=10;//生成题目个数
    unsigned int problem_size=10;//生成题目最大数值
    string exercisefile = "./Exercises.txt";//输出的练习文件
    string answerfile = "./Answers.txt";//读取的答案文件
    opt_handler(int argc, char** argv);
    void help();
    unsigned int to_num(char* in);//将字符转换为数字
    void opt_handler_process();//参数处理与执行
    void generate_problems();//生成题目
    void compare();//答案比对
};

参数处理函数如下，根据传入的不同参数执行不同的行为

void opt_handler::opt_handler_process()
{
    if (this->argc == 1)
    {
        help();
        return;
    }
    bool is_judge = false;
    bool is_generate = false;
    for (int pos = 0; pos < this->argc; pos++)
    {
        if (!strncmp(this->argv[pos], "-h", 2))
        {
            help();
            return;
        }
        if (!strncmp(this->argv[pos], "-n", 2))//生成题目个数
        {
            if (this->argc-1 > pos &&  isdigit(this->argv[pos + 1][0]))
                this->problem_num = this->to_num(this->argv[pos + 1]);
            else
                this->problem_num = 10;
            is_generate = true;
            continue;
        }
        else if (!strncmp(this->argv[pos], "-r", 2))//题目数值范围
        {
            if (this->argc-1 > pos && isdigit(this->argv[pos + 1][0]))
                this->problem_size = this->to_num(this->argv[pos + 1]);
            else
                this->problem_size = 10;
            is_generate = true;
            continue;
        }
        else if (!strncmp(this->argv[pos], "-e", 2))//题目文本文件
        {
            this->exercisefile = this->argv[pos + 1];
            continue;
        }
        else if (!strncmp(this->argv[pos], "-a", 2))//题目答案文件
        {
            this->answerfile = this->argv[pos + 1];
            is_judge = true;
            continue;
        }
    }
    if (is_generate)
        this->generate_problems();
    if (is_judge)
        this->compare();
    else if (!is_generate && !is_judge)
        help();
}

喜闻乐见的帮助页面

void opt_handler::help()
{
    cout << "小学生暑假杀手  充实暑假时光" << endl;
    cout << "使用方法：" << endl;
    cout << " -n: 控制生成题目的个数" << endl;
    cout << " -r: 控制题目中数值" << endl;
    cout << " -e: 题目文件" << endl;
    cout << " -a: 答案文件"<<endl;
    return;
}
题目生成

题目生成过程需要进行两个操作：题目生成与计算。生成后需要通过计算判断算式有无异常，如无异常，则将题目与算式输出至不同的文件

void opt_handler::generate_problems()
{
    clExamGen *p = new clExamGen();
    caculator* q = new caculator();
    ofstream Answer_File;
    ofstream Exercise_File;
    Answer_File.open(this->answerfile,ios::out| ios::trunc);//创建答案文件
    Exercise_File.open(this->exercisefile, ios::out | ios::trunc);//创建题目文件
    if (!Answer_File.is_open() || !Exercise_File.is_open())
    {
        cout << "文件创建失败";
        return;
    }
    string sCout;
    string sCal;
    int lv = lv_UserDefine;
    for (unsigned int x = 1; x < this->problem_num+1; x++)//题目生成
    {
        p->CreateExamToString1(lv_UserDefine, sCout, sCal, this->problem_size, this->problem_size, this->problem_size, 3, 1);
        q->start_process(sCal);
        if (q->result->re_granted)
        {
            x--;
            continue;
        }
        cout << to_string(x)<< ". "<<sCout << " = " << q->final_result << endl;
        Exercise_File << to_string(x)<<". "<<sCout << " = " << endl;
        Answer_File<< to_string(x) << ". " << q->final_result << endl;
    }
    cout << "generate " << this->problem_num << " problems"<<endl;
    delete p, q;
    return;
}
答案判断

答案判断首先需要同步读取答案和题目文件，然后将题目字符串放入计算模块得出结果，并将结果与答案进行比对

void opt_handler::compare()
{
    vector<unsigned int>correct, error;
    caculator* q = new caculator();
    ifstream AnswerFile;
    ifstream ExerciseFile;
    AnswerFile.open(this->answerfile);//打开答案文件
    ExerciseFile.open(this->exercisefile);//打开题目文件
    if (!AnswerFile.is_open() || !ExerciseFile.is_open())
    {
        cout << "文件不存在";
        return;
    }
    string ans, exe;
    unsigned int current_problem_num = 0;
    while (!AnswerFile.eof() && !ExerciseFile.eof())//读取文件内容
    {

        current_problem_num++;
        getline(AnswerFile, ans);
        getline(ExerciseFile, exe);
        unsigned int pos = ans.find('.');
        if (pos != string::npos)
            ans = ans.substr(pos + 2);
        else
            break;
        pos = exe.find('.');
        exe = exe.substr(pos + 1);
        q->start_process(exe);
        ans._Equal(q->final_result) ? correct.push_back(current_problem_num) : error.push_back(current_problem_num);//结果判定
    }
    
    cout << "Correct: "<<correct.size()<<" (";
    for (unsigned int x = 0; x < correct.size(); x++)
    {
        if (x == 0)
            cout << " " << correct[x];
        else
            cout << ", " << correct[x];
    }
    cout << " )"<<endl;

    cout << "Error: " << error.size() << " (;
    for (unsigned int x = 0; x < error.size(); x++)
    {
        if (x == 0)
            cout << " " << error[x];
        else
            cout << ", " << error[x];
    };
    cout << " )" << endl;
    delete q;
    return;
}

-Gaveu：

题目生成模块
主数据结构
  • 运行状态枚举值定义：
typedef enum 
{ 
    en_success = 0, 
    en_fail, 
    en_true, 
    en_false, 
    en_nullptr 
}Status;    //Status状态变量定义，用于表明运行状态，常作为函数返回值。
  • 以二叉树为基础的随机题目生成树。
typedef struct GenNode
{
    bool isElem;            //标识当前二叉树节点是否为运算数值，若为表达式则值为false
    bool isExpressionHead;  //标识当前二叉树节点是否为运算表达式的第一个元素
                            //是的话该值为true，nodeSymbol不能为sym_multiply或sym_divide
                            //否则值为false，nodeSymbol取值不限。
    
    bool isFraction;        //标识当前运算数值是否为真分数，是则为true，否则为false

    Symbol nodeSymbol;      //表示当前二叉树节点的运算符号类型
    ValueType value;        //表示当前二叉树节点的运算值，若为表达式，则值为0
    ValueType molecular;    //表示当前二叉树节点的真分数分子
    ValueType denominator;  //表示当前二叉树节点的真分数分母

    GenNode *nextElem;      //指向下一个运算数值节点的指针，若为NULL则说明已至当前表达式的末尾
    GenNode *expressionHead;//指向下一个运算表达式节点的指针，若为NULL则说明当前节点为数值节点
}GenNode, *pGenNode;

示例图：

picture01

  • 题目随机生成类clExamGen定义：
class clExamGen
{
public:
    bool ifFraction;                        //存储当前题目生成是否包括真分数
    unsigned int maxNumOfElem;              //存储一个表达式中运算值及子表达式的最大个数
    unsigned int numOfExpression;           //存储一个题目中表达式嵌套的个数
    Level lvMode;                           //存储题目难度
    string strExam;                         //存储由二叉树整理出来的题目字符串
    pGenNode genNodeRoot;                   //题目二叉树头节点
    ValueType maxiumOfValue;                //生成数值的最大值
    ValueType maxiumOfDenominator;          //生成分母的最大值
    ValueType maxiumOfMolecular;            //生成分子的最大值

    char SymbolToChar(Symbol IN_symbol);    //根据传入的IN_symbol输出对应符号的ASCII
    Status GetRandom(ValueType &Data, ValueType IN_Minima, ValueType IN_Maxima);    //获取[Minima,Maxima)的随机数,将该数传给Data
    Status GetRandom1(ValueType &Data, ValueType IN_Minima, ValueType IN_Maxima);   //获取[Minima,Maxima]的随机数,将该数传给Data
    Status SetLevel(Level IN_level);        //根据传入的IN_level设置类内参数lvMode、maxNumOfElem、numOfExpression、maxiumOfValue
    Status GetNode(pGenNode &pNode);        //动态申请GenNode大小的内存，成功则将该内存地址返回给pNode并返回en_success;否则输出错误信息并返回en_fail
    Status SetNode(
        pGenNode    pNode,                  //被写值节点的节点指针
        bool        IN_isElem,              //待写入的运算数值标识
        bool        IN_isExpressionHead,    //待写入的表达式头节点标识
        Symbol      IN_nodeSymbol,          //待写入的运算符号枚举变量
        ValueType   IN_value,               //代写入的运算数值
        pGenNode    IN_nextElem,            //当前表达式中代写入的下一个数值节点指针
        pGenNode    IN_expressionHead       //当前表达式中代写入的下一个子表达式节点指针
    );      //设置pNode指向的结构体的值,函数成功则返回en_success;pNode值为空则输出错误信息，返回en_nullptr
    Status SetNode(
        pGenNode    pNode,                  //被写值节点的节点指针
        bool        IN_isElem,              //待写入的运算数值标识
        bool        IN_isExpressionHead,    //待写入的表达式头节点标识
        bool        IN_isFraction,          //待写入的表达式运算数值真分数标识
        Symbol      IN_nodeSymbol,          //待写入的运算符号枚举变量
        ValueType   IN_value,               //代写入的运算数值
        ValueType   IN_molecular,           //代写入的真分数分子
        ValueType   IN_denominator,         //代写入的真分数分母
        pGenNode    IN_nextElem,            //当前表达式中代写入的下一个数值节点指针
        pGenNode    IN_expressionHead       //当前表达式中代写入的下一个子表达式节点指针
    );      //(真分数)设置pNode指向的结构体的值,函数成功则返回en_success;pNode值为空则输出错误信息，返回en_nullptr

    Status CreateBiTree(pGenNode &pFather, int times);  //以pFather为头节点，递归生成试题二叉树，传参times为递归次数
    Status DeleteBiTree(pGenNode &pFather); //递归释放二叉树节点空间
    //Status CreateExamToString(Level IN_lvmode, string &Out_dst);  //根据传入的试题难度自动生成试题，并将试题字符串化，复制到Out_dst的string引用对象中
    Status CreateExamToString(
        Level IN_lvmode,                        //传入的题目生成难度，仅接受自定义难度，其他难度则报错并返回en_fail
        string &Out_dst,                        //输出的string类引用，当函数成功生成一道题目时会将其字符串化并输出至该引用对应的对象              
        ValueType IN_maxiumOfValue,             //待生成题目的数值最大值，题目生成参数，若为50,则运算数值范围为[1,50)
        ValueType IN_maxiumOfMolecular,         //待生成题目的真分数分子最大值
        ValueType IN_maxiumOfDenominator,       //待生成题目的真分数分母最大值
        unsigned int IN_numOfElem,              //待生成题目中一个表达式中运算值及子表达式的最大个数
        unsigned int IN_numOfExpression         //待生成题目中的括号嵌套层数
    );  //(用户自定义难度)根据传入的试题参数自动生成试题，并将试题字符串化，复制到Out_dst的string引用对象中,返回值为Status状态枚举值
    Status CreateExamToString1(
        Level IN_lvmode,                        //传入的题目生成难度，仅接受自定义难度，其他难度则报错并返回en_fail
        string &Out_dstCout,                    //(无分数转换)输出的string类引用，当函数成功生成一道题目时会将其字符串化并输出至该引用对应的对象       
        string &Out_dstCal,                     //(有分数转换)输出的string类引用，当函数成功生成一道题目时会将其字符串化并输出至该引用对应的对象   
        ValueType IN_maxiumOfValue,             //待生成题目的数值最大值，题目生成参数，若为50,则运算数值范围为[1,50)
        ValueType IN_maxiumOfMolecular,         //待生成题目的真分数分子最大值
        ValueType IN_maxiumOfDenominator,       //待生成题目的真分数分母最大值
        unsigned int IN_numOfElem,              //待生成题目中一个表达式中运算值及子表达式的最大个数
        unsigned int IN_numOfExpression         //待生成题目中的括号嵌套层数
    );  //(用户自定义难度)(真分数转换)根据传入的试题参数自动生成试题，并将试题字符串化，复制到Out_dst的string引用对象中,返回值为Status状态枚举值
    Status DeleteOneElemExpression(pGenNode pLast, pGenNode pNode); //对于仅含有一个元素的表达式时，进行表达式节点删除操作，类似单链表的中间节点删除

    void BiTreeInfoIntoString(pGenNode pFather, string &dst);   //将试题的信息输入至dst对应字符串中
    void BiTreeInfoIntoString1(pGenNode pFather, string &dstCal, string &dstCout);  //将试题的信息输入至dstCal(真分数转换)、dstCout(无真分数转换)对应字符串中
    void ShowTree(pGenNode pFather);        //递归输出试题树的信息

};
题目生成算法

深度优先，随机生成运算符号与数值，流程可见流程图：

picture02

具体实现代码：

Status clExamGen::CreateBiTree(pGenNode &pFather, int times)    //以pFather为表达式节点，递归生成子试题二叉树，传参times为递归计数
{
    if (times < 0)  //传参判断，times<0为异常，返回错误枚举值
    {
        cout << "CreatBiTree:times < 0 ,recursion failed!" << endl;
        return en_fail;
    }
    else if (!pFather)  //传参判断，pFather为空指针时判断为异常，返回错误枚举值
    {
        cout << "CreatBiTree:pFather is a nullptr,function failed" << endl;
        return en_nullptr;
    }

    pGenNode pNode;                             //存储当前操作的节点地址
    pGenNode pLast;                             //存储上一个操作的节点地址
    bool nodeIsElem;                            //存储当前节点的随机元素标识
    bool nodeIsFraction;                        //存储当前节点的随机真分数标识
    Symbol nodeSymbol;                          //存储当前节点的随机符号枚举变量
    ValueType nodeValue;                        //存储当前节点的随机运算数值
    ValueType nodeMolecular;                    //存储当前节点的真分数分子
    ValueType nodeDenominator;                  //存储当前节点的真分数分母
    //unsigned int numOfElem = maxNumOfElem;        //存储当前表达式链表中的节点数
    int explimit = 2;

    pNode = NULL;
    pLast = NULL;

    while (maxNumOfElem != 0 && explimit)
    {
        //动态申请当前节点内存空间
        if (en_success != GetNode(pNode))
        {
            cout << "CreateBiTree:GetNode failed!" << endl;
            return en_fail;
        }

        //节点类型决定环节，若已递归至最底层(times == 0)则表达式内所有节点均为数值节点，否则将随机决定当前节点为运算数值节点还是子表达式节点
        if (0 == times)
        {
            nodeIsElem = true;
            explimit--;
        }
        else
        {
            //随机决定当前节点为运算数值节点还是子表达式节点
            nodeIsElem = rand() % 2;
        }

        //当前节点的赋值操作
        if (nodeIsElem == false)    //当前节点为子表达式节点时，运算符号不限
        {
            nodeSymbol = (Symbol)(rand() % 4);      //随机生成 +、-、*、/运算符号
            SetNode(pNode,
                false,
                false,
                false,
                nodeSymbol,
                0,
                0,
                0,
                pLast,
                NULL);
            if (en_success != CreateBiTree(pNode, times - 1))   //以pNode为头节点，递归生成试题二叉树，传参times-1为递归次数
            {
                cout << "CreateBiTree: Create son tree failed!" << endl;
                return en_fail;
            }
        }
        else                    //当前节点为运算数值节点时，运算符号不限
        {
            nodeIsFraction = rand() % 2;
            if (nodeIsFraction == true && ifFraction == true)       //真分数节点生成
            {
                GetRandom(nodeValue, 0, maxiumOfValue); //真分数则真数值范围为[0,maxiumOfValue)
                GetRandom1(nodeDenominator, 2, maxiumOfDenominator);    //真分数分母取值为[2,maxiumOfMolecular]

                //真分数分子取值为[1,nodeDenominator-1或maxiumOfMolecular的最小者]
                GetRandom1(nodeMolecular, 1, nodeDenominator > maxiumOfMolecular ? maxiumOfMolecular : nodeDenominator - 1);

                nodeSymbol = (Symbol)(rand() % 4);      //随机生成 +、-、*、/运算符号
                SetNode(pNode,
                    true,
                    false,
                    true,
                    nodeSymbol,
                    nodeValue,
                    nodeMolecular,
                    nodeDenominator,
                    pLast,
                    NULL);

            }
            else //真值节点生成
            {
                GetRandom(nodeValue, 1, maxiumOfValue); //数值范围为[1,maxiumOfValue)
                nodeSymbol = (Symbol)(rand() % 4);      //随机生成 +、-、*、/运算符号
                SetNode(pNode,
                    true,
                    false,
                    false,
                    nodeSymbol,
                    nodeValue,
                    0,
                    0,
                    pLast,
                    NULL);
            }
        }

        pLast = pNode;
        if (0 == maxNumOfElem || 0 == explimit)
        {
            break;
        }
        else
        {
            maxNumOfElem--;
        }
    }
    pFather->expressionHead = pNode;    //将pFather对应节点的子表达式指针指向pNode，至此pFather的子试题树生成完毕
    pFather->expressionHead->nodeSymbol = sym_plus; //将子表达式中头节点符号置为加号
    pFather->expressionHead->isExpressionHead = true;   //将子表达式中头节点的头节点标识isExpressionHead置为true

    return en_success;
}
题目二叉树字符串化算法

同样的，深度优先的遍历规则，遇头节点则不显示符号，节点为子表达式节点则增加“ ( 表达式 )”，同时递归进入子表达式中；节点为运算数值节点则判断是否为分数，为分数则增加” value`molecular/denominator“(value为0时增加” molecular/denominator“)，为自然数则增加” value“。运算数值（包括分数）、子表达式、运算符号彼此用空格相隔以示独立。

void clExamGen::BiTreeInfoIntoString1(pGenNode pFather, string &dstCal, string &dstCout)    //将试题的信息输入至dstCal(真分数转换)、dstCout(无真分数转换)对应字符串中
{
    if (!pFather)
    {
        return;
    }

    //运算符号显示环节
    if (pFather->isExpressionHead == false) //非表达式的头节点则显示运算符号
    {
        dstCal.insert(dstCal.size(), 1, ' ');
        dstCal.insert(dstCal.size(), 1, SymbolToChar(pFather->nodeSymbol));

        dstCout.insert(dstCout.size(), 1, ' ');
        dstCout.insert(dstCout.size(), 1, SymbolToChar(pFather->nodeSymbol));
    }

    //运算数值或表达式输出环节
    if (pFather->isElem == false)   //节点为表达式节点则显示“ ( 表达式 )”
    {
        dstCal.insert(dstCal.size(), " (");
        dstCout.insert(dstCout.size(), " (");
        BiTreeInfoIntoString1(pFather->expressionHead, dstCal, dstCout);
        dstCal.insert(dstCal.size(), " )");
        dstCout.insert(dstCout.size(), " )");
    }
    else    //节点为数值节点时显示运算数值
    {
        dstCal.insert(dstCal.size(), 1, ' ');
        dstCout.insert(dstCout.size(), 1, ' ');
        if (pFather->isFraction == true)
        {
            dstCal.insert(dstCal.size(), to_string(pFather->molecular + pFather->value * pFather->denominator));
            dstCal.insert(dstCal.size(), 1, '/');
            dstCal.insert(dstCal.size(), to_string(pFather->denominator));

            if (pFather->value != 0)
            {
                dstCout.insert(dstCout.size(), to_string(pFather->value));
                dstCout.insert(dstCout.size(), 1, '`');
            }
            dstCout.insert(dstCout.size(), to_string(pFather->molecular));
            dstCout.insert(dstCout.size(), 1, '/');
            dstCout.insert(dstCout.size(), to_string(pFather->denominator));

        }
        else
        {
            dstCal.insert(dstCal.size(), to_string(pFather->value));
            dstCout.insert(dstCout.size(), to_string(pFather->value));
        }
    }
    BiTreeInfoIntoString1(pFather->nextElem, dstCal, dstCout);
}
计算结果字串查重模块
主数据结构

std::map<string,int>

原理

以计算结果的string字串为索引，以当前生成题目的int型题号作为键值，建立一个映射计算结果与题号的map类。在生成题目后，模块会将该题答案(string字串)传入map中进行检索，若map中不存在该索引则将答案与题号添加入map中；若已存在，则模块的接口函数将返回一个false，让程序重新生成一道题目。

字串查重类的具体代码定义
class clStrRepeatCheck
{
public:
    map<string, int> checkMap;              //存储string-int的字串查重map类
    map<string, int>::iterator mapIt;       //字串查重map类迭代器

    bool StrCheckAndAdd(string &s, int IN_Num);     //检查传入字串是否存在于checkMap中，不存在则将该字串及对应的int型标号插入checkMap中，返回true；
                                                    //如果传入的IN_Num小于等于0或者字串存在则不操作并返回false。
    int isInMap(string &s);     //检查传入字串是否存在于checkMap中，是则返回其对应的int值，不存在则返回0
};
具体方法实现代码
bool clStrRepeatCheck::StrCheckAndAdd(string &s, int IN_Num)        
//检查传入字串是否存在于checkMap中，不存在则将该字串及对应的int型标号IN_Num插入checkMap中，返回true；
//如果传入的IN_Num小于等于0或者字串存在则不操作并返回false。
{
    //传入的IN_Num小于等于0，则返回false
    //若s在checkMap中被查找到对应的int值，则返回false
    if (IN_Num <= 0 || isInMap(s) != 0)
    {
        return false;
    }

    //运行到此处则说明s在checkMap中并无重复，此时以s为索引，将对应的int标号IN_Num作为键值加入checkMap中
    checkMap[s] = IN_Num;
    return true;
}

int clStrRepeatCheck::isInMap(string &s)
//检查传入字串是否存在于checkMap中，是则返回其对应的int值，不存在则返回0
{
    mapIt = checkMap.find(s);
    if (mapIt != checkMap.end())
    {
        return mapIt->second;
    }
    else
    {
        return 0;
    }
}

运行测试

-Gaveu：

  • 分别测试生成10到数值范围为10的题目、生成10到数值范围为20的题目、生成20到数值范围为20的题目：

    TestPic01

此时程序同目录下存有了试题文件Exercises.txt、答案文件Answers.txt，且答案题目均无重复：

TestPic01-1

TestPic02

TestPic03

  • 组合-a -e进行答案验证：

    TestPic04

修改Answer.txt中的第4题和第19题答案为0并保存修改：

TestPic05

再次校验，结果显示第4题和第19题答案错误，符合预期：

TestPic06

  • 10000道运算数值范围为20的题目生成测试：

    TestPic07

    TestPic08

本地Answers.txt与Exercises.txt头与末尾，符合需求:

TestPic09

TestPic10

Chernobyl：

两次生成一百万道、数值范围为一万以内的题目耗时：

  • 第一次耗时17秒73：

    TimeTest01

  • 第二次耗时22秒55：

    TimeTest02

项目总结与反思

Chernobyl

通过计算器项目，了解并实践逆波兰算法和二叉树相关的知识。在结对的过程中学习了代码实现的协商与同步，积累的合作项目的经验。

项目闪光点 ：生成100w题仅需要26秒~

结对闪光点：积极沟通，制定了编程规范，接口对接顺利，实现良好。

-Gaveu

该项目我主要实现的试题的生成与查重模块的设计。之前有过二叉树及其相关算法的练习与实践，所以实现难度不大。耗时多的地方还是在出题的参数的设计与把控上，像括号嵌套层数、数值大小、真分数设计、括号内运算单元数目多少等，文档中还表明不应当有负数运算。可没有负数运算的四则运算还算是四则运算？按照一切遵循需求的原则，将负数判断的环节交给@Chernobyl了，因为这个涉及到计算。

项目存在的可能的优化点：由于运算模块基于二叉树，题目生成的模块也是基于二叉树，如若前期能商讨出一套方案使得运算模块与题目生成模块能共用同一棵二叉树，时间的开销应该会更小。如今要尝试该优化的话需要重构代码，时间与精力成本较大。

总的而言，这次的项目不仅在开发能力上有所锻炼，在团队沟通分工协作方面也有收获良多。

完成项目后心情是自由自在，毕竟是小学生暑假杀手小学生四则运算习题库的代码实现，在充实暑假时光的同时也能提升计算能力，是一个十分有意义的项目，还能减少假期游戏的小学生队友数目，让妈妈再也不用担心孩子的学习！

结对闪光点：很好地实现了将团队与项目中的复杂问题逐步细化与逐一解决的过程，沟通有效，按时完成任务规划。

转载于:https://www.cnblogs.com/HelloGaveu/p/9726847.html

山清水秀iOS
关注
软工结对项目之四则运算的生成计算界面
hhhhhhh455的博客
01-21 590
软工结对项目之四则运算的生成计算界面 这是第一次真正意义上的结对项目，两个人一起完成增加了写代码的效率和正确性，往往自己不容易发现自己的bug，但你的队友却能很快发现bug并一起debug。另一方面，两个人的想法也更加丰富，比如在功能的设置拓展上，在界面的美化上，在细节处理上，1+1都是大于2的。希望以后可以多多尝试这种结对项目~ 1、Github地址 首先给出我们组的github库的地址： ht...
java 四则运算gui_结对编程-四则运算GUI的实现
weixin_33694391的博客
03-02 731
一、项目成员以及coding地址：二、结对编程题目描述在个人作业1中，用各种语言实现了一个命令行的四则运算小程序。进一步，本次要求把这个程序做成GUI，成为一个有基本功能、一定价值的程序。在下面的功能需求中实现两个：记录用户的对错总数，程序退出再启动的时候，能把以前的对错数量保存并在此基础上增量计算。记录用户的对错总数，程序退出再启动的时候，能把以前的对错数量保存并在此基础上增量计算。有计时功能，...
程序员考试刷题-exam-generation:考试代
07-07
程序员考试刷题考试生成设计指南 创建考试生成项目的一般参考指南 目录 更改日志 软件 主要软件 Python 3.6+ 对于所有项目，我们将默认使用python 3.6.0及更高版本。 如果你没有最新的python版本，你可以使用homebrew()或通过Anaconda()更新你的python。 注意：建议通过homebrew获取你的python，因为它会直接放在你的/usr/local/bin/目录下，对于Mac系统，不会在你的OS更新时出现问题。 要检查您拥有的 Python 版本，您可以执行以下操作： python3 --version 如果您不确定是否安装了 python3，也可以尝试： python --version 其他软件 对其他软件没有严格限制以与其他软件保持兼容； 但是，如果您使用其他类型的软件，请务必查看更详细的说明。 项目结构 由于这个项目是学生写的，我们需要预测毕业等真实事件，这会导致代码创建者的流失。 因此，我们希望选择最简单的方法来保持每个人的代码相关，几乎零维护，这将确保每个人的工作在任何意外休假的情况下都能继续存在。 因此，这有望确保整体努力的持久性
操作系统实验报告_MIT 6.828 JOS Lab1 实验报告
weixin_39594457的博客
12-04 563
本文使用 Zhihu On VSCode 创作并发布前言此为本人上本校的操作系统实习(实验班)时所写的实验报告，简单记述了JOS Lab的各个Exercise、Challenge(未覆盖所有Challenge，每个Lab大概做了1~3个Challenge)的基本思路。仅供有需者参考，上有关课程(比如本校的操统实习实验班)的最好不要直接抄。附上源代码链接：https://github.com/Lig...
软件工程结对项目-四则运算题目生成
tarxsbc的博客
01-14 743
软件工程结对项目-四则运算题目生成 一．项目的Github地址链接： https://github.com/guangyezhao/the_sec_se_porject 二．选题、小组讨论及分工： 我们仔细看了三道题目，都是有一定的难度，在讨论之后，我们决定选择第二个，四则运算生成。打算做第三阶段的图形界面。 我们大致讨论了一下这个程序该如何写。因为以前有做过四则运算的题目，知道运算过程可以直接用...
四则运算题目生成求解及图形界面程序（结对项目）
qq_42174315的博客
01-18 527
四则运算题目生成求解及图形界面程序（结对项目） GitHub地址 问题描述 自动生成小学四则运算题目的命令行软件，一次可以出一千道不重复的题目，并写入一个文件中，支持真分数、乘方，并能让用户输入答案，程序判定对错，给出对错的数量。 扩展方向 我们选择的扩展方向是图形界面程序，增加倒计时功能、历史记录功能。 分工 我的结对伙伴负责题目及答案生成、避免重复，我负责图形界面、用户输入及判定对错、倒计时、...
结对项目：自动生成小学四则运算题目程序
qq_43337502的博客
10-14 922
================= 这个作业属于哪个课程 软件工程 作业要求 作业要求 Github Github链接 小队成员 这个作业的目标 熟悉结对编程，实现自动生成小学四则运算题目程序，对给定的题目文件和答案文件，判定答案中的对错并进行数量统计 核心功能实现 1. 生成题目 实现思路： 随机生成参数列表和运算符列表 判断算式是否存在括号 ​ if 存在不括号： ​ 返回获取到的无括号算式 ​ else： ​ 返回获取到的括号算式 算式存
BIT软件工程结对项目——四则运算题目生成
weixin_41709195的博客
01-20 503
BIT软件工程结对项目——四则运算题目生成 目录： (点击可页内跳转) 1. 项目地址 2. PSP表格 3. 解题思路描述 ——3.1初期思考 ——3.2数独终局生成 ——3.3求解数独 4. 设计实现 ——4.1 类的组织 ——4.2 类中主要成员、方法的调用关系 ——4.3 单元测试的设计及代码覆盖率测试 5. 程序优化 6. 代码说明 7. 心得感悟 ...
软件工程结对项目——四则运算题目生成（GUI）
wen_zihan的博客
01-16 1299
目录 1.源代码的github链接： 2.PSP表格 3.题目要求 第一阶段： 第二阶段： 第三阶段： 4.解题思路 5.设计实现过程 第一二阶段： 第一部分：operation类的构建 第二部分：四则运算生成函数 第三部分：四则运算求解及判断函数 第四部分：main函数部分 在powershell上的运行结果： 单元测试部分 代码覆盖率部分 第三阶段： 6.性...
四则运算——软件工程结对项目（四则运算题目生成+网页程序）
weixin_37861541的博客
01-18 1553
四则运算题目生成+网页程序一、项目简介1、项目要求2、psp表格时间预估和实际二、项目解决思路生成运算题目思路关于括号匹配关于查重求解四则运算题目思路三、网页程序实现 github地址(cmd版) https://github.com/felinae98/virgo-calc github地址(web版) https://github.com/felinae98/virgo-calc/tree/w...
安卓毕业设计app项目源码6-CalculateExercise:软工结对编程项目-小学生四则计算练习工具项目配套安卓APP
06-06
软工结对编程项目-小学生四则计算练习工具项目配套安卓APP 软件工程 作业要求 作业目标 熟悉在未结对情况下如何结对开发项目 Github与合作者 合作者（学号）： 区德明：318005422 虚左以待 Github链接： 由于本来的...
动态规划习题其七【力扣】【算法学习day.29】
2301_79232523的博客
11-11 322
##我做这类文档一个重要的目的还是给正在学习的大家提供方向（例如想要掌握基础用法，该刷哪些题？）我的解析也不会做的非常详细，只会提供思路和一些关键点，力扣上的大佬们的题解质量是非常非常高滴！！！
c语言基础知识点（十五）C语言中的指针+1与指针的二进制表示+1的区别
qq_51519091的博客
11-13 131
给一个指针加上一个整数与给该指针的二进制表示加上同样的整数，这两者之间存在本质的区别，主要体现在操作对象、操作意义以及结果上。
gbase8s数据库常见的连接算法
最新发布
wangyx01的博客
11-13 99
外表指针指向第一条数据，内表指针顺序移动，找到和外表匹配项，记录，内表循环结束后外边指针继续向下移动，一直到外表循环结束为止。hash 连接中只有极少量的随机读，大部分都为顺序读，极大缓解了大量随机读的压力。有则取捅中进行匹配（若捅中有多条数据则发生hash碰撞），没有则继续匹配下一。hash 连接避免了嵌套循环的大量的随机读，简单伪代码如下。在gbase8s 中 ，常见的连接算法主要分为如下几种。细分可分为索引嵌套循环，块嵌套循环，半嵌套循环等。嵌套循环的缺点，在大量数据下会发生大量的随机读。
OJ08题：876. 链表的中间结点
吴先生的博客
11-12 333
过程简单，这题主要在于我们怎样让循环停下来，我们来分析一下：我们先来看一下有奇数个节点：我们可以看到，当slow指向中间节点的时候fast->next = NULL,这时候循环结束有偶数个节点：这个时候当slow指向中间节点的时候，fast指向NULL；对这两种情况分析我们知道，当fast指向NULL或fast->next=NULL时，循环结束，此时，slow指向的节点为中间节点，
[FBCTF 2019]rceservice 详细题解
weixin_73904941的博客
11-09 1409
如果在字符串最末尾的 } 之前加上一个%0a {%0a"cmd":"/bin/cat /home/rceservice/flag"%0a}此时 \x00-\x1F 匹配了第一个%0a 但是最后的.* 不能匹配换行符,也匹配不到换行后的 }所以不能遍历完整字符串,返回值为空,完成正则绕过//而在单行模式下$ 似乎会忽略在句尾的 %0a 所以如果%0a 添加在字符串最后的} 的后面的话依然会被匹配构造?
LeetCode 216-组合总数Ⅲ
qq_45801839的博客
11-11 158
【代码】LeetCode 216-组合总数Ⅲ。
渐进最优 (asymptotically optimal)
天天向上的专栏
11-13 200
渐进最优 (asymptotically optimal) 这个名词看到很多次了，在这篇博客总结一下这个概念。一个算法的复杂度，在输入值无限大时，与已知的最优算法的复杂度相比（相除），为一个常数，则该算法为渐进最优算法。的极限存在（若存在，极限值为1），则该算法为渐进最优算法。为输入值的大小，当前算法的运行时间为。，而堆排序与归并排序的算法复杂度都是。例如，最优的排序算法的复杂度为。若最优算法的运行时间下界为。，因此这两个算法为渐进最优。
力扣（leetcode）面试经典150题——88. 合并两个有序数组
qq_36748747的博客
11-10 225
给你两个按排列的整数数组nums1和nums2，另有两个整数m和n，分别表示nums1和nums2中的元素数目。请你nums2到nums1中，使合并后的数组同样按排列。最终，合并后数组不应由函数返回，而是存储在数组nums1中。为了应对这种情况，nums1的初始长度为m + n，其中前m个元素表示应合并的元素，后n个元素为0，应忽略。nums2的长度为n。需要合并 [1,2,3] 和 [2,5,6]。合并结果是 [,2,,5,6] ，其中斜体加粗标注的为 nums1 中的元素。
Java GUI四则运算练习软件设计与开发
这要求程序不仅能够处理常规的整数四则运算，还需要能够处理分数和括号，并且能够将这些情况融入题库生成逻辑中。 8. 分数运算处理: 分数的加减乘除涉及不同分母的通分和约分，需要专门的算法来处理。此外，在生成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值