kestrel java_结对项目(JAVA)

项目成员：

邓镇港 3117004608

陈嘉欣 3117004604

## 一、Github项目地址：

**[https://github.com/kestrelcjx/operation_expression](https://github.com/kestrelcjx/operation_expression)**

## 二、PSP表格

PSP2.1|Personal Software Process Stages|预估耗时(分钟)|实际耗时(分钟)

-|-|-|-

Planning|计划|30|25

Estimate|估计这个任务需要多少时间|10|12

Development|开发|600|488

Analysis|需求分析|120|150

Design Spec|生成设计文档|30|55

Design Review|设计复审|40|50

Coding Standard|代码规范|20|65

Design|具体设计|60|40

Coding|具体编码|480|460

Code Review|代码复审|30|25

Test|测试(自我测试，修改代码，提交修改)|60|125

Reporting|报告|60|100

Test Report|测试报告|20|35

Size Measurement|计算工作量|10|12

Postmortem & Process Improvement Plan|事后总结, 并提出过程改进计划|120|100

合计||1690|1742

## 三、效能分析

把数字封装成类，每个数字类由整数、分子、分母三部分组成。在类中重新定义加减乘除方法，每个运算方法都会用到通分，约分，将他们写成reduction()方法,gcd()方法。

查重功能实现得比较简单，生成10000条题目所需的时间很短：



代码覆盖率：

四、设计实现过程

这次的项目需求是自动生成四则运算题目，难点在于随机数的处理和优先级的计算。在阅读完题目并分析需求后，我们先解决的是随机数的生成。因为要求有自然数和真分数，我们用到了一个数字类BasicWork来产生随机数。数字类定义一个数为带分数，分子为零的时候生成一个整数，否则生成一个真分数。这样做的好处是可以将自然数和真分数都统一，在后续的生成和计算过程能够通过调用数字类的方法处理。在数字类中，因为每个随机数都有3个部分组成，我们重新定义了数字类的加减乘除方法。数字类中还包括一个约分方法reduction()对生成的随机数和计算的结果进行处理，确保数字类满足是自然数或真分数的需求。

CreatExpress类用来随机生成式子，用一个随机数来决定式子的操作数个数，根据操作数个数随机生成运算符并连接成四则运算表达式。生成括号这一部分的处理，是通过判断括号出现的正确位置来随机生成。

MainShow主类则是显示出相关的使用信息，接收用户传入的参数。实现生成题目文件和答案文件需求的方法写在主类中，循环生成式子的同时把式子逐条写进题目文件里，并计算出答案写进答案文件。判断表达式重复的过程就是判断计算过程是否重复，这里仅仅是判断结果是否相同，不够完善。生成式子时调用主类的check()方法计算得出答案，并判断答案是否一致进行正确统计。

五、代码说明

对表达式字符串逐个字符判断，将操作数与操作符分隔，同时，将原来的中缀表达式转换为后缀表达式进行计算。

对于将中缀表达式转后缀表达式，进行如下操作：从表达式左到右进行操作，如果是数值，将其放入number数组模拟的栈；如果是操作符，判断symbol数组模拟的栈，如果栈为空或栈顶为左括号，操作符直接进栈，如果栈顶为操作符，根据操作符优先级判断，如果栈顶操作符优先级低，操作符直接进栈，否则，将栈顶操作符放入number数组，继续讨论栈顶元素；如果是左括号，直接进栈；如果是右括号，将栈顶操作符放入number数组，直到栈顶为左括号，括号不放入number数组。最后将symbo模拟的栈中剩余操作符取出放入number数组。

于是，我们便得到后缀表达式，对后缀表达式进行计算，从表达式(number数组)左到右进行操作，如果是操作数，放入stk栈；如果是操作符，将stk栈顶2个元素进行计算，再将结果放入stk栈。最后，stk栈剩余一个操作数，便是表达式结果，运算无误则方法返回结果。在计算过程中，判断是否出现负数，如果出现负数方法返回null值，表示表达式不合法。

//判断表达式是否合法，是否重复

public static BasicWork check(String s) {

boolean flag = true;

String symbol[] = new String[100];

int sym = 0;

String number[] = new String[100];

int num = 0;

String str = "";

//计算、判断合法、判断重复

for(int i = 0; i < s.length(); i++) {

if(s.charAt(i) == '+' || s.charAt(i) == '-' || s.charAt(i) == '×' || s.charAt(i) == '÷'

|| s.charAt(i) == '(' || s.charAt(i) == ')') {

if(!str.equals("")) {

number[num++] = str;

str = "";

}

if(s.charAt(i) == '+') {

while(sym != 0 && !symbol[sym-1].equals("(")) {

number[num++] = symbol[sym-1];

sym--;

}

symbol[sym++] = "+";

}

else if(s.charAt(i) == '-') {

while(sym != 0 && !symbol[sym-1].equals("(")) {

number[num++] = symbol[sym-1];

sym--;

}

symbol[sym++] = "-";

}

else if(s.charAt(i) == '×') {

while(sym != 0 && (symbol[sym-1].equals("×") || symbol[sym-1].equals("÷"))) {

number[num++] = symbol[sym-1];

sym--;

}

symbol[sym++] = "×";

}

else if(s.charAt(i) == '÷') {

while(sym != 0 && (symbol[sym-1].equals("×") || symbol[sym-1].equals("÷"))) {

number[num++] = symbol[sym-1];

sym--;

}

symbol[sym++] = "÷";

}

else if(s.charAt(i) == '(') {

symbol[sym++] = "(";

}

else if(s.charAt(i) == ')') {

while(sym != 0 && !symbol[sym-1].equals("(")) {

number[num++] = symbol[sym-1];

sym--;

}

if(sym != 0 && symbol[sym-1].equals("(")) sym--;

}

}

else {

str += s.charAt(i);

}

}

BasicWork tempA, tempB;

if(!str.equals("")) number[num++] = str;

while(sym > 0) {

number[num++] = symbol[sym-1];

sym--;

}

//for(int i = 0; i < num; i++) System.out.print(number[i]+" ");

//System.out.println();

Stack stk = new Stack();

for(int i = 0; i < num; i++) {

if(number[i].equals("+")) {

tempA = stk.peek();

stk.pop();

tempB = stk.peek();

stk.pop();

tempA = tempB.add(tempA);

stk.push(tempA);

}

else if(number[i].equals("-")) {

tempA = stk.peek();

stk.pop();

tempB = stk.peek();

stk.pop();

tempA = tempB.sub(tempA);

stk.push(tempA);

if(tempA.zheng < 0 || tempA.fenzi < 0||tempA.fenmu<0) {

flag = false;

break;

}

}

else if(number[i].equals("×")) {

tempA = stk.peek();

stk.pop();

tempB = stk.peek();

stk.pop();

tempA = tempB.mul(tempA);

stk.push(tempA);

}

else if(number[i].equals("÷")) {

tempA = stk.peek();

stk.pop();

tempB = stk.peek();

stk.pop();

if(tempA.zheng == 0 && tempA.fenzi == 0) {

flag = false;

break;

}

tempA = tempB.div(tempA);

stk.push(tempA);

}

else {

stk.push(BasicWork.toBasicWork(number[i]));

}

}

if(flag == false) return null;

else return stk.peek();

}

随机生成一条式子

//生成一条式子

public static String express(int limit,int opnum) {

String str = null;

for(int i=0;i

a[i]=new BasicWork(limit);

BasicWork.reduction(a[i]);

}

if(opnum == 2) {

str = a[0].toString() + getSymbol() + a[1].toString();

}

else if(opnum == 3) {

int randx = (int)(Math.random()*10);

if(randx == 0)

str = "("+a[0].toString() + getSymbol() + a[1].toString() + ")" + getSymbol() + a[2].toString();

else if(randx == 1)

str = a[0].toString() + getSymbol() + "(" + a[1].toString() + getSymbol() + a[2].toString() + ")";

else

str = a[0].toString() + getSymbol() + a[1].toString() + getSymbol() + a[2].toString();

}

else {

int randx = (int)(Math.random()*30);

if(randx == 0)

str = "(" + a[0].toString() + getSymbol() + a[1].toString() + getSymbol() + a[2].toString() + ")"

+ getSymbol() + a[3].toString();

else if(randx == 1)

str = a[0].toString() + getSymbol() + "(" + a[1].toString() + getSymbol() + a[2].toString() + ")"

+ getSymbol() + a[3].toString();

else if(randx == 2)

str = "(" + a[0].toString() + getSymbol() + "(" + a[1].toString() + getSymbol() + a[2].toString() + "))"

+ getSymbol() + a[3].toString();

else if(randx == 3)

str = a[0].toString() + getSymbol() + "(" + a[1].toString() + getSymbol() + "(" + a[2].toString()

+ getSymbol() + a[3].toString() + "))";

else if(randx == 4)

str = "(" + a[0].toString() + getSymbol() + a[1].toString() + ")" + getSymbol() + "(" + a[2].toString()

+ getSymbol() + a[3].toString() + ")";

else

str = a[0].toString() + getSymbol() + a[1].toString() + getSymbol() + a[2].toString()

+ getSymbol() + a[3].toString();

}

return str;

}

数字类BasicWork

public class BasicWork {

int fenzi;

int fenmu;

int zheng;

public BasicWork() {

}

public BasicWork(int limit) {

//fenzi=(int)(0+Math.random()*(limit-0+1));

//zheng=(int)(0+Math.random()*(limit-0+1));

zheng=0;

fenmu=(int)(1+Math.random()*(limit-1+1));

fenzi=(int)(Math.random()*fenmu*limit);

reduction(this);

}

//用于测试

public BasicWork(int a,int b,int c) {

fenzi=a;

fenmu=b;

zheng=c;

}

//约分方法

public static void reduction(BasicWork reop) {

int re=gcd(reop.fenzi,reop.fenmu);

re = re == 0 ? 1 : re;

reop.fenzi=reop.fenzi/re;

reop.fenmu=reop.fenmu/re;

//System.out.println(reop.fenzi + " " + reop.fenmu);

try {

if(reop.fenzi>=reop.fenmu) {

reop.zheng=reop.zheng+reop.fenzi/reop.fenmu;

reop.fenzi=reop.fenzi%reop.fenmu;

if(reop.fenzi==0) reop.fenmu=1;

}

} catch (Exception e) {

e.printStackTrace();

}

}

public BasicWork add(BasicWork a) {

BasicWork temp=new BasicWork();

temp.zheng=zheng+a.zheng;

temp.fenmu=fenmu*a.fenmu;

temp.fenzi=fenzi*a.fenmu+a.fenzi*fenmu;

//约分

reduction(temp);

return temp;

}

public BasicWork sub(BasicWork s) {

BasicWork temp=new BasicWork();

temp.fenzi=fenzi+fenmu*zheng;

temp.zheng=0;

temp.fenmu=fenmu;

s.fenzi=s.fenzi+s.fenmu*s.zheng;

s.zheng=0;

temp.fenzi=temp.fenzi*s.fenmu;

s.fenzi=s.fenzi*temp.fenmu;

temp.fenmu=temp.fenmu*s.fenmu;

temp.fenzi=temp.fenzi-s.fenzi;

//约分

reduction(temp);

return temp;

}

public BasicWork mul(BasicWork m) {

BasicWork temp=new BasicWork();

temp.fenzi=fenzi+fenmu*zheng;

temp.zheng=0;

temp.fenmu=fenmu;

m.fenzi=m.fenzi+m.fenmu*m.zheng;

m.zheng=0;

temp.fenmu=temp.fenmu*m.fenmu;

temp.fenzi=temp.fenzi*m.fenzi;

//约分

reduction(temp);

return temp;

}

public BasicWork div(BasicWork d) {

d.fenzi+=d.fenmu*d.zheng;

d.zheng=0;

int i;

i=d.fenmu;

d.fenmu=d.fenzi;

d.fenzi=i;

return this.mul(d);

}

public boolean equals(BasicWork rhs) {

return (zheng*fenmu+fenzi)*rhs.fenmu == (rhs.zheng*rhs.fenmu+rhs.fenzi)*fenmu;

}

private static int gcd(int a,int b) {

if(b==0) return a;

return gcd(b,a%b);

}

public String toString() {

String s=new String();

if(fenzi==0) s=zheng+"";

else if(zheng==0) s=fenzi+"/"+fenmu;

else s=zheng+"'"+fenzi+"/"+fenmu;

return s;

}

//命令行传入参数转换为整型

public static int toInt(String s) {

int ans=0;

for(int i=0;i

ans=ans*10+s.charAt(i)-'0';

}

return ans;

}

public static BasicWork toBasicWork(String str) {

BasicWork temp = new BasicWork();

ArrayList ary = new ArrayList();

int tmp = 0;

for(int i = 0; i < str.length(); i++) {

if(str.charAt(i) >= '0' && str.charAt(i) <= '9') tmp = tmp*10+str.charAt(i)-'0';

else {

ary.add(tmp);

tmp = 0;

}

}

ary.add(tmp);

if(ary.size() == 1) {

temp.zheng = ary.get(0);

temp.fenzi = 0;

temp.fenmu = 1;

}

else if(ary.size() == 2) {

temp.zheng = 0;

temp.fenzi = ary.get(0);

temp.fenmu = ary.get(1);

}

else {

temp.zheng = ary.get(0);

temp.fenzi = ary.get(1);

temp.fenmu = ary.get(2);

}

return temp;

}

}

六、测试运行

测试-n -r

测试-e -a

这里选用刚刚生成的题目文件和答案文件，答案文件修改几个答案以验证功能

生成10000条题目

经验证，功能正确实现。

七、项目小结