结对项目2.0版

更新内容：

1.在之前基础上实现四个数的四则运算。

2.实现了带有括号的运算。

存在问题：

运算过程中偶尔会有-nan(ind)的结果，还在找原因。

部分代码如下：

  1 //运算符栈的长度
  2 #define OPSTACK_LENGTH 5
  3 //操作数栈的长度
  4 #define NUMSTACK_LENGTH 100
  5 //输入串的最大长度
  6 #define MAX_STRING_LENGTH 100
  7 #pragma warning(disable:4996)
  8 //表达式结构体
  9 struct biaodashi
 10 {
 11     char word;
 12 };
 13 //运算符结构体
 14 struct operatorStruct
 15 {
 16     //运算符名称
 17     char name;
 18     //优先级
 19     int priority;
 20     //目数，即操作数个数，例如单目运算符为1，双目运算符2
 21     int opnum;
 22 };
 23
 24 typedef struct operatorStruct OPERATOR;
 25
 26 //运算符栈
 27 OPERATOR opStack[OPSTACK_LENGTH];
 28 //运算符栈顶指针
 29
 30 //操作数栈
 31 double numStack[NUMSTACK_LENGTH];
 32 //操作数栈顶指针
 33 int opStackTop = -1;
 34 int numStackTop = -1;
 35
 36 //获取一个字符所代表的运算符的优先级
 37 int getPriority(char name)
 38 {
 39     if (name == ‘(‘ || name == ‘)‘)
 40     {
 41         return 0;
 42     }
 43     if (name == ‘!‘)
 44     {
 45         return 3;
 46     }
 47     if (name == ‘*‘ || name == ‘/‘)
 48     {
 49         return 2;
 50     }
 51     if (name == ‘+‘ || name == ‘-‘)
 52     {
 53         return 1;
 54     }
 55
 56 }
 57 //获取一个字符所代表的运算符的目数
 58 int getOpNum(char name)
 59 {
 60     if (name == ‘*‘ || name == ‘/‘ || name == ‘+‘ || name == ‘-‘)
 61     {
 62         return 2;
 63     }
 64     if (name == ‘!‘)
 65     {
 66         return 1;
 67     }
 68     if (name == ‘(‘ || name == ‘)‘)
 69     {
 70         return 0;
 71     }
 72
 73 }
 74
 75 //运算符压栈
 76 void pushOperator(OPERATOR op)
 77 {
 78     if (opStackTop < OPSTACK_LENGTH - 1)
 79     {
 80         opStack[++opStackTop] = op;
 81     }
 82 }
 83 //运算符出栈
 84 OPERATOR popOperator()
 85 {
 86     if (opStackTop >= 0)
 87     {
 88         return opStack[opStackTop--];
 89     }
 90 }
 91 //操作数压栈
 92 void pushNumber(double num)
 93 {
 94     if (numStackTop < NUMSTACK_LENGTH - 1)
 95     {
 96         numStack[++numStackTop] = num;
 97     }
 98 }
 99 //操作数出栈
100 double popNumber()
101 {
102     if (numStackTop >= 0)
103     {
104         return numStack[numStackTop--];
105     }
106 }
107
108 //从操作数栈中弹出两个操作数，完成一次双目运算
109 double opertate2Num(OPERATOR op)
110 {
111     double num2 = popNumber();
112     double num1 = popNumber();
113     if (op.name == ‘+‘)
114     {
115         return num1 + num2;
116     }
117     if (op.name == ‘-‘)
118     {
119         return num1 - num2;
120     }
121     if (op.name == ‘*‘)
122     {
123         return num1 * num2;
124     }
125     if (op.name == ‘/‘)
126     {
127         return num1 / num2;
128     }
129 }
130 //从操作数栈中弹出一个操作数，完成一次单目运算
131 double opertate1Num(OPERATOR op)
132 {
133     double num = popNumber();
134     if (op.name == ‘!‘)
135     {
136         double result = 1;
137         while (num > 1)
138         {
139             result *= num;
140             num--;
141         }
142         return result;
143     }
144
145 }
146 //完成一次运算
147 double operate(OPERATOR op)
148 {
149     if (op.opnum == 1)
150     {
151         return opertate1Num(op);
152     }
153     else if (op.opnum == 2)
154     {
155         return opertate2Num(op);
156     }
157
158 }
159 //四则运算计算器
160 double Calculate(struct biaodashi *string)
161 {
162
163     int i;
164     OPERATOR op, topOp;//op为从当前输入串中提取的一个运算符，topOp为运算符栈栈顶的运算符
165
166     topOp.name = ‘#‘;
167     topOp.priority = 0;
168     topOp.opnum = 0;
169     pushOperator(topOp);//压入#作为初始运算符
170
171     for (i = 0; string[i].word != ‘=‘;i++)
172     {
173         //从输入串中取出一个字符作为开始，进行处理，直到表达式结束
174         if (string[i].word!=‘+‘ && string[i].word != ‘-‘&& string[i].word != ‘*‘&& string[i].word != ‘/‘&& string[i].word != ‘(‘&& string[i].word != ‘)‘)
175         {
176             //如果是操作数，将整个操作数提取出来，压入操作数栈
177             pushNumber((double)(string[i].word));
178         }
179         else
180         {
181             op.name = string[i].word;
182             op.priority = getPriority(string[i].word);
183             op.opnum = getOpNum(string[i].word);
184             topOp = popOperator();
185             if (op.name == ‘(‘)
186             {
187                 //如果是‘(‘，将从栈顶弹出的运算符压回栈内，并将当前运算符则压栈
188                 pushOperator(topOp);
189                 pushOperator(op);
190             }
191             else if (op.name == ‘)‘)
192             {
193                 //如果是‘)‘，则进行运算，每次运算结果作为一个操作数压入操作数栈，直到将‘(‘弹出运算符栈
194                 while (topOp.name != ‘(‘)
195                 {
196                     pushNumber(operate(topOp));
197                     topOp = popOperator();
198                 }
199             }
200             else
201             {
202                 //如果是普通运算符
203                 if (topOp.name != ‘#‘ && op.priority <= topOp.priority)
204                 {
205                     //如果运算符栈非空，且当前运算符的优先级大于栈顶运算符，则进行一次运算，将结果压入操作数栈
206                     pushNumber(operate(topOp));
207                 }
208                 else
209                 {
210                     //否则将从栈顶弹出的运算符压回
211                     pushOperator(topOp);
212                 }
213                 //将当前运算符压栈
214                 pushOperator(op);
215             }
216         }
217
218     }
219     //完成栈内剩余的运算
220     while ((topOp = popOperator()).name != ‘#‘)
221     {
222         pushNumber(operate(topOp));
223     }
224     //操作数栈中剩下的最后一个数即为结果
225     return popNumber();
226 }

这部分为计算器，主体来自http://blog.csdn.net/bhq2010/article/details/7516369，做了些必要的修改。

 1 int N = 0, i = 0;
 2     int optr1 = 0, optr2 = 0, optr3 = 0, kuohao = 0;
 3     int num1, num2, num3, num4;
 4
 5     double answer1, answer2;
 6     struct biaodashi string[15];
 7     char str[] = "+-*/", ch;
 8
 9     srand((unsigned)time(0));
10
11     printf("请输入本次测试的题目数量：");        //手动输入题目数量
12     scanf("%d", &N);
13     ch = getchar();
14
15     printf("保留两位小数\n");                    //输入结果如果有小数，保留两位小数

部分主函数代码。

 1     for (i = 0; i < N; i++)
 2     {
 3         num1 = rand() % 100 + 1;                       //生成随机数
 4         num2 = rand() % 100 + 1;
 5         num3 = rand() % 100 + 1;
 6         num4 = rand() % 100 + 1;
 7         optr1 = rand() % 4;
 8         optr2 = rand() % 4;
 9         optr3 = rand() % 4;
10         kuohao = rand() % 8;
11         if (num1 > 40)
12         {
13             printf("题号：%d\n", i + 1);
14             printf("%d %c %d %c %d %c %d=?\n", num1, str[optr1], num2, str[optr2], num3, str[optr3], num4);
15             string[0].word = num1;
16             string[1].word = str[optr1];
17             string[2].word = num2;
18             string[3].word = str[optr2];
19             string[4].word = num3;
20             string[5].word = str[optr3];
21             string[6].word = num4;
22             string[7].word = ‘=‘;
23             answer1 = Calculate(string);
24             scanf("%lf", &answer2);
25             ch = getchar();
26             if ((fabs(answer2-answer1))<0.01)
27                 printf("正确\n");
28             else printf("错误 正确答案是：%-10.2lf\n", answer1);
29         }

这部分为不带括号的出题方式，比例大小为60%

else
                    {
                        printf("题号：%d\n", i + 1);
                        switch (kuohao)
                        {
                        case 1:
                            printf("(%d %c %d) %c %d %c %d=?\n", num1, str[optr1], num2, str[optr2], num3, str[optr3], num4);
                            string[0].word = ‘(‘;
                            string[1].word = num1;
                            string[2].word = str[optr1];
                            string[3].word = num2;
                            string[4].word = ‘)‘;
                            string[5].word = str[optr2];
                            string[6].word= num3;
                            string[7].word = str[optr3];
                            string[8].word = num4;
                            string[9].word = ‘=‘;
                            break;
                        case 2:
                            printf("(%d %c %d %c %d) %c %d=?\n", num1, str[optr1], num2, str[optr2], num3, str[optr3], num4);
                            string[0].word = ‘(‘;
                            string[1].word = num1;
                            string[2].word = str[optr1];
                            string[3].word = num2;
                            string[4].word = str[optr2];
                            string[5].word = num3;
                            string[6].word = ‘)‘;
                            string[7].word = str[optr3];
                            string[8].word = num4;
                            string[9].word = ‘=‘;
                            break;
                        case 3:
                            printf("%d %c (%d %c %d) %c %d=?\n", num1, str[optr1], num2, str[optr2], num3, str[optr3], num4);
                            string[0].word = num1;
                            string[1].word = str[optr1];
                            string[2].word = ‘(‘;
                            string[3].word = num2;
                            string[4].word = str[optr2];
                            string[5].word = num3;
                            string[6].word = ‘)‘;
                            string[7].word = str[optr3];
                            string[8].word = num4;
                            string[9].word = ‘=‘;
                            break;
                        case 4:
                            printf("%d %c (%d %c %d %c %d)=?\n", num1, str[optr1], num2, str[optr2], num3, str[optr3], num4);
                            string[0].word = num1;
                            string[1].word = str[optr1];
                            string[2].word = ‘(‘;
                            string[3].word = num2;
                            string[4].word = str[optr2];
                            string[5].word = num3;
                            string[6].word = str[optr3];
                            string[7].word = num4;
                            string[8].word = ‘)‘;
                            string[9].word = ‘=‘;
                            break;
                        case 5:
                            printf("%d %c %d %c (%d %c %d)=?\n", num1, str[optr1], num2, str[optr2], num3, str[optr3], num4);
                            string[0].word = num1;
                            string[1].word = str[optr1];
                            string[2].word = num2;
                            string[3].word= str[optr2];
                            string[4].word = ‘(‘;
                            string[5].word = num3;
                            string[6].word = str[optr3];
                            string[7].word = num4;
                            string[8].word = ‘)‘;
                            string[9].word = ‘=‘;
                            break;
                        case 6:
                            printf("(%d %c %d) %c (%d %c %d)=?\n", num1, str[optr1], num2, str[optr2], num3, str[optr3], num4);
                            string[0].word = ‘(‘;
                            string[1].word = num1;
                            string[2].word = str[optr1];
                            string[3].word = num2;
                            string[4].word = ‘)‘;
                            string[5].word = str[optr2];
                            string[6].word = ‘(‘;
                            string[7].word = num3;
                            string[8].word = str[optr3];
                            string[9].word = num4;
                            string[10].word = ‘)‘;
                            string[11].word = ‘=‘;
                            break;
                        case 7:
                            printf("(%d %c (%d %c %d)) %c %d=?\n", num1, str[optr1], num2, str[optr2], num3, str[optr3], num4);
                            string[0].word = ‘(‘;
                            string[1].word = num1;
                            string[2].word = str[optr1];
                            string[3].word = ‘(‘;
                            string[4].word = num2;
                            string[5].word = str[optr2];
                            string[6].word = num3;
                            string[7].word = ‘)‘;
                            string[8].word = ‘)‘;
                            string[9].word = str[optr3];
                            string[10].word = num4;
                            string[11].word = ‘=‘;
                            break;
                        case 8:
                            printf("%d %c (%d %c (%d %c %d))=?\n", num1, str[optr1], num2, str[optr2], num3, str[optr3], num4);
                            string[0].word = num1;
                            string[1].word = str[optr1];
                            string[2].word = ‘(‘;
                            string[3].word = num2;
                            string[4].word = str[optr2];
                            string[5].word= ‘(‘;
                            string[6].word = num3;
                            string[7].word = str[optr3];
                            string[8].word = num4;
                            string[9].word = ‘)‘;
                            string[10].word = ‘)‘;
                            string[11].word = ‘=‘;
                            break;
                        default: printf("错误\n");
                        }
                        answer1 = Calculate(string);
                        scanf("%lf", &answer2);
                        ch = getchar();

                        if ((fabs(answer2-answer1))<0.01)
                            printf("正确\n");
                        else printf("错误 正确答案是：%-10.2lf\n", answer1);
                    }

带括号的出题方式采用的枚举法，所以略长，比例为40%

输出结果：

结果：可以看到第6题出现了-nan(ind)的问题，百度一下意思是not a number，应该是计算过程中出了问题，但是还没找到。

时间： 2024-08-03 20:12:53

结对项目2.0版的相关文章

0414 结对项目2.0

一.主要功能与需求分析 1.本金为100万,利率或者投资回报率为3%,投资年限为30年,那么,30年后所获得的利息收入:按复利计算公式来计算就是:1,000,000×(1+3%)^30 2.如果按照单利计算,本息的最终收益 3.假如30年之后要筹措到300万元的养老金,平均的年回报率是3%,那么,现在必须投入的本金是多少呢? 4.利率这么低,复利计算收益都这么厉害了,如果拿100万元去买年报酬率10%的股票,若一切顺利,过多长时间,100万元就变成200万元呢? 5.如果我希望在十年内将100万

java在线聊天项目1.0版 异常处理——开启多个客户端，关闭一个客户端后，在其他客户端中再发出信息会出现异常的处理

异常一 只开启一个客户端,输入信息后关闭,客户端出现如下异常 根据异常说明 ChatClientFrame客户端117行 提示原因是Socket关闭 分析原因 客户端代码 while (connected) { String str = dis.readUTF(); 当窗口关闭后,Socket已经关闭,读的操作还在继续 处理这个异常,代码如下 catch (SocketException e) { System.out.println("a client has been closed!&quo

结对项目-四则运算出题程序（GUI版）

目录: 一.致搭档(含项目地址) 二.PSP(planning) 三.结对编程中对接口的设计 四.计算模块接口的设计与实现过程 五.计算模块接口部分的性能改进 六.计算模块部分单元测试展示 七.计算模块部分异常处理说明 八.界面模块的详细设计过程 九.界面模块与计算模块的对接 十.结对过程的描述 十一.结对编程的优缺点 十二.PSP(actual) 一.致搭档:     队友:李庭娟(我很喜欢把这位队友叫娟子,感觉很亲切) 首先非常非常感谢这位结对搭档--娟子,从最初组队到如今合作,始终非常信任

结对作业（1.0版）

import java.awt.EventQueue; import javax.swing.JFrame; import javax.swing.JPanel; import javax.swing.GroupLayout; import javax.swing.GroupLayout.Alignment; import javax.swing.LayoutStyle.ComponentPlacement; import java.awt.Font; import javax.swing.JT

小学四则运算练习题网页版结对项目报告

一.项目结构 二.计算模块和界面模块间的调用 三.页面演示效果 四.遇到问题 五.知识点记录 六.新知识新技能 七.未实现但计划实现功能 八.学习目标与总结 项目地址:https://git.dev.tencent.com/hey_wuqw/webArithmetic.git 一.项目结构 二. 计算模块和界面模块间的调用 三.页面演示效果 四.遇到问题 1.check()方法(用于接收答题页面传来的参数,请求从answer.jsp(答题界面)转发到result.jsp(做题结果界面))需要访问

结对项目 - 词频统计Ⅱ

目的与要求 代码复审练习 结对练习 编写单元测试 基于上一个结对项目的结果,读取小文本文件A_Tale_of_Two_Cities.txt 或者 大文本文件Gone_with_the_wind.txt,统计某一指定单词在该文本文件中出现的频率. 命令行格式: 提示符> Myapp.exe -f filename.txt -w word (PS:C++ 程序,Java 程序输出方式类似) 解释: 选项 -f 表示打开某一文件 选项 -w 表示统计其后单词在打开的文件中的频率 详细内容 开发语言:J

仿QQ聊天软件2.0版

仿QQ聊天软件2.0版 转载请标明出处:牟尼的专栏 http://blog.csdn.net/u012027907     上次课设做了Java版的仿QQ聊天程序,这次软件实训,我们继续完善了仿QQ聊天程序,将上次未完成及不完善的地方进行完善和改进,还新加了部分功能:表情输入.气泡模式.文件传输.截屏.语音聊天.逐步向QQ的基本功能靠齐.通过这次软件实训,又有了很多收获. 一.设计内容及要求 1.1综述 A.系统概述 我们要做的就是类似QQ这样的面向企业内部的聊天软件,基本功能和QQ类似.首先,

结对项目—地铁出行路线规划

结对项目—地铁出行路线规划 我的搭档:陈鸿超 14061216 https://github.com/ChengFR/PairProgramming_SubwayRoute- 会在十一期间发布新版本 结对编程体会: 结对编程的优点: 站在软件开发的角度,两个人共同面对同一台电脑进行开发,无论是效率还是软件质量都要超过一个人进行开发的情况. 对于还处于学习阶段的年轻软件开发者来说,结对编程是一个很好的互相学习的机会 结对编程时动力.责任感更强 结对编程的缺点: 对于我们来说,寻找两个人共同的时间进

结对项目2

题目:构造程序,分别是: •不能触发Fault •触发Fault,但是不能触发Error. •触发Error,但是不能产生Failure. 结对对象:王翰林   博客地址:http://www.cnblogs.com/whl1127/p/5405639.html 双方贡献比例:1:1 编程照片: 源代码: import java.util.Scanner; public class MainTest { public static void main(String[] args) { doubl