时间戳

首页 > 技术文章 > Java随机生成题目

Java随机生成题目

china-lishi 2021-12-12 20:54 原文

package oooo;
import java.util.Scanner;
import java.util.Random;
import java.util.Collections;
import java.util.Stack;
public class shu {
public static void main(String [] args)
{
Scanner sc=new Scanner(System.in);
Random rand=new Random();
String []m=new String [100];
int l=0;
double l1=0;
int l2=0;
int n=30;
for(int j=0;;j++)
{
jiemian();
int t=sc.nextInt();
if(t==1)
{
n=sc.nextInt();
}
if(t==2)
{
Two obj=new Two();
obj.setn(n);
String []b=new String [100];
System.out.println("请输入数值范围");
int a=sc.nextInt();
System.out.println("请输入数值范围");
obj.setScope(a);
int i;
for(i=0;i<n;i++)
{
b[i]=chuti(2);
}
for(i=0;i<n;i++)
{
System.out.println(b[i]);
double k=sc.nextDouble();
l1= Calculator.conversion(b[i]);
if(k!=l1)
{
System.out.println("回答错误");
m[l]=b[i];
l++;
l2++;
}
}
double t1=(n-l2)/n;
System.out.println("正确率："+t1);
}
if(t==3)
{
Three obj=new Three();
obj.setn(n);
String []b=new String [100];
System.out.println("请输入数值范围");
int a=sc.nextInt();
obj.setScope(a);
int i;
for(i=0;i<n;i++)
{
b[i]=chuti(4);
}
for(i=0;i<n;i++)
{
System.out.println(b[i]);
double k=sc.nextDouble();
l1= Calculator.conversion(b[i]);
if(k!=l1)
{
System.out.println("回答错误");
m[l]=b[i];
l++;
l2++;
}
}
double t1=(n-l2)/n;
System.out.println("正确率："+t1);
}
if(t==4)
{
Four obj=new Four();
obj.setn(n);
String []b=new String [100];
System.out.println("请输入数值范围");
int a=sc.nextInt();
obj.setScope(a);
int i;
for(i=0;i<n;i++)
{
b[i]=chuti(5);
}
for(i=0;i<n;i++)
{
System.out.println(b[i]);
double k=sc.nextDouble();
l1= Calculator.conversion(b[i]);
if(k!=l1)
{
System.out.println("回答错误");
m[l]=b[i];
l++;
l2++;
}
}
double t1=(n-l2)/n;
System.out.println("正确率："+t1);
}
if(t==5)
{
int i1;
for(i1=0;i1<l2;i1++)
System.out.println(m[i1]);
l2=0;
}
if(t==6)
{
System.out.println("已退出");
break;
}
}
}
public static void jiemian()
{
System.out.println("1:设置参数");
System.out.println("2:小学二年级的题");
System.out.println("3:小学三年级的题");
System.out.println("4:小学四年级的题");
System.out.println("5:错题集");
System.out.println("6:退出");
}
public static String chuti(int o)
{
Random rand=new Random();
String s="";
String s1="yes";
int i,t=0,q=0;
int []a=new int [20];
for(i=0;i<20;i++)
{
a[i]=rand.nextInt(100);
}
if(s1.equals("yes"))
{
for(i=0;i<o;i++)
{
if(o>2&&i==0)
{
s+="(";
t++;
}
if(q==1)
{
if(a[i]%4==0)
{
s+="+";
}
if(a[i]%4==1)
{
s+="-";
}
if(a[i]%4==2)
{
s+="*";
}
if(a[i]%4==3)
{
s+="/";
}
q--;
}
if(q==0)
{
s+=a[i];
q++;
}
if(i==1&&t==1)
s+=")";
}
s+="=";
}
return s;
}

}
class Two{
private int n;//出题个数
int scope=0;//数值范围
int number=0;//操作数个数
public void setn(int a)
{
n=a;
}
public int getn()
{
return n;
}
public int getScope() {
return scope;
}
public void setScope(int scope) {
this.scope = scope;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
}
class Three extends Two{
private int n;//出题个数
int scope=0;//数值范围
int number=0;//操作数个数
}
class Four extends Three{
private int n;//出题个数
int scope=0;//数值范围
int number=0;//操作数个数
}
class Calculator {
private Stack<String> postfixStack = new Stack<String>();
private Stack<Character> opStack = new Stack<Character>();
private int[] operatPriority = new int[] { 0, 3, 2, 1, -1, 1, 0, 2 };
public static double conversion(String expression) {
double result = 0;
Calculator cal = new Calculator();
try {
expression = transform(expression);
result = cal.calculate(expression);
} catch (Exception e) {
return 0.0 / 0.0;
}
// return new String().valueOf(result);
return result;
}
private static String transform(String expression) {
char[] arr = expression.toCharArray();
for (int i = 0; i < arr.length; i++) {
if (arr[i] == '-') {
if (i == 0) {
arr[i] = '~';
} else {
char c = arr[i - 1];
if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == 'E' || c == 'e') {
arr[i] = '~';
}
}
}
}
if(arr[0]=='~'||arr[1]=='('){
arr[0]='-';
return "0"+new String(arr);
}else{
return new String(arr);
}
}
public double calculate(String expression) {
Stack<String> resultStack = new Stack<String>();
prepare(expression);
Collections.reverse(postfixStack);
String firstValue, secondValue, currentValue;
while (!postfixStack.isEmpty()) {
currentValue = postfixStack.pop();
if (!isOperator(currentValue.charAt(0))) {
currentValue = currentValue.replace("~", "-");
resultStack.push(currentValue);
} else {
secondValue = resultStack.pop();
firstValue = resultStack.pop();
firstValue = firstValue.replace("~", "-");
secondValue = secondValue.replace("~", "-");

String tempResult = calculate(firstValue, secondValue, currentValue.charAt(0));
resultStack.push(tempResult);
}
}
return Double.valueOf(resultStack.pop());
}
private void prepare(String expression) {
opStack.push(',');// 运算符放入栈底元素逗号，此符号优先级最低
char[] arr = expression.toCharArray();
int currentIndex = 0;// 当前字符的位置
int count = 0;// 上次算术运算符到本次算术运算符的字符的长度便于或者之间的数值
char currentOp, peekOp;// 当前操作符和栈顶操作符
for (int i = 0; i < arr.length; i++) {
currentOp = arr[i];
if (isOperator(currentOp)) {// 如果当前字符是运算符
if (count > 0) {
postfixStack.push(new String(arr, currentIndex, count));// 取两个运算符之间的数字
}
peekOp = opStack.peek();
if (currentOp == ')') {// 遇到反括号则将运算符栈中的元素移除到后缀式栈中直到遇到左括号
while (opStack.peek() != '(') {
postfixStack.push(String.valueOf(opStack.pop()));
}
opStack.pop();
} else {
while (currentOp != '(' && peekOp != ',' && compare(currentOp, peekOp)) {
postfixStack.push(String.valueOf(opStack.pop()));
peekOp = opStack.peek();
}
opStack.push(currentOp);
}
count = 0;
currentIndex = i + 1;
} else {
count++;
}
}
if (count > 1 || (count == 1 && !isOperator(arr[currentIndex]))) {// 最后一个字符不是括号或者其他运算符的则加入后缀式栈中
postfixStack.push(new String(arr, currentIndex, count));
}

while (opStack.peek() != ',') {
postfixStack.push(String.valueOf(opStack.pop()));// 将操作符栈中的剩余的元素添加到后缀式栈中
}
}
private boolean isOperator(char c) {
return c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')';
}
public boolean compare(char cur, char peek) {// 如果是peek优先级高于cur，返回true，默认都是peek优先级要低
boolean result = false;
if (operatPriority[(peek) - 40] >= operatPriority[(cur) - 40]) {
result = true;
}
return result;
}
private String calculate(String firstValue, String secondValue, char currentOp) {
String result = "";
switch (currentOp) {
case '+':
result = String.valueOf(ArithHelper.add(firstValue, secondValue));
break;
case '-':
result = String.valueOf(ArithHelper.sub(firstValue, secondValue));
break;
case '*':
result = String.valueOf(ArithHelper.mul(firstValue, secondValue));
break;
case '/':
result = String.valueOf(ArithHelper.div(firstValue, secondValue));
break;
}
return result;
}
}

class ArithHelper {
private static final int DEF_DIV_SCALE = 16;
private ArithHelper() {
}
public static double add(double v1, double v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
return b1.add(b2).doubleValue();
}
public static double add(String v1, String v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
return b1.add(b2).doubleValue();
}
public static double sub(double v1, double v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
return b1.subtract(b2).doubleValue();
}
public static double sub(String v1, String v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
return b1.subtract(b2).doubleValue();
}
public static double mul(double v1, double v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
return b1.multiply(b2).doubleValue();
}
public static double mul(String v1, String v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
return b1.multiply(b2).doubleValue();
}
public static double div(double v1, double v2) {
return div(v1, v2, DEF_DIV_SCALE);
}
public static double div(String v1, String v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
return b1.divide(b2, DEF_DIV_SCALE, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
}
public static double div(double v1, double v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
return b1.divide(b2, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
}
public static double round(double v, int scale) {
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
java.math.BigDecimal b = new java.math.BigDecimal(Double.toString(v));
java.math.BigDecimal one = new java.math.BigDecimal("1");
return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
}
public static double round(String v, int scale) {
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
java.math.BigDecimal b = new java.math.BigDecimal(v);
java.math.BigDecimal one = new java.math.BigDecimal("1");
return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
}
}

推荐阅读