2021.9.24课堂小测试

题目要求：

对上次四则运算进行修改，使程序更有弹性。

设计思路：

先提示用户输入需求，把用户需求当做方法参数放入方法中，使程序更有弹性。先让用户输入需求，然后用一个函数生成操作数，一个函数生成字符，把这俩个转换为字符串放入二维数组，有题目数量个大循环，在每次循环后，二维数组多一个表达式，同时在每个循环中有判断和前面是否重复的函数。

代码实现：

package xiugaiyunsuan;
import java.util.*;
import java.util.Random;
import java.util.Scanner;

public class xiugai {
public static void main(String[] args) {
System.out.println("请输入要出题目的数量：");
Scanner sc=new Scanner(System.in);
int i=sc.nextInt();
System.out.println("是否需要乘除法，填YES或NO：");
Scanner in=new Scanner(System.in);
String s=in.nextLine();
System.out.println("请输入算式数字范围：");
int c=sc.nextInt();
System.out.println("是否需要括号，填YES或NO");
String u=in.nextLine();
System.out.println("请输入操作数的个数：");
int z=sc.nextInt();
String b=new String("YES");
String x=new String("NO");


if(s.equals(b)) {
if(u.equals(b)) {
String cun1[][]=new String[i][2*z-1];
String cun2[][]=new String[i][2*z-1];
int n;
for(int k=0;k<i;k++) {
int cao[]=new int[z];
String fu[]=new String[z-1];
shengChengCaoZuoShu(c,z,cao);
shengchengzifu(z,fu);
System.out.println(cao[1]+fu[1]+fu[2]);
for(int j=0;j<z-1;j++) {
cun1[k][2*j]=String.valueOf(cao[j]);
cun1[k][2*j+1]=fu[j];
}
cun1[k][2*z-1]=String.valueOf(cao[z-1]);
n=yanZhengTiMu(cun1,i);
if(n==1) {
k--;
continue;}
else cun2[k]=cun1[k];
}
for(int k=0;k<i;k++) {
System.out.println(cun1[k]);
}
}
}
}



public static int yanZhengTiMu(String c[][],int i) { //通过比较字符串确定是否重复
int j;
for(j=0;j<i;j++) {
if(c[i].equals(c[i])) return 1;
}
return 0;
}



public static void shengChengCaoZuoShu(int c,int z,int cao[]) { //i是题目数量，c是算式范围，z是操作数,生成操作数。
Random random=new Random();
int x1;
for(x1=0;x1<z;x1++) {
int a=random.nextInt(c);
cao[x1]=a+1;
}
}

public static void shengchengzifu(int z,String fu[]) { //输出运算符
Random random=new Random();
int x2;
int fu1[]=new int[z-1];
for(x2=0;x2<z-1;x2++) {
int b=random.nextInt(4);
fu1[x2]=b;
if(fu1[x2]==0) {
fu[x2]="+";
}
if(fu1[x2]==1) {
fu[x2]="-";
}
if(fu1[x2]==2) {
fu[x2]="*";
}
if(fu1[x2]==3) {
fu[x2]="/";
}
}
}
}

问题：

运行失败，可能在每次循环中操作数和字符数组都要生成新的，而原来那个没有删除，所以会出错，觉得可以用二维数组代替。

心得：

可以把一个具体的问题不断细化，最后放入不同的方法中，使程序更有弹性。