四则运算之二十点小游戏(持续更新)

//github相关链接

//完整工程源码：https://github.com/Dawnfoxer/ranh941/commit/ac9f7ee72751591a6e03b311c04e4f8053e5e77c

//UML：https://github.com/Dawnfoxer/ranh941/tree/c7f1c779b2162fcd99d9b97c68d7473ef3794d04/C_Sharp/twefourpoint/UML

//docs:待定

背景：此前自己闲时写过一个C#的二十四点程序，符合Teacher Young的第一次作业编程要求。相关源码和文档已上传GitHub。

一、需求描述

　　设计一个“二十四点”游戏程序，图形界面类似下图所示，要求可以校验输入答案是否正确（表达式支持括号操作），同时具有自动求解功能（该算法需要在报告中详细说明）；另外，如无解应重新出题。

可选功能：计时、记录成绩排行榜

二、功能分析

1.1 基础功能

（1） 出题；

（2） 若当前题目存在结果为24的表达式则给出，若不存在则显示不存在；

（3） 检验输入答案是否正确；

（4） 记录答题时间；

（5） 记录成绩排行榜。

1.2 实际功能

（1） 游戏启动时，自动出题。用户也可以手工出题；

（2） 用户可选择开始和暂停游戏；

（3） 存在24的表达式时给出答案，不存在则显示不存在；

（4） 设定每次答题时间为60s，同时记录每次答题开始时间、结束时间、答题时长和答题结果；

（5） 暂停游戏后答题，只有一次答题机会，若正确则根据提示重新开始游戏或返回当前游戏（自动显示系统正确答案），若错误则直接给出答案，同时结束本次游戏；

（6） 在有效时间内答题次数不限制，若答题正确则根据提示重新开始游戏或返回当前游戏（自动显示系统正确答案），若错误则根据提示重新开始游戏或返回当前游戏继续答题。

（7） 查询记录。查询每次答题信息，包括起始时间、时长和答题结果。可选择清楚历史答题记录。

（8） 游戏玩法和版权。关于游戏的信息介绍。

1.3  程序基本界面（具体图形界面见附录）

三、具体实现

1.1 开发环境

开发工具：Visual Studio 2015 64位 + Windows10 64位。

测试机器：Windows10 64位，Windows7 32位。

其他：StartUML。

1.2 实现过程

（1） 根据面向对象编程模块化思想，将游戏的界面和逻辑处理分离。确定程序涉及到的各个功能，先针对每个功能做原型测试，再将各个功能集成。最后才根据题目要求确定界面。

（2） 将题目的基本要求完成之后，再进行功能上的拓展。前后总共用四天左右的时间，主要时间是用在原型测试上。最先做的原型是对一表达式求值，然后是四个数插入四则符号组成的表达式，最后是带括号的表达式。

（3） 在编码的过程中，完善逻辑上的处理，对数据和操作的封装。

1.3 程序易忽视点

1. 用户输入的表达式元素是否是当前的四个基础元素；

2. 四个基础元素的顺序可以改变；

3. 将字符串通过Split函数处理时产生的额外的空格；

4. 用户输入的表达式存在空格；

5. 进行四则计算时对分数或小数或负数的处理；

6. 在主窗体上新建子窗体，同时锁定父窗体，父窗体无法操作；

7. 每次处理完文件需要关闭文件流，否则线程占用；

8. 以什么形式记录数据到本地。

1.4 系统的UML静态图

四、关键问题

1.1 求表达式的值

1.1.1 算法陈述

采用栈的数据结构。

首先建立两个栈，操作数栈ovs用来记录表达式中的操作符，运算符栈ops用来存放表达式中的操作符。一开始表达式是按照从左到右顺序存放在字符串数组中，以‘；’作为结束符。对数组进行遍历，假设当前遍历的元素是str。根据不同的元素进行如下如下的处理：

（1） 如果是操作数，则入栈ovs;

（2） 如果是操作符，则需要考虑以下情况：

1. 第一个操作符都入栈ops;

2. 若操作符为左括号，则入栈ops;

3. 若操作符为右括号，则存在两种可能：

A. 若ops栈顶元素为左括号，ops出栈;

B. 否则将ovs栈栈顶两个元素弹出，ops栈顶元素弹出，设先后弹出的操作数为a、b，再从运算符栈ops中弹出一个运算符，设为+，然后作运算a+b,并将运算结果压入操作数栈ovs。

4. 若操作符为四则运算符（+=*/）,则存在三种可能：

A. 若当前ops栈顶元素不为左括号,分两组情形：

a) 若当前遍历操作符优先级低于等于操作符栈ops栈顶元素优先级，则将ovs栈栈顶两个元素弹出，ops栈顶元素弹出，设先后弹出的操作数为a、b，再从运算符栈ops中弹出一个运算符，设为+，然后作运算a+b,并将运算结果压入操作数栈ovs和当前遍历的运算符压入操作符栈ops。

b) 若当前遍历操作符优先级高于操作符栈ops栈顶元素优先级，则入栈ops；

B. 若当前ops栈顶元素为左括号，则入栈ops;

（3） 如果为‘；’，则存在两种可能：

1. 若ops中元素为0，则ovs栈顶元素弹出，作为表达式最终的结果；

2. 若ops中元素不为0，则

A. ovs栈栈顶两个元素弹出，ops栈顶元素弹出，设先后弹出的操作数为a、b，再从运算符栈ops中弹出一个运算符，设为+，然后作运算a+b,并将运算结果压入操作数栈ovs;

B. 重复A的操作，直到ops中元素为0，重复（3）中1.的操作。

        //求表达式值
        static int opsExp(string[] arr)
        {
            arr = arr.Where(s => !string.IsNullOrEmpty(s)).ToArray();
            Stack<string> ovs = new Stack<string>();//操作数
            Stack<string> ops = new Stack<string>();//操作符
            int res = 0;
            foreach (string str in arr)
            {
                if (str.Equals(";"))
                {
                    while (ops.Count != 0)
                    {
                        if (ovs.Count >= 2)
                        {
                            string firOps = ovs.Pop();
                            string secOps = ovs.Pop();
                            string onceOps = ops.Pop();
                            int[] resOps = opsAl(secOps, firOps, onceOps);
                            if (isValid(resOps[0]))
                            {
                                ovs.Push(resOps[1].ToString());

                            }
                            else
                            {
                                return res;

                            }

                        }
                    }

                    if (ops.Count == 0)
                    {

                        res = int.Parse(ovs.Pop());
                        break;
                    }

                }
                if (ovsArr.Contains(str))
                {
                    ovs.Push(str);
                }
                else if (opsArr.Contains(str))
                {
                    //第一个运算符
                    if (ops.Count == 0)
                    {
                        ops.Push(str);
                    }
                    else {

                        //遇到左括号
                        if (str.Equals("("))
                        {
                            ops.Push(str);
                        }

                        //15/12/24 3:30 by hr
                        // 还需要考虑括号隔两个操作符的情况！
                        //遇到右括号且当前栈顶元素为左括号 
                        //if (str.Equals(")") && ops.Peek().Equals('('))
                        if (str.Equals(")"))
                        {
                            //还需要考虑括号隔两个操作符的情况！
                            while (!ops.Peek().Equals("("))
                            {
                                if (ovs.Count >= 2)
                                {
                                    string firOps = ovs.Pop();
                                    string secOps = ovs.Pop();
                                    string onceOps = ops.Pop();
                                    int[] resOps = opsAl(secOps, firOps, onceOps);
                                    if (isValid(resOps[0]))
                                    {
                                        ovs.Push(resOps[1].ToString());
                                    }
                                    else
                                    {
                                        return res;
                                    }
                                }

                            }
                            if (ops.Peek().Equals("("))
                            {
                                ops.Pop();
                            }

                        }


                        if ((str.Equals("+") || str.Equals("-") || str.Equals("*") || str.Equals("/")))
                        {

                            //当前操作符优先级低于操作符栈顶元素优先级 
                            if (!ops.Peek().Equals("(") && privority(ops.Peek()) >= privority(str))
                            {
                                if (ovs.Count >= 2)
                                {
                                    string firOps = ovs.Pop();
                                    string secOps = ovs.Pop();
                                    string onceOps = ops.Pop();
                                    int[] resOps = opsAl(secOps, firOps, onceOps);
                                    if (isValid(resOps[0]))
                                    {
                                        ovs.Push(resOps[1].ToString());
                                        ops.Push(str);
                                    }
                                    else
                                    {
                                        return res;
                                    }

                                }
                            }

                            //当前运算符优先级大于运算符栈顶元素优先级
                            if (!ops.Peek().Equals("(") && privority(ops.Peek()) < privority(str))
                            {
                                ops.Push(str);
                            }

                            if (ops.Peek().Equals("("))
                            {
                                ops.Push(str);
                            }


                        }
                    }

                }
                else
                {
                    //Console.WriteLine("存在不合法数据或符号");
                    break;
                }

            }

            return res;
        }

1.2 四个数和四则运算以及括号组成的表达式

可以采取分治的思想。先考虑四个数的组合情况（四个数一开始是生成了的，也就是说四个数给定了的），再考虑向四个数中插入三个运算符，最后再考虑加入括号的情况。四个数不重复的组合数是4*3*2*1=24种，从四个运算符中选3个组成的组合共有4^3=64种，也就是说不含括号的表达式总共有24*64=1536种可能。再来考虑加括号的可能，分为两种情况，四个数加括号的有效情况：一种是只有一对括号，一种是只有两对括号，均为5种，因此带括号的表达式总共1536*10=15360种。这说明采取枚举法是可取的。

0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24

红色格子为插入数字，黑色为插入运算符，其余部分则是插入括号。

将数字和运算符的位置固定，用循环对其赋值，括号的位置可直接枚举后，循环进行赋值，如此即可获取所有的表达式组合。

        //满足24的表达式
        //返回值为空字符时 表示不存在满足条件的表达式
        static string rightExp(string ops0, string ops1, string ops2, string ops3)
        {
            string[] exp = new string[200];//存储表达式 无括号
            string[] expKhArr = new string[200];//存储表达式 带括号
            exp[199] = ";";//表达式结束符
            string rExp = "";//存放正确的表达式

            exp[2] = ops0;
            exp[8] = ops1;
            exp[14] = ops2;
            exp[20] = ops3;

            //无括号
            for (int o = 0; o < 4; o++)
                for (int p = 0; p < 4; p++)
                    for (int q = 0; q < 4; q++)
                    {
                        exp[5] = fOps[o];
                        exp[11] = fOps[p];
                        exp[17] = fOps[q];

                        //默认 没有括号的情况
                        rExp = isRightExp(exp);
                        if (rExp.Count() != 0)
                        {
                            return rExp;
                        }

                        //一对括号
                        for (int i = 0; i < kh1ps.Length; i += 2)
                        {

                            expKhArr = expKh(exp, false, i, (i + 1));
                            rExp = isRightExp(expKhArr);
                            if (rExp.Count() != 0)
                            {
                                return rExp;
                            }

                            //清除此次运算的括号 运算符和操作数是固定位置 可被覆盖 因此不作考虑
                            exp[kh1ps[i]] = "";
                            exp[kh1ps[i + 1]] = "";

                        }

                        //两对括号
                        for (int i = 0; i < kh2ps.Length; i += 4)
                        {

                            expKhArr = expKh(exp, true, i, (i + 1), (i + 2), (i + 3));
                            rExp = isRightExp(expKhArr);
                            if (rExp.Count() != 0)
                            {
                                return rExp;
                            }
                            
                            //清除此次运算的括号
                            exp[kh2ps[i]] = "";
                            exp[kh2ps[i + 1]] = "";
                            exp[kh2ps[i + 2]] = "";
                            exp[kh2ps[i + 3]] = "";

                        }
                    }

            return rExp;
        }

        //产生四个基础元素
        public static string[] randElem()
        {
            string[] elem = new string[4];
            Random a = new Random();
            int elemNum = 0;
            while (elemNum < 4)
            {
                int opsEle = a.Next(0, 13);
                string opsTemp = ovsArr[opsEle];
                if (!elem.Contains(opsTemp))
                {
                    elem[elemNum++] = opsTemp;
                    //  Console.WriteLine("基础："+opsEle);
                }

            }
            return elem;
        }

        //考虑正确表达式带括号 
        //flag false为一括号 true为二括号
        static string[] expKh(string[] expKh, bool flag, int a, int b, int c = 0, int d = 0)
        {
            if (!flag)
            {

                expKh[kh1ps[a]] = "(";
                expKh[kh1ps[b]] = ")";
            }
            else
            {
                expKh[kh2ps[a]] = "(";
                expKh[kh2ps[b]] = ")";
                expKh[kh2ps[c]] = "(";
                expKh[kh2ps[d]] = ")";
            }
            return expKh;
        }

        //获取表达式的值是否为24
       static string isRightExp(string[] exp)
        {
            string rightExp = "";
            if (opsExp(exp) == 24)
            {
                rightExp = String.Join("", exp.Where(s => !string.IsNullOrEmpty(s)).ToArray());
                return rightExp.TrimEnd(';');
            }
            else {
                rightExp = "";//清空数据 下次不受影响
            }

            return rightExp;
        }

        //基础元素的组合
        static string[] opsP(string[] ops)
        {
            string[] opsP = new string[222];
            int opsPNum = 0;
            int opsNum = ops.Length;
            for (int i = 0; i < opsNum; i++)
                for (int j = 0; j < opsNum; j++)
                    for (int k = 0; k < opsNum; k++)
                        for (int l = 0; l < opsNum; l++)
                        {
                            if (i != j && i != k && i != l && j != k && j != l && k != l)
                            {
                                opsP[opsPNum++] = ops[i];
                                opsP[opsPNum++] = ops[j];
                                opsP[opsPNum++] = ops[k];
                                opsP[opsPNum++] = ops[l];

                            }
                        }

            return opsP;
        }

        //值为的24表达式组合是否存在
        public static string beginTestRightExp(string[] eleArr)
        {
            string[] opsPArr = opsP(eleArr);
            string rightexp = "";
            for (int i = 0; i < opsPArr.Length; i += 4)
            {
                rightexp = rightExp(opsPArr[i], opsPArr[i + 1], opsPArr[i + 2], opsPArr[i + 3]);
                if (rightexp.Length != 0)
                {
                    return rightexp;
                }

            }

            return rightexp;
        }

附录：

附加：

　　1. 疑问，这能算是投机取巧？在进度条中的代码量应该记为0？

　　2. 在大一下使用GitHub,虽然每次重装系统后都会安装好GitHub Windows客户端，但是除了看看别人的代码，基本就没使用。这次使用，折腾了49min（包含网络影响）。忏愧。图有其表，差评。待改进。后期补上相关博客（截止日期16/3/21）。

　　3. 因程序基本完成，本打算对代码进行效能分析（performance wizard？）。此前从未接触过，网上查询相关资料（40~60min），失败。后期完成（截止日期16/3/28）。耽误太多时间。

　　4. 第一次编辑（109min）；第二次编辑（预计60min/实际73min）。

　　5. 该程序作为分析程序，独立出来，关于四则运算程序重新编写（截止时间2016/03/18）。