10.9

java小学生四则运算出题

生成30道小学四则运算题目的 “软件”

package jieduan3;
import java.util.*;
public class suan2 {
    public String P[]=new String[30];
    public int Q[]=new int[30];
    public int Temp[]=new int[30];
    //static Set<Character> brace = new HashSet<>();
    public static void main(String[] args) {
        // TODO 自动生成的方法存根


                Scanner cin=new Scanner(System.in);
                suan2 a=new suan2();
                suan2 s=new suan2();
                int n1,n2;
                //Stack<Integer> stack=new Stack<Integer>();
                for(int i=0;i<30;i++)
                {
                    String A=a.string(a,3,i);
                    System.out.println(A);
//                    int answ;
//                    String A=a.string(a,4,i);
//                    System.out.println(A+"=");
//                    a.Q[i]=calculate((A+"#"));
//                    answ=cin.nextInt();
//                    if(answ==a.Q[i]) {System.out.println("正确!");a.Temp[i]=1;}
//                    else {System.out.println("错误！");a.Temp[i]=0;}
                }
            }
            public String string(suan2 a,int n,int i)
            {
                String A;
                int Temp=0;
                for(;;)
                {
                    A=a.suanf(n, i);
                    for(int j=0;j<i;i++)
                    {
                        if(A.equals(a.P[j]))
                        {
                            Temp=1;
                            break;
                        }
                    }
                    if(Temp==0) break;
                }
                return A;
            }
            public  int random1(int a)
            {
                Random ran1 = new Random();
                return (ran1.nextInt(a)+1);
            }
            public  char random2()
            {
                Random ran1 = new Random();
                int a=ran1.nextInt(4);
                char b;
                if(a==1) b='+';
                else if(a==2) b='-';
                else if(a==3) b='*';
                else b='/';
                return b;
            }
            public int answer1(int a,char b,int c)
            {
                int P;
                if(b=='+') P=a+b;
                else if(b=='-') P=a-b;
                else if(b=='*') P=a*b;
                else P=a/b;
                return P;
            }
            public String suanf(int AB,int AB1)
            {
                int n;
                if(AB==2) n=100;
                else if(AB==3) n=1000;
                else n=1000;
                int a[]=new int[5];
                char b[]=new char[4];
                for(int i=0;i<5;i++)
                {
                    a[i]=random1(n)+1;
                }
                for(int i=0;i<4;i++)
                {
                    b[i]=random2();
                }
                String A=String.valueOf(a[0])+String.valueOf(b[0]);
                String B=String.valueOf(a[1])+String.valueOf(b[1]);
                String C=String.valueOf(a[2])+String.valueOf(b[2]);
                String D=String.valueOf(a[3])+String.valueOf(b[3]);
                String E=String.valueOf(a[4]);
                if(AB==4)
                {
                    int a1=random1(5);
                    int a2=random1(5);
                    while(a1==a2||a1==5||a2==1)
                    {
                        a1=random1(5);
                        a2=random1(5);
                    }
                    if(a1>a2) {int a3=a2;a2=a1;a1=a3;}
                    switch(a1)
                    {
                    case 0:
                    case 1:A=String.valueOf('(')+A;break;
                    case 2:B=String.valueOf('(')+B;break;
                    case 3:C=String.valueOf('(')+C;break;
                    case 4:D=String.valueOf('(')+D;break;
                    }
                    switch(a2)
                    {
                    case 2:B=String.valueOf(a[1])+String.valueOf(')')+String.valueOf(b[1]);break;
                    case 3:C=String.valueOf(a[2])+String.valueOf(')')+String.valueOf(b[2]);break;
                    case 4:D=String.valueOf(a[3])+String.valueOf(')')+String.valueOf(b[3]);break;
                    case 5:E=String.valueOf(a[4])+String.valueOf(')');break;
                    }
                }
                if(AB==2) P[AB1]=A+E;
                else if(AB==3) P[AB1]= A+B+C+E;
                else P[AB1]=A+B+C+D+E;
                return P[AB1];
            }
//            public String[] houzhui(String str) {
//                String s="";
//                char a[]=new char[100];
//                String answer[]=new String [100];
//                int top=-1,j=0;
//                for(int i=0;i<str.length();i++)
//                {
//                    if("0123456789.".indexOf(str.charAt(i))>=0)
//                    {
//                        s="";
//                        for(;i<str.length()&&"0123456789.".indexOf(str.charAt(i))>=0;)
//                        {
//                            s=s+str.charAt(i);
//                        }
//                        i--;
//                        answer[j]=s;
//                        j++;
//                    }
//                    else if("(".indexOf(str.charAt(i))>=0)
//                    {
//                        top++;
//                        a[top]=str.charAt(i);
//                    }
//                    else if(")".indexOf(str.charAt(i))>=0)
//                    {
//                        for(;;)
//                        {
//                            if(a[top]!=')')
//                            {
//                                answer[j]=a[top]+"";
//                                j++;
//                                top--;
//                            }
//                            else
//                            {
//                                top--;
//                                break;
//                            }
//                        }
//                    }
//                    else if("*/.".indexOf(str.charAt(i))>=0)
//                    {
//                        if(top==-1)
//                        {
//                            top++;
//                            a[top]=str.charAt(i);
//                        }
//                        else
//                        {
//                            if("*/.".indexOf(a[top])>=0)
//                            {
//                                answer[j]=a[top]+"";
//                                j++;
//                                a[top]=str.charAt(i);
//                            }
//                            else if("(".indexOf(a[top])>0)
//                            {
//                                top++;
//                                a[top]=str.charAt(i);
//                            }
//                            else if("+-".indexOf(a[top])>=0)
//                            {
//                                top++;
//                                a[top]=str.charAt(i);
//                            }
//                        }
//                    }
//                    else if("+-".indexOf(str.charAt(i))>=0)
//                    {
//                        if(top==-1)
//                        {
//                            top++;
//                            a[top]=str.charAt(i);
//                        }
//                        else
//                        {
//                            if("*/".indexOf(a[top])>=0)
//                            {
//                                answer[j]=a[top]+"";
//                                j++;
//                                a[top]=str.charAt(i);
//                            }
//                            else if ("(".indexOf(a[top])>=0)
//                            {
//                                top++;
//                                a[top]=str.charAt(i);
//                            }
//                            else if ("+-".indexOf(a[top])>=0)
//                            {
//                                answer[j]=a[top]+"";
//                                j++;
//                                a[top]=str.charAt


//                                a[top]=str.charAt(i);
//                            }
//                        }
//                    }
//                }
//                for(;top!=-1;)
//                {
//                    answer[j]=a[top]+"";
//                    j++;
//                    top--;
//                }
//                return answer
//            }
//            public int answer(String str)
//            {
//                Stack<Integer> stack1=new Stack<Integer>();
//                Stack<Character> stack2=new Stack<Character>();
//                stack2.add('#');
//                String a[]=str.split("+|-|*|/");
//                char b[]=new char[5];
//                int temp=0;
//                for(int i=0;i<str.length();i++)
//                {
//                    if(str.charAt(i)=='+'||str.charAt(i)=='-'||str.charAt(i)=='*'||str.charAt(i)=='/')
//                    {
//                        b[temp]=str.charAt(i);
//                        temp++;
//                    }
//                }
//                for(int i=0;i<(a.length+b.length);i++)
//                {
//                    if(i==1||i%2==1)
//                    {
//                        int bb=new Integer(a[temp]);
//                        stack1.push(bb);
//                    }
//                    else
//                    {
//                        switch(fuhao(stack2.peek(),b[i]))
//                        {
//                            case '<':stack2.push(b[temp]);break;
//                            case '=':stack2.push(b[temp]);break;
//                            case '>':{
//                                int a1;int a2;char a3;
//                                a3=stack2.pop();
//                                a1=stack1.pop();
//                                a2=stack1.pop();
//                                stack1.push(answer1(a1,a3,a2));
//                            }
//                        }
//                    }
//                }
//                return stack1.peek();
//            }
//            public char fuhao(char a,char b)
//            {
//                if((a=='+'||a=='-')&&(b=='*'&&b=='/')) return '<';
//                else if((b=='+'||b=='-')&&(a=='*'&&a=='/')) return '>';
//                else return '=';
//            }
            private static int calculate(String exp){
                // 初始化栈
                Stack<Integer> opStack = new Stack<>();
                Stack<Character> otStack = new Stack<>();
                 
                // 整数记录器  当num是多位时将 num += c 知道遇见运算符
                String num = "";
                for(int i = 0; i < exp.length(); i++){
                    // 抽取字符
                    char c = exp.charAt(i);
                    // 如果字符是数字，则加这个数字累加到num后面
                    if(Character.isDigit(c)){
                        num += c;
                    }
                    // 如果不是数字
                    else{
                        // 如果有字符串被记录，则操作数入栈，并清空
                        if(!num.isEmpty()){
                            int n = Integer.parseInt(num);
                            num = "";
                            opStack.push(n);
                        }
                        // 如果遇上了终结符则退出
                        if(c == '#')
                            break;


        // 如果遇上了+-
                        else if(c == '+' || c == '-'){
                            // 空栈或者操作符栈顶遇到正括号，则入栈
                            if(otStack.isEmpty() || brace.contains(otStack.peek())){
                                otStack.push(c);
                            } else {
                                // 否则一直做弹栈计算，直到空或者遇到正括号为止，最后入栈
                                while(!otStack.isEmpty() && !brace.contains(otStack.peek()))
                                    popAndCal(opStack, otStack);
                                otStack.push(c);
                            }
                        }
                        // 如果遇上*/
                        else if(c == '*' || c == '/'){
                            // 空栈或者遇到操作符栈顶是括号，或者遇到优先级低的运算符，则入栈
                            if(otStack.isEmpty()
                                    || brace.contains(otStack.peek())
                                    || otStack.peek() == '+' || otStack.peek() == '-'){
                                otStack.push(c);
                            }else{
                                // 否则遇到*或/则一直做弹栈计算，直到栈顶是优先级比自己低的符号，最后入栈
                                while(!otStack.isEmpty()
                                        && otStack.peek() != '+' && otStack.peek() != '-'
                                        && !brace.contains(otStack.peek()))
                                    popAndCal(opStack, otStack);
                                otStack.push(c);
                            }
                        } else {
                            // 如果是正括号就压栈
                            if(brace.contains(c))
                                otStack.push(c);
                            else{
                                // 反括号就一直做弹栈计算，直到遇到正括号为止
                                char r = getBrace(c);
                                while(otStack.peek() != r){
                                    popAndCal(opStack, otStack);
                                }
                                // 最后弹出正括号
                                otStack.pop();
                            }
                        }
                    }
                }
                // 将剩下的计算完，直到运算符栈为空
                while(!otStack.isEmpty())
                    popAndCal(opStack, otStack);
                // 返回结果
                return opStack.pop();
            }
            private static void popAndCal(Stack<Integer> opStack, Stack<Character> otStack){
                int op2 = opStack.pop();
                int op1 = opStack.pop();
                char ot = otStack.pop();
                int res = 0;
                switch(ot){
                    case '+':
                        res = op1 + op2;
                        break;
                    case '-':
                        res = op1 - op2;
                        break;
                    case '*':
                        res = op1 * op2;
                        break;
                    case '/':
                        res = op1 / op2;
                        break;
                }
                opStack.push(res);
            }
            private static char getBrace(char brace){
                switch(brace){
                    case ')':
                        return '(';
                    case ']':
                        return '[';
                    case '}':
                        return '{';
                }
                return '#';
            }



    }

这段代码现在只能实现随机出现四则运算，不能进行解答，也没有错题集的功能，每一部分的功能正在努力写。