20162307 结对编程第二周总结

第二周总结博客

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

需求分析（描述自己对需求的理解，以及后续扩展的可能性）

1.随机生成题目数
2.整数运算
3.正确判题，如果错误，显示正确答案
4.统计正确率
5.支持真分数

设计思路（同时输出UML类图）

实现过程中的关键代码解释

随机生成运算：

public void setFormula() {
this.a = (int) (Math.random () * 100);
this.b = (int) (Math.random () * 100);
switch ((int) (Math.random () * 4)) {
case 0:
op = '+';
result = a + b;
break;
case 1:
op = '-';
result = a - b;
break;
case 2:
op = '*';
result = a * b;
break;
case 3:
op = '/';
while (this.b == 0) {
this.b = (int) (Math.random () * 100);
}
if (a % b == 0)
result = (a / b);
else if (a % b != 0)
result = (int)(a / b);
System.out.printf ("%3.2f",result);
}
统计正确率及判题

if((ex.resultanswer&&ex.result2.isInteger())||ex.result1answer1||ex.result2.equals(answer1)){
correct_num++;
System.out.println("正确，很棒啊，再接再厉");
}
else
System.out.println("错啦,正确答案是："+ex.result+" 继续加油哦");

accuracy = (float)correct_num/num;

System.out.printf("不错嘛，共%d题,做对%d题,正确率：%.2f，继续加油啊",num,correct_num,accuracy*100 );
System.out.println('%');
System.out.println("想要学的更好就输入你还想做的题目数，如果想休息了输入0");
num=scan.nextInt();
if(num==0) flag =0;
真分数部分代码

Fraction reduce_deno(Fraction f){ //约分
int deno = GCD(f.numerator, f.denominator); //GCD求最大公倍数
f.numerator=f.numerator/deno;
f.denominator=f.denominator/deno;
return f;
}
Fraction reduce_deno(int a,int b){
a = a/GCD(a, b);
b = b/GCD(a, b);
Fraction f = new Fraction();
f.numerator = a;
f.denominator = b;
return f;
}
Fraction[] same_deno(Fraction f1,Fraction f2){ //通分
Fraction [] f = new Fraction[2];
f[0]=new Fraction();
f[1]=new Fraction();
f[0].denominator =LCM(f1.denominator, f2.denominator); //LCM求最小公约数
f[1].denominator = LCM(f1.denominator, f2.denominator);
f[0].numerator = f1.numerator(LCM(f1.denominator, f2.denominator)/f1.denominator);
f[1].numerator = f2.numerator(LCM(f1.denominator, f2.denominator)/f2.denominator);
return f;

}

int GCD(int a,int b){
int c;
while(a%b!=0){
c=a%b;
a=b;
b=c;
}
return b;
}

int LCM(int a, int b){
return a*b/GCD(a,b);
}

运行过程截图

代码托管地址

20162307

遇到的困难及解决方法

关于除法我们在测试中一直都在出错

关于它的代码是

case 3:
op = '/';
while (this.b == 0) {
this.b = (int) (Math.random () * 100);
}
if (a % b == 0)
result = (a / b);
else if (a % b != 0)
result = (int)(a / b);
System.out.printf ("%3.2f",result);
a的值不是整数所以改进了代码

result1 = (float) (a / c);
分母不能为0，所以再次定义一个随机数c（在1至100之间）

this.c = generator.nextInt(99)+1;
改进之后的代码

case 3:
op = '/';
if (a % c == 0)
result = (a / c);
else
result = (int) (a/c);
result1 = (float) (a / c);
result2.setter ( a, c );
result2 = result2.reduce_deno ( result2 );
break;

indexOf与lastindexOf的区别

indexOf：
语法：

stringObject.indexOf(searchvalue,fromindex)

参数	描述
searchvalue	必需。规定需检索的字符串值。
fromindex	可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的首字符开始检索。

说明：
该方法将从头到尾地检索字符串 stringObject，看它是否含有子串 searchvalue。开始检索的位置在字符串的 fromindex 处或字符串的开头（没有指定 fromindex 时）。如果找到一个 searchvalue，则返回 searchvalue 的第一次出现的位置。stringObject 中的字符位置是从 0 开始的。

例子：

var str="Hello world!"
document.write(str.indexOf("Hello") + "
")
document.write(str.indexOf("World") + "
")
document.write(str.indexOf("world"))

输出的结果：

0
-1
6

lastindexOf:
语法：

stringObject.lastIndexOf(searchvalue,fromindex)

参数	描述
searchvalue	必需。规定需检索的字符串值。
fromindex	可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的最后一个字符处开始检索。

例子：

var str="Hello world!"
document.write(str.lastIndexOf("Hello") + "
")
document.write(str.lastIndexOf("World") + "
")
document.write(str.lastIndexOf("world"))

输出的结果：

0
-1
6

idea 出错

总是会出现打开idea没有bin、src、test、 .idea。的目录，只剩下

解决：打开苹果的终端

将本项目彻底删除，再重新git，一般出现这种情况，都是 .idea这个文件出错

变成混合运算

我和我的小伙伴想了好久，我们无法随机生成中缀表达式，但是我们可以随机生成后缀表达式，试着把后缀变为中缀，但是写完代码后还是失败了

public class Change {
//后缀转中缀
/**
* 提前将符号的优先级定义好
*/

private static final Map <Character, Integer> basic = new HashMap <Character, Integer> ();

static {
basic.put ( '-', 0 );
basic.put ( '+', 0 );
basic.put ( '*', 1 );
basic.put ( '/', 1 );
}

public void test() {
String s3 = new String ();
String a = toSuffix ( s3 ); //传入一串随机生成的后缀表达式
System.out.println ( a );
System.out.println ( new dealEquation ( a ) );
}

/**
* 将后缀表达式转化为中缀表达式
*/
public String toSuffix(String infix) {
List queue = new ArrayList (); //定义队列用于存储运算符以及最后的中缀表达式
List stack = new ArrayList <> (); //定义栈用于存储数字最后stack中会被弹空

char[] charArr = infix.trim ().toCharArray (); //字符数组用于拆分数字或符号
String standard = "/+-"; //判定标准将表达式中会出现的运算符写出来
char ch = '&'; //在循环中用来保存字符数组的当前循环变量的这里仅仅是初始化一个值没有意义
int len = 0; //用于记录字符长度【例如1002,则记录的len为3 到时候截取字符串的前三位就是数字】
for (int i = 0; i < charArr.length; i++) { //开始迭代

ch = charArr[i]; //保存当前迭代变量
if (Character.isDigit ( ch )) { //如果当前变量为数字
len++;
} else if (Character.isLetter ( ch )) { //如果当前变量为字母
len++;
} else if (Character.isSpaceChar ( ch )) { //如果当前变量为空格支持表达式中有空格出现
if (len > 0) { //若为空格代表一段结束，就可以往队列中存入了【例如100 * 2 100后面有空格就可以将空格之前的存入队列了】
stack.add ( String.valueOf ( Arrays.copyOfRange ( charArr, i - len, i ) ) ); //往栈存入截取的数字
len = 0; //长度置空
}
continue; //如果空格出现，则一段结束跳出本次循环
} else if (standard.indexOf ( ch ) != -1) { //如果是上面标准中的任意一个符号
if (len > 0) { //长度也有
stack.add ( String.valueOf ( Arrays.copyOfRange ( charArr, i - len, i ) ) ); //说明符号之前的可以截取下来做数字
len = 0; //长度置空
}
if (Character.isDigit ( ch )) { //如果是数字
stack.add ( String.valueOf ( ch ) ); //将数字放入栈中
continue; //跳出本次循环继续找下一个位置
}
if (!stack.isEmpty ()) { //如果栈不为empty
int size = stack.size () - 1; //获取栈的大小-1 即代表栈最后一个元素的下标
boolean flag = false; //设置标志位
while (size >= 0 && standard.indexOf ( ch ) != -1) { //若当前ch为符号，则栈里元素从栈顶弹出两个数字
for (int k = 0; k < 3; k++) {
stack.remove ( stack.size () - 1 );
size--; //size-- 保证下标永远在栈最后一个元素【栈中概念：指针永远指在栈顶元素】
flag = true; //设置标志位为true 表明一直在取（）中的元素
}
while (size >= 0 && !flag && basic.get ( queue.get ( size ) ) >= basic.get ( ch )) { //若取得不是（）内的元素，并且当前栈顶元素的优先级>=对比元素那就出栈插入队列
stack.add ( String.valueOf ( queue.remove ( size ) ) ); //同样此处也是remove()方法，既能得到要获取的元素，也能将栈中元素移除掉
size--;
}
}
}
if (i == charArr.length - 1) { //如果已经走到了后缀表达式的最后一位
if (len > 0) { //如果len>0 就截取数字
stack.add ( String.valueOf ( Arrays.copyOfRange ( charArr, i - len + 1, i + 1 ) ) );
}
int size = stack.size () - 1; //size表示栈内最后一个元素下标
while (size >= 0) { //一直将栈内符号全部出栈并且加入队列中【最终的中缀表达式是存放在队列中的，而栈内最后会被弹空】
stack.add ( String.valueOf ( stack.remove ( size ) ) );
size--;
}
}

}

}
return queue.stream ().collect ( Collectors.joining ( "," ) );//将队列中元素以,分割返回字符串
}

public String dealEquation(String equation){
String [] arr = equation.split(","); //根据, 拆分字符串
List list = new ArrayList(); //用于计算时存储运算过程的集合，例如list中当前放置100 20 5 / 则取出20/5 最终将结果4存入list 此时list中结果为 100
for (int i = 0; i < arr.length; i++) { //此处就是上面说的运算过程，因为list.remove的缘故，所以取出最后一个数个最后两个数都是size-2
int size = list.size();
switch (arr[i]) {
case "+": double a = Double.parseDouble(list.remove(size-2))+ Double.parseDouble(list.remove(size-2)); list.add(String.valueOf(a)); break;
case "-": double b = Double.parseDouble(list.remove(size-2))- Double.parseDouble(list.remove(size-2)); list.add(String.valueOf(b)); break;
case "": double c = Double.parseDouble(list.remove(size-2)) Double.parseDouble(list.remove(size-2)); list.add(String.valueOf(c)); break;
case "/": double d = Double.parseDouble(list.remove(size-2))/ Double.parseDouble(list.remove(size-2)); list.add(String.valueOf(d)); break;
default: list.add(arr[i]); break; //如果是数字直接放进list中
}
}
return list.size() == 1 ? list.get(0) : "运算失败" ;

}
}

对结对的小伙伴做出评

合作的很好，我们互相帮助，有了困难问题一起找解决方法，不停的实践、尝试，直到达到我们的要求
我们的水平有限，所以很多老师要求的我们做不出来，但是我们每一个都尝试了，比如复杂的混合运算，多语言支持，输出文件。

posted @ 2017-05-21 21:37 张韵琪阅读(204) 评论(1) 收藏举报

Java小组