个人工作流程计应192六组石帅康

PSP计划表

PSP阶段	预计花费时间(小时)	实际花费时间
计划	3	2
明确需求和其他相关因素，估计每个阶段的时间成本	3	2
开发	30	30
需求分析	2	2
代码规范	1	1
具体设计	2	2
具体编码	4	4
代码复审	1	2
测试（自测、修改代码、提交修改）	2	4

需求分析：

　　计算

       显示对错

       统计正确率

具体设计　　

       产生100以内的正整数

　　产生+-运算符

       输出结果

代码实现：

public class Create {
public int algorithm(String s) {
//放数字
Stack<Integer> stack1 = new Stack<>();
//放操作符
Stack<String> stack2 = new Stack<>();
//存放运算符优先级
HashMap<String, Integer> hashmap = new HashMap<>();
hashmap.put("(", 0);
hashmap.put("+", 1);
hashmap.put("-", 1);
hashmap.put("*", 2);
hashmap.put("÷", 2);

for (int i = 0; i < s.length();) {
//设置可变长的字符串
StringBuffer digit = new StringBuffer();
//将式子字符串切割为c字符
char c = s.charAt(i);
//判断字符是否为10进制数字,将一个数加入digit
while (Character.isDigit(c)) {
digit.append(c);
i++;
c = s.charAt(i);
}
//当前digit里面已经无数字，即当前处理符号
if (digit.length() == 0){
switch (c) {
case '(': {
stack2.push(String.valueOf(c));
break;
}
//遇到右括号了计算，因为（的优先级最高
case ')': {
String stmp = stack2.pop();
while (!stack2.isEmpty() && !stmp.equals("(")) {
int a = stack1.pop();
int b = stack1.pop();
int sresulat = calculate(b, a, stmp);
if(sresulat<0)
return -1;
stack1.push(sresulat);
//符号指向下一个计算符号
stmp = stack2.pop();
}
break;
}
case '=': {
String stmp;
while (!stack2.isEmpty()) {
stmp = stack2.pop();
int a = stack1.pop();
int b = stack1.pop();
int sresulat = calculate(b, a, stmp);
if(sresulat<0)
return -1;
stack1.push(sresulat);
}
break;
}

default: {
String stmp;
while (!stack2.isEmpty()) {
stmp = stack2.pop();
//比较优先级
if (hashmap.get(stmp) >= hashmap.get(String.valueOf(c))) {
int a = stack1.pop();
int b = stack1.pop();
int sresulat =calculate (b, a, stmp);
if(sresulat<0)
return -1;
stack1.push(sresulat);
}
else {
stack2.push(stmp);
break;
}

}
//将符号压入符号栈
stack2.push(String.valueOf(c));
break;
}
}
}
else {
//处理数字
stack1.push(Integer.valueOf(digit.toString()));
continue;
}
i++;
}
//返回栈底得到答案
return stack1.peek();
}
private int calculate(int a, int b, String stmp) { //计算a stmp b的值
int res = 0;
char s = stmp.charAt(0);
switch (s) {
case '+': {
res = a + b;
break;
}
case '-': {
//判断是否产生负数
res = a - b;
break;
}
case '*': {
res = a * b;
break;
}
case '÷': {
if(b==0)
return -1;
//判断是否产生小数
else if(a%b!=0)
return -2;
else
res = a / b;
break;
}
}
return res;
}
这是算法部分

public String createProblem(){ //产生整数式子
Random r = new Random();
String[] opertor = {"+","-","*","÷"};
//操作符的个数
int operatorNum = 3+r.nextInt(3);
//新建数组来保存操作数
int[] number = new int[operatorNum+1];
//操作符的下标
int[] arr = index(operatorNum);
String s = new String();

for(int j=0;j<operatorNum+1;j++){
number[j] = r.nextInt(101);
}



//如果flag=0，则该式子加括号，如果flag=1，则该式子不加括号（自己设定）
int flag = r.nextInt(2);

switch (operatorNum){
case 3:{
if(flag == 0){
s = "(" + number[0] + opertor[arr[0]] + number[1] + ")" +opertor[arr[1]]+ "(" + number[2] + opertor[arr[2]] + number[3] + ")";
}
else{
s = number[0] + opertor[arr[0]] + number[1]+opertor[arr[1]]+number[2] + opertor[arr[2]] + number[3] ;
}
break;
}
case 4:{
if(flag ==0){
s = "(" + "(" + number[0] + opertor[arr[0]] + number[1] + ")" + opertor[arr[1]] + number[2] + ")" + opertor[arr[2]] + "(" + number[3] + opertor[arr[3]] + number[4] + ")";
}
else{
s = number[0] + opertor[arr[0]] + number[1] +opertor[arr[1]] + number[2] + opertor[arr[2]] + number[3] + opertor[arr[3]] + number[4] ;
}
break;
}
case 5:{
if(flag ==1){
s = "(" + "(" + number[0] + opertor[arr[0]]+number[1]+")" + opertor[arr[1]] + number[2] + ")" +opertor[arr[2]]+ "(" + "(" + number[3] + opertor[arr[3]] + number[4] + ")" + opertor[arr[4]] + number[5] + ")";
}
else{
s = number[0] + opertor[arr[0]]+number[1]+ opertor[arr[1]] + number[2] +opertor[arr[2]] + number[3] + opertor[arr[3]] + number[4] + opertor[arr[4]] + number[5] ;
}
break;
}
}


s+="=";
Calculator calculator = new Calculator();
int answer = calculator.algorithm(s);

//判断式子是否符合要求，凡是返回负数的就是不合格的
if(answer>=0){
s+=answer;
}else {
//递归
return createProblem();
}

return s;

}


public int[] index(int n){ //产生操作符的下标数组
Random random = new Random();
int similar=0;
int[] a = new int[n];
for(int j=0;j<n;j++){
a[j] = random.nextInt(4);
}
for(int j=1;j<n;j++){
if(a[0]==a[j]) similar++;
}
//保证一个式子里至少有2个不同的操作符
if(similar==n-1) return index(n);
else {
return a;
}

}

}
产生整数式子

public class ProperFraction {
public String createProblem(){
Random r = new Random();
String[] operator = {"+","-"};
int operatorCount = 3+r.nextInt(3);


int[] index = index2(operatorCount);

int sumx = 1+r.nextInt(10);
int sumy = 1+r.nextInt(20);
int g = maxG(sumx,sumy);
sumx/=g;
sumy/=g;

int[] fenshu = huajian(sumx, sumy);
sumx = fenshu[0];
sumy = fenshu[1];
//第一个数
String s=sumx+"/"+sumy;

for(int i=0;i<operatorCount;i++){
int numx = r.nextInt(10);
int numy = 1+r.nextInt(20);
String currentOpreator = operator[index[i]];
fenshu = huajian(numx, numy);
numx = fenshu[0];
numy = fenshu[1];
if(currentOpreator.equals("+")) {
fenshu = huajian(sumx * numy + sumy * numx, sumy * numy);
sumx = fenshu[0];
sumy = fenshu[1];
}
else { //减法
while(sumx*numy-sumy*numx<0)
{
numx=r.nextInt(10);
numy=1+r.nextInt(20);
g=maxG(numx,numy);
numx/=g;
numy/=g;
}
sumx=sumx*numy-sumy*numx;
sumy=sumy*numy;
}
s+=currentOpreator+numx+"/"+numy;
}

g = maxG(sumx,sumy);
sumx/=g;
sumy/=g;

if(sumx==0) s+="="+sumx;
else if(sumx==1&&sumy==1) s+="="+sumx;
else s+="="+sumx+"/"+sumy;

return s;

}

public int maxG(int fenzi,int fenmu)//求最大公因数
{
while (fenmu != 0) {
int r = fenzi % fenmu;
fenzi = fenmu;
fenmu = r;
}
return fenzi;
}

public int[] index2(int n) {
Random random = new Random();
int similar = 0;
int[] a = new int[n];
for (int j = 0; j < n; j++) {
a[j] = random.nextInt(2);
}
for (int j = 1; j < n; j++) {
if (a[0] == a[j]) similar++;
}
if (similar == n - 1) return index2(n);
else {
return a;
}

}
public int[] huajian(int fenzi, int fenmu){
Random r = new Random();
while (fenzi >= fenmu) {
fenzi = 1 + r.nextInt(10);
fenmu = 1 + r.nextInt(20);
int g = maxG(fenzi, fenmu);
fenzi = fenzi / g;
fenmu = fenmu / g;
}
int[] fenshu = new int[2];
fenshu[0] = fenzi;
fenshu[1] = fenmu;
return fenshu;
}
}

实现效果：