四则运算网页版

最新推荐文章于 2020-08-04 19:27:44 发布
最新推荐文章于 2020-08-04 19:27:44 发布
阅读量127 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/wangzongze/p/5360853.html
版权

在第三次实验的基础上，老师又对四则运算提出了新的要求，实现网页版或安卓的四则运算。

结对开发伙伴：

姓名：程思敏

　　博客名：鹏程万里之思

　　博客地址链接：http://home.cnblogs.com/u/pengchengwanli/

网页四则运算要求：

1、生成的题目中计算过程不能产生负数，也就是说算术表达式中如果存在e1-e2的子表达式，那么结果大于等于0；

2、生成的题目中如果存在形式如e1/e2的子表达式，那么其结果应该是真分数。

3、每道题目中出现的运算符个数不超过3个，括号不做详细要求。

设计思路：

1.将原先程序中的结构体改成class文件，依次生成calculator.java、arithmetic.java、Formula.java、subject.java文件。

2.编写MyHtml.html文件，在页面上显示出题数、上下限文本框，以及四个复选框控制出题条件。

3.在MyHtml.html页面上点击确认键，跳转到index.jsp文件，调用calculator.java文件中的函数，产生各道算式，在对应的文本框中输入答案。

4.在index.jsp页面上点击提交按钮，跳转到Myjsp.jsp文件，显示答题结果。

程序代码：

package Calculator;
import java.util.*;
import Calculator.arithmetic;
import Calculator.subject;
import Calculator.Formula;
import java.lang.*;

public class calculator {
    static int N=100;
    //public int length = 0;//运算数个数
    static int fuh;//表示运算符的数（0、1、2、3分别代表+、-、*、/）
    static subject sub[]=new subject[N];//所有算式
    static int lpoint1;//内层左括号的位置
    static int rpoint1;//内层右括号的位置
    static int lpoint2;//外层左括号的位置
    static int rpoint2;//外层右括号的位置
    static Formula Formul[]=new Formula[N];    //定义一个字符串数组
    static int Flength;    //字符串数组长度
    static int i, j;
    static int Result;    //算式的运算结果
    static int dataS[]=new int[N];    //存储算式中的数
    static String fuhaoS[]=new String[N];    //存储算式中的符号
    static int count;    //记录答对题数
    static int CountNum=-1;    //记录对每道题求解
    static int CountStr=-1;    //记录每道题
    static int low;    //算式数值范围的最小值
    static int high;    //算式数值范围的最大值
    static int MulAndDiv;   //是否有乘除
    static int Bracket;     //是否有括号
    static int Negative;       //是否有负数
    static int Remainder;       //是否有余数
    //static int IsRep;       //是否重复
    static int Results[]= new int[N];      //正确结果数组
    //public subject buffer[] = new subject[N];     //缓冲区数组
    static String buffer[]=new String[N];
    static int LENGTH[]=new int[N];        //记录算式的长度
    static int number;    //题目数量
    //将算式转化为string数组
    public void ToString(int geti, int length)
    {
        Flength = -1;
        for (j = 0; j < length; j++)
        {
            if (sub[geti].arith[j].left2 != "")
            {
                Flength =Flength+ 1;
                Formul[Flength].str = sub[geti].arith[j].left2;
            }
            if (sub[geti].arith[j].left1 != "")
            {
                Flength =Flength+ 1;
                Formul[Flength].str = sub[geti].arith[j].left1;
            }
            Flength =Flength+ 1;
            Formul[Flength].str = String.valueOf(sub[geti].arith[j].member);
            Formul[Flength].data = sub[geti].arith[j].member;
            if (sub[geti].arith[j].right1 != "")
            {
                Flength =Flength+ 1;
                Formul[Flength].str = sub[geti].arith[j].right1;
            }
            if (sub[geti].arith[j].right2 != "")
            {
                Flength =Flength+ 1;
                Formul[Flength].str = sub[geti].arith[j].right2;
            }
            if (sub[geti].arith[j].fuhao != "")
            {
                Flength =Flength+ 1;
                Formul[Flength].str = sub[geti].arith[j].fuhao;
            }
        }
        String bstr="";
        for(i=0;i<Flength;i++)
        {
            bstr=bstr+Formul[i].str;
        }
        CountStr+=1;
        buffer[CountStr]=bstr;
    }
    
    //比较优先级
    public String Precede(String Fuhao1, String Fuhao2)
    {
        String FuResult="";    //返回优先级关系">"、"<"、"="
        if (Fuhao1 == "+")
        {
            if (Fuhao2 == "+" || Fuhao2 == "-" || Fuhao2 == ")" || Fuhao2 == "#")
            {
                FuResult = ">";
            }
            else
            {
                FuResult = "<";
            }
        }
        if (Fuhao1 == "-")
        {
            if (Fuhao2 == "+" || Fuhao2 == "-" || Fuhao2 == ")" || Fuhao2 == "#")
            {
                FuResult = ">";
            }
            else
            {
                FuResult = "<";
            }
        }
        if (Fuhao1 == "*")
        {
            if (Fuhao2 == "(")
            {
                FuResult = "<";
            }
            else
            {
                FuResult = ">";
            }
        }
        if (Fuhao1 == "/")
        {
            if (Fuhao2 == "(")
            {
                FuResult = "<";
            }
            else
            {
                FuResult = ">";
            }
        }
        if (Fuhao1 == "(")
        {
            if (Fuhao2 == ")")
            {
                FuResult = "=";
            }
            else
            {
                FuResult = "<";
            }
        }
        if (Fuhao1 == ")")
        {
            FuResult = ">";
        }
        if (Fuhao1 == "#")
        {
            if (Fuhao2 == "#")
            {
                FuResult = "=";
            }
            else
            {
                FuResult = "<";
            }
        }
        return FuResult;
    }
    
    //两个数运算
    public int Operate(int num1, String theta, int num2)
    {
        int InResult;    //返回运算结果
        if (theta == "+")
        {
            InResult = num1 + num2;
        }
        else if (theta == "-")
        {
            InResult = num1 - num2;
        }
        else if (theta == "*")
        {
            InResult = num1*num2;
        }
        else
        {
            InResult = num1 / num2;
        }
        return InResult;
    }
    
    //表达式求值
    public int ValueResult(int geti, int length)
    {
        int i;
        Flength = 0;
        String PResult;    //优先级比较结果
        String theta;    //出栈符号
        int num1, num2;    //出栈运算数
        int dalength=0;    //算式数据数组的长度
        int fulength=0;    //算式符号数组的长度
        ToString(geti, length);
        
        Formul[Flength].str = "#";
        //InitStack(OPND);
        //fuInitStack(OPTR);
        //fuPush(OPTR, "#");
        fuhaoS[fulength]="#";
        
        for (i = 0; i <= Flength; i++)
        {
            if (Formul[i].str == "#")
            {
                while (fuhaoS[fulength]!= "#")
                {
                    PResult = Precede(fuhaoS[fulength], Formul[i].str);
                    if (PResult == ">")
                    {
                        //fuPop(OPTR, theta);
                        theta=fuhaoS[fulength];
                        fulength-=1;
                        //Pop(OPND, num2);
                        num2=dataS[dalength];
                        dalength-=1;
                        //Pop(OPND, num1);
                        num1=dataS[dalength];
                        dalength-=1;
                        int num3 = Operate(num1, theta, num2);
                        //Push(OPND, num3);
                        dalength+=1;
                        dataS[dalength]=num3;
                    }
                    else if (PResult == "<")
                    {
                        //fuPush(OPTR, Formul[i].str);
                        fulength+=1;
                        fuhaoS[fulength]=Formul[i].str;
                    }
                    else
                    {
                        //fuPop(OPTR, theta);
                        theta=fuhaoS[fulength];
                        fulength-=1;
                    }
                }
            }
            else if (Formul[i].str == "(" || Formul[i].str == ")" || Formul[i].str == "+" || Formul[i].str == "-" || Formul[i].str == "*" || Formul[i].str == "/")
            {
                PResult = Precede(fuhaoS[fulength], Formul[i].str);
                if (PResult == ">")
                {
                    //fuPop(OPTR, theta);
                    theta=fuhaoS[fulength];
                    fulength-=1;
                    //Pop(OPND, num2);
                    num2=dataS[dalength];
                    dalength-=1;
                    //Pop(OPND, num1);
                    num1=dataS[dalength];
                    dalength-=1;
                    int num3 = Operate(num1, theta, num2);
                    //Push(OPND, num3);
                    dalength+=1;
                    dataS[dalength]=num3;
                    PResult = Precede(fuhaoS[fulength], Formul[i].str);
                    if (PResult == "=")
                    {
                        //fuPop(OPTR, theta); continue;
                        theta=fuhaoS[fulength];
                        fulength-=1;continue;
                    }
                    else
                    {
                        //fuPush(OPTR, Formul[i].str);
                        fulength+=1;
                        fuhaoS[fulength]=Formul[i].str;
                    }
                }
                else if (PResult == "<")
                {
                    //fuPush(OPTR, Formul[i].str);
                    fulength+=1;
                    fuhaoS[fulength]=Formul[i].str;
                }
                else
                {
                    //fuPop(OPTR, theta);
                    theta=fuhaoS[fulength];
                    fulength-=1;
                }
            }
            else
            {
                //Push(OPND, Formul[i].data);
                dalength+=1;
                dataS[dalength]=Formul[i].data;
            }
        }
        return dataS[dalength];
    }
    
    //随机数产生运算符
    String Fuhao(int fuh)
    {
        String fuh0;//返回运算符号
        if (fuh == 0)
            fuh0 = "+";
        else if (fuh == 1)
            fuh0 = "-";
        else if (fuh == 2)
            fuh0 = "*";
        else
            fuh0 = "/";
        return fuh0;
    }
    
    //初始化算式
    public void Init(int geti,int length, int high, int low, int TwoOrFour)
    {
        Random rand = new Random();
        for (j = 0; j < length - 1; j++)
        {
            sub[geti].arith[j].left2 = "";
            sub[geti].arith[j].left1 = "";
            sub[geti].arith[j].right1 = "";
            sub[geti].arith[j].right2 = "";
            sub[geti].arith[j].member = rand.nextInt() % (high - low) + low;
            //无乘除法
            if (TwoOrFour == 2)
            {
                fuh = rand.nextInt() % 2;
            }
            //有乘除法
            if (TwoOrFour == 4)
            {
                fuh = rand.nextInt() % 4;
            }
            sub[geti].arith[j].fuhao = Fuhao(fuh);
        }
        sub[geti].arith[length - 1].left2 = "";
        sub[geti].arith[length - 1].left1 = "";
        sub[geti].arith[length - 1].right1 = "";
        sub[geti].arith[length - 1].right2 = "";
        sub[geti].arith[length - 1].member = rand.nextInt() % (high - low) + low;
        sub[geti].arith[length - 1].fuhao = "=";
        for (j = 0; j < length; j++)
        {
            if (sub[geti].arith[j].right1 == "" || sub[geti].arith[j].right1 == ")")
            {
                if (sub[geti].arith[j].fuhao == "/"&&sub[geti].arith[j].left2 == ""&&sub[geti].arith[j].left1 == ""&&sub[geti].arith[j].right2 == "")
                {
                    if (sub[geti].arith[j + 1].fuhao == "/"&&sub[geti].arith[j + 1].left2 == ""&&sub[geti].arith[j + 1].left1 == ""&&sub[geti].arith[j + 1].right1 == ""&&sub[geti].arith[j + 1].right2 == "")
                    {
                        sub[geti].arith[j].left1 = "(";
                        sub[geti].arith[j + 1].right1 = ")";
                        j +=1;
                    }
                }
            }
        }
    }
    /*
    //输出函数
    public void Output(int geti, int length)
    {
        for (j = 0; j < length; j++)
        {
            //cout << sub.arith[j].left2 << sub.arith[j].left1 << sub.arith[j].member << sub.arith[j].right1 << sub.arith[j].right2 << sub.arith[j].fuhao;
            System.out.print(sub[geti].arith[j].left2);
            System.out.print(sub[geti].arith[j].left1);
            System.out.println(sub[geti].arith[j].member);
            System.out.print(sub[geti].arith[j].right1);
            System.out.print(sub[geti].arith[j].right2);
            System.out.print(sub[geti].arith[j].fuhao);
        }
        //cout << endl;
    }
    */
    //括号的产生
    public int Bracket(int geti, int length)
    {
        Random rand = new Random();
        int check = 0;
        if (length > 2)
        {
            int floor = rand.nextInt() % 2 + 1;//产生括号的层数
            if (floor == 1)
            {
                lpoint1 = rand.nextInt() % (length - 1);//产生左括号的位置
                rpoint1 = lpoint1 + rand.nextInt() % (length - 1 - lpoint1);//产生右括号的位置
                if (lpoint1 == rpoint1)
                {
                    if (lpoint1 > 0)
                    {
                        lpoint1 -= 1;
                    }
                    else
                    {
                        if (rpoint1 < length - 1)
                        {
                            rpoint1 +=1;
                        }
                    }
                }
                sub[geti].arith[lpoint1].left1 = "(";
                sub[geti].arith[rpoint1].right1 = ")";
            }
            else
            {
                if (length > 3)
                {
                    lpoint1 = rand.nextInt() % (length - 1);//产生内层左括号的位置
                    rpoint1 = lpoint1 + rand.nextInt() % (length - 1 - lpoint1);//产生内层右括号的位置
                    if (lpoint1 == rpoint1)
                    {
                        if (lpoint1 > 0)
                        {
                            lpoint1 -= 1;
                        }
                        else
                        {
                            if (rpoint1 < length - 1)
                            {
                                rpoint1 +=1;
                            }
                        }
                    }
                    sub[geti].arith[lpoint1].left1 = "(";
                    sub[geti].arith[rpoint1].right1 = ")";
                    if (lpoint1 == 0)
                    {
                        lpoint2 = lpoint1;//产生外层左括号的位置
                    }
                    else
                    {
                        lpoint2 = lpoint1 - rand.nextInt() % lpoint1;//产生外层左括号的位置
                    }
                    rpoint2 = rpoint1 + rand.nextInt() % (length - rpoint1);//产生外层右括号的位置
                    if (lpoint2 == lpoint1&&rpoint2 == rpoint1)
                    {
                        if (lpoint2 > 0)
                        {
                            lpoint2 -= 1;
                        }
                        else
                        {
                            if (rpoint2 < length - 1)
                            {
                                rpoint2 +=1;
                            }
                        }
                    }
                    sub[geti].arith[lpoint2].left2 = "(";
                    sub[geti].arith[rpoint2].right2 = ")";
                }
                else
                {
                    check = 1;
                }
            }
        }
        return check;
    }

    //判断用户是否答对
    public int Right(int result, int answer)
    {
        if (answer == result)
        {
            return 0;
        }
        else
        {
            return 1;
        }
        //return 0;
    }

    //验证除法有无余数
    public int change(int geti, int length)
    {
        int check = 0;
        for (j = 0; j < length; j++)
        {
            if (sub[geti].arith[j].fuhao == "/"&&sub[geti].arith[j].right1 != ")")
            {
                if (sub[geti].arith[j].member%sub[geti].arith[j + 1].member != 0)
                {
                    check = 1;
                }
            }
            if (sub[geti].arith[j].fuhao == "/"&&sub[geti].arith[j].right1 == ")")
            {
                if ((sub[geti].arith[j - 1].member / sub[geti].arith[j].member) % sub[geti].arith[j + 1].member != 0)
                {
                    check = 1;
                }
            }
        }
        return check;
    }

    //有乘除法、有括号、加减有负数、除法有余数
    public void Output1(int number, int low, int high)
    {
        int count = 0;
        for (i = 0; i < number; i++)
        {
            int check = 0;//检验产生式是否合格
            Random rand = new Random();
            sub[i].length = rand.nextInt() % 9 + 2;
            Init(i, sub[i].length, high, low, 4);
            Result = ValueResult(i, sub[i].length);
            check = Bracket(i, sub[i].length);
            if (Result>high)
            {
                check = 1;
            }
            if (check == 1)
            {
                i = i - 1; continue;
            }
            else
            {
                //Output(sub[i], sub[i].length);
                //LENGTH[CountNum++]=sub[i].length;
                //buffer[CountNum++]=sub[i];
                CountNum+=1;
                Results[CountNum]=Result;
                //int answer = Input();
                //Right(Result, answer);
            }
        }
        //UserResult(count);
    }
    //有乘除法、有括号、加减有负数、除法无余数
    public void Output2(int number, int low, int high)
    {
        int count = 0;
        for (i = 0; i < number; i++)
        {
            int check = 0;//检验产生式是否合格
            Random rand = new Random();
            sub[i].length = rand.nextInt() % 9 + 2;
            int check1 = 0;//检验除法是否有余数
            Init(i, sub[i].length, high, low, 4);
            check = Bracket(i, sub[i].length);
            check1 = change(i, sub[i].length);
            Result = ValueResult(i, sub[i].length);
            if (Result > high)
            {
                check = 1;
            }
            if (check == 1 || check1 == 1)
            {
                i = i - 1; continue;
            }
            else
            {
                //Output(sub[i], sub[i].length);
                //LENGTH[CountNum++]=sub[i].length;
                //buffer[CountNum++]=sub[i];
                CountNum+=1;
                Results[CountNum]=Result;
                //int answer = Input();
                //Right(Result, answer);
            }
        }
        //UserResult(count);
    }
    //有乘除法、有括号、加减无负数、除法有余数
    public void Output3(int number, int low, int high)
    {
        int count = 0;
        for (i = 0; i < number; i++)
        {
            int check = 0;//检验产生式是否合格
            Random rand = new Random();
            sub[i].length = rand.nextInt() % 9 + 2;
            Init(i, sub[i].length, high, low, 4);
            check = Bracket(i, sub[i].length);
            Result = ValueResult(i, sub[i].length);
            if (Result < 0 || Result > high)
            {
                check = 1;
            }
            if (check == 1)
            {
                i = i - 1; continue;
            }
            else
            {
                //Output(sub[i], sub[i].length);
                //LENGTH[CountNum++]=sub[i].length;
                //buffer[CountNum++]=sub[i];
                CountNum+=1;
                Results[CountNum]=Result;
                //int answer = Input();
                //Right(Result, answer);
            }
        }
        //UserResult(count);
    }
    //有乘除法、有括号、加减无负数、除法无余数
    public void Output4(int number, int low, int high)
    {
        int count = 0;
        for (i = 0; i < number; i++)
        {
            int check = 0;//检验产生式是否合格
            int check1 = 0;//检验除法是否有余数
            Random rand = new Random();
            sub[i].length = rand.nextInt() % 9 + 2;
            Init(i, sub[i].length, high, low, 4);
            check = Bracket(i, sub[i].length);
            check1 = change(i, sub[i].length);
            Result = ValueResult(i, sub[i].length);
            if (Result < 0 || Result > high)
            {
                check = 1;
            }
            if (check == 1 || check1 == 1)
            {
                i = i - 1; continue;
            }
            else
            {
                //Output(sub[i], sub[i].length);
                //LENGTH[CountNum++]=sub[i].length;
                //buffer[CountNum++]=sub[i];
                CountNum+=1;
                Results[CountNum]=Result;
                //int answer = Input();
                //Right(Result, answer);
            }
        }
        //UserResult(count);
    }
    //有乘除法、无括号、加减有负数、除法有余数
    public void Output5(int number, int low, int high)
    {
        int count = 0;
        for (i = 0; i < number; i++)
        {
            int check = 0;
            Random rand = new Random();
            sub[i].length = rand.nextInt() % 9 + 2;
            Init(i, sub[i].length, high, low, 4);
            Result = ValueResult(i, sub[i].length);
            if (Result > high)
            {
                check = 1;
            }
            if (check == 1)
            {
                i = i - 1; continue;
            }
            //Output(sub[i], sub[i].length);
            //LENGTH[CountNum++]=sub[i].length;
            //buffer[CountNum++]=sub[i];
            CountNum+=1;
            Results[CountNum]=Result;
            //int answer = Input();
            //Right(Result, answer);
        }
        //UserResult(count);
    }
    //有乘除法、无括号、加减有负数、除法无余数
    public void Output6(int number, int low, int high)
    {
        int count = 0;
        for (i = 0; i < number; i++)
        {
            int check = 0;
            Random rand = new Random();
            sub[i].length = rand.nextInt() % 9 + 2;
            Init(i, sub[i].length, high, low, 4);
            check = change(i, sub[i].length);
            Result = ValueResult(i, sub[i].length);
            if (Result > high)
            {
                check = 1;
            }
            if (check == 1)
            {
                i = i - 1; continue;
            }
            //Output(sub[i], sub[i].length);
            //LENGTH[CountNum++]=sub[i].length;
            //buffer[CountNum++]=sub[i];
            CountNum+=1;
            Results[CountNum]=Result;
            //int answer = Input();
            //Right(Result, answer);
        }
        //UserResult(count);
    }
    //有乘除法、无括号、加减无负数、除法有余数
    public void Output7(int number, int low, int high)
    {
        int count = 0;
        for (i = 0; i < number; i++)
        {
            int check = 0;//检验
            Random rand = new Random();
            sub[i].length = rand.nextInt() % 9 + 2;
            Init(i, sub[i].length, high, low, 4);
            Result = ValueResult(i, sub[i].length);
            if (Result < 0 || Result > high)
            {
                check = 1;
            }
            if (check == 1)
            {
                i = i - 1;
            }
            else
            {
                //Output(sub[i], sub[i].length);
                //LENGTH[CountNum++]=sub[i].length;
                //buffer[CountNum++]=sub[i];
                CountNum+=1;
                Results[CountNum]=Result;
                //int answer = Input();
                //Right(Result, answer);
            }
        }
        //UserResult(count);
    }
    //有乘除法、无括号、加减无负数、除法无余数
    public void Output8(int number, int low, int high)
    {
        int count = 0;
        for (i = 0; i < number; i++)
        {
            int check = 0;//检验
            Random rand = new Random();
            sub[i].length = rand.nextInt() % 9 + 2;
            Init(i, sub[i].length, high, low, 4);
            Result = ValueResult(i, sub[i].length);
            check = change(i, sub[i].length);
            if (Result < 0 || Result > high)
            {
                check = 1;
            }
            if (check == 1)
            {
                i = i - 1; continue;
            }
            else
            {
                //Output(sub[i], sub[i].length);
                //LENGTH[CountNum++]=sub[i].length;
                //buffer[CountNum++]=sub[i];
                CountNum+=1;
                Results[CountNum]=Result;
                //int answer = Input();
                //Right(Result, answer);
            }
        }
        //UserResult(count);
    }
    //无乘除法、有括号、加减有负数
    public void Output9(int number, int low, int high)
    {
        int count = 0;
        for (i = 0; i < number; i++)
        {
            int check = 0;//检验产生式是否合格
            Random rand = new Random();
            sub[i].length = rand.nextInt() % 9 + 2;
            Init(i, sub[i].length, high, low, 2);
            Result = ValueResult(i, sub[i].length);
            check = Bracket(i, sub[i].length);
            if (Result>high)
            {
                check = 1;
            }
            if (check == 1)
            {
                i = i - 1; continue;
            }
            else
            {
                //Output(sub[i], sub[i].length);
                //LENGTH[CountNum++]=sub[i].length;
                //buffer[CountNum++]=sub[i];
                CountNum+=1;
                Results[CountNum]=Result;
                //int answer = Input();
                //Right(Result, answer);
            }
        }
        //UserResult(count);
    }
    //无乘除法、有括号、加减无负数
    public void Output10(int number, int low, int high)
    {
        int count = 0;
        for (i = 0; i < number; i++)
        {
            int check = 0;//检验产生式是否合格
            Random rand = new Random();
            sub[i].length = rand.nextInt() % 9 + 2;
            Init(i, sub[i].length, high, low, 2);
            check = Bracket(i, sub[i].length);
            Result = ValueResult(i, sub[i].length);
            if (Result < 0 || Result > high)
            {
                check = 1;
            }
            if (check == 1)
            {
                i = i - 1; continue;
            }
            else
            {
                //Output(sub[i], sub[i].length);
                //LENGTH[CountNum++]=sub[i].length;
                //buffer[CountNum++]=sub[i];
                CountNum+=1;
                Results[CountNum]=Result;
                //int answer = Input();
                //Right(Result, answer);
            }
        }
        //UserResult(count);
    }
    //无乘除法、无括号、加减有负数
    public void Output11(int number, int low, int high)
    {
        int count = 0;
        for (i = 0; i < number; i++)
        {
            Random rand = new Random();
            sub[i].length = rand.nextInt() % 9 + 2;
            Init(i, sub[i].length, high, low, 2);
            Result = ValueResult(i, sub[i].length);
            if (Result>high)
            {
                i = i - 1; continue;
            }
            //Output(sub[i], sub[i].length);
            //LENGTH[CountNum++]=sub[i].length;
            //buffer[CountNum++]=sub[i];
            CountNum+=1;
            Results[CountNum]=Result;
            //int answer = Input();
            //Right(Result, answer);
        }
        //UserResult(count);
    }
    //无乘除法、无括号、加减无负数
    public void Output12(int number, int low, int high)
    {
        //int count = 0;//记录用户答对题数
        for (i = 0; i < number; i++)
        {
            Random rand = new Random();
            sub[i].length = rand.nextInt() % 9 + 2;
            Init(i, sub[i].length, high, low, 2);
            int check = 0;//检验
            Result = ValueResult(i, sub[i].length);
            if (Result<0 || Result>high)
            {
                check = 1;
            }
            if (check == 1)
            {
                i = i - 1; continue;
            }
            //Output(sub[i], sub[i].length);
            //LENGTH[CountNum++]=sub[i].length;
            //buffer[CountNum++]=sub[i];
            CountNum+=1;
            Results[CountNum]=Result;
            //int answer = Input();
            //Right(Result, answer);
        }
        //UserResult(count);
    }
    
    public void SetValue(int high1,int low1,int number1){
        MulAndDiv=0;
        Bracket=0;
        Negative=0;
        Remainder=0;
        high=high1;
        low=low1;   
        number=number1;
    } 
    public void SetValue1(int MAD)
    {
        MulAndDiv=MAD;
    }
    public void SetValue2(int Bra)
    {
        Bracket=Bra;
    }
    public void SetValue3(int Neg)
    {
        Negative=Neg;
    }
    public void SetValue4(int Rem)
    {
        Remainder=Rem;
    }
    
    public int Choose(){
        if(MulAndDiv==1&&Bracket==1&&Negative==1&&Remainder==1){
            return 1;
        }
        else if(MulAndDiv==1&&Bracket==1&&Negative==1&&Remainder==0){
            return 2;
        }
        else if(MulAndDiv==1&&Bracket==1&&Negative==0&&Remainder==1){
            return 3;
        }
        else if(MulAndDiv==1&&Bracket==1&&Negative==0&&Remainder==0){
            return 4;
        }
        else if(MulAndDiv==1&&Bracket==0&&Negative==1&&Remainder==1){
            return 5;
        }
        else if(MulAndDiv==1&&Bracket==0&&Negative==1&&Remainder==0){
            return 6;
        }
        else if(MulAndDiv==1&&Bracket==0&&Negative==0&&Remainder==1){
            return 7;
        }
        else if(MulAndDiv==1&&Bracket==0&&Negative==0&&Remainder==0){
            return 8;
        }
        else if(MulAndDiv==0&&Bracket==1&&Negative==1&&Remainder==0){
            return 9;
        }
        else if(MulAndDiv==0&&Bracket==1&&Negative==0&&Remainder==0){
            return 10;
        }
        else if(MulAndDiv==0&&Bracket==0&&Negative==1&&Remainder==0){
            return 11;
        }
        else
            return 12;
    }
    
     public int StrToNum(String strget)
     {
         int num=0;
         for(int i=0;i<strget.length();i++)
         {
             num=num*10+strget.charAt(i)-48;
         }
         return num;
     }
     //输出算式
     public String OutputEq(int number1)
     {
         return buffer[number1];
     }
     //输出答案
     public int OutputAn(int number1)
     {
         return Results[number1];
     }
     public int OutputLE(int number1)
     {
         return LENGTH[number1];
     }

    public int main()
    {
        int chooseWay;    //条件筛选结果
        chooseWay = Choose();        //条件筛选
        switch (chooseWay)
        {
        case 1:Output1(number, low, high); break;
        case 2:Output2(number, low, high); break;
        case 3:Output3(number, low, high); break;
        case 4:Output4(number, low, high); break;
        case 5:Output5(number, low, high); break;
        case 6:Output6(number, low, high); break;
        case 7:Output7(number, low, high); break;
        case 8:Output8(number, low, high); break;
        case 9:Output9(number, low, high); break;
        case 10:Output10(number, low, high); break;
        case 11:Output11(number, low, high); break;
        case 12:Output12(number, low, high);
        }
        return 0;
    }
    
}

 

转载于:https://www.cnblogs.com/wangzongze/p/5360853.html

weixin_30596165
关注
四则运算网页版--结对项目
Leon_Theprofessional的博客
04-10 500
前言： 这次项目是用前后台分离，后台代码由servlet编写。项目部署于我的个人服务器。 github仓库地址https://github.com/LeonP3ng/CalculateWeb.git 服务器项目地址https://rammsteinlp.cn/CalculateProject/ 前台搭档陈慧妮博客： https://blog.csdn.net/olivia_chn/ar...
java 四则运算_四则运算————javaweb版
weixin_28713947的博客
02-19 1472
1.设计思路：定义一个类arithmetic，在该类中的定义相关成员，随机产生的题目以及答案用数组承接，在第一个jsp里面用户输入题目数量以及设置做题时间，将这两个数传到第二个jsp页面，在此页面定义类对象，调用相关类函数，进行出题：最后将算式的数组和答案的数组以及用户输入的值传到第三个jsp页面，进行答案的校对即可。源代码：arithmetic.java:package com.jaovo.ms...
四则运算完整网页版
weixin_30632089的博客
04-09 287
与胡泽杰合作完成 转载于:https://www.cnblogs.com/zhangbaohai/p/6686853.html
四则运算 网页版
weixin_30770783的博客
04-06 166
这次实验是四则运算系列的最后一次实验，实验的要求是：做成安卓APP版或者网页版，我们组做的是网页版，实验内容如下： 完成本次实验所使用的软件：MyEclipse（主要是学习java时课外所学习的知识）和tomcat（作为服务器，上传实验程序） 主要代码： QusetionAction.java：　　 public HandleRequest chuti(HandleReq...
js实现随机的四则运算题目效果
01-20
在本文中，我们将探讨如何使用JavaScript（JS）来实现一个随机生成四则运算题目的功能，特别关注如何适应小学生的数学水平，避免涉及负数和小数。首先，我们需要一个函数来生成1到30之间的随机整数，这可以通过`...
小学四则运算源码
04-08
该压缩包文件主要包含了一款针对小学生四则运算学习的软件资源。这款软件不仅能够帮助学生进行四则运算练习，还提供了数字转换的功能，旨在提升孩子们的数学计算能力，减轻家长辅导作业的压力。 首先，我们可以看到...
PHP 使用位运算实现四则运算的代码
10-15
【PHP 使用位运算实现四则运算的代码】 在编程中，位运算是一种高效的数据处理方式，尤其在底层计算和优化中十分常见。PHP作为一种广泛使用的脚本语言，虽然其主要应用在于网页开发，但同样可以利用位运算进行复杂...
计算器JSP 四则运算
06-07
用JSP写的四则运算，相当简单JSP 四则运算器 +(加) -(减) *(乘) /(除)
简单的四则运算网页版
weixin_33825683的博客
12-06 411
四、源代码 欢迎界面 1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> 2 <html> 3 <head> 4 <%@ page language="java" contentType="text/html; charset=UTF-8" 5 ...
四则运算最终篇-网页版四则运算
weixin_30711917的博客
04-07 467
1.实验要求： 2.实验思路：使用jsp Javabean和servlet来实现，Javabean定义实体类，定义能根据设置的参数产生出对应的方法，jsp页面用来让用户选择参数，做题和查看历史记录，servlet根据jsp传的数据进行响应和处理。 首先有一个选择界面的jsp，如果选择做题就跳转到设置参数的jsp，设置好参数后，传到servlet，servlet根据传过来的参数...
结对项目之网页版四则运算报告
Olivia_CHN的博客
04-10 376
前言 这次我们做的是网页版的四则运算，采用前后端分离的方式来完成此次项目。在本次项目中我负责前端部分，我的搭档刘鹏负责后端部分。这次的结对项目对于我来说是一个很好的复习css和js的机会，很好地练习了ajax技术，对前后端分离也有了更好的理解。 一、项目地址 代码仓库地址： 陈慧妮：https://github.com/Chenhn110/Calcu/tree/master...
软件工程个人作业04-四则运算网页版
weixin_30779691的博客
06-08 153
在网页上面生成一个四则运算表达式，用户可以输入表达式的值，然后系统提示结果是否正确。这个网页程序比本机程序来说容易一点，一是因为表达式中运算符的个数不超过三个，表达式容易获得。还有就是javascript自带了一个计算表达式的值的函数，我们可以调用这个函数来完成对表达式值的计算。 <%@ page language="java" import="java.util.*" pageE...
四则运算生成器（网页版）
weixin_30586257的博客
04-06 619
题目：在原有的C程序下将四则运算生成器改写为网页版 要求： 1. 生成的题目中计算过程不能产生负数，也就是说算术表达式中不存在负数或如果存在形如e1 ? e2的子表达式，那么e1 ≥ e2。 2.生成的题目中如果存在形如e1 ÷ e2的子表达式，那么其结果应是真分数。 3.程序一次运行生成的题目不能重复。　　 4.把程序变成一个网页程序或智能手机...
Html实现简单的四则运算--加减乘除计算(单选框默认选择)
程序羊的博客
09-25 7703
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0, minimum-scale=1.0, maximum-scal...
[JS]做一个网页四则运算计算器
weixin_33910385的博客
10-29 1914
任务：用js写算法，实现一个网页四则运算计算器 效果： 成果链接：codepen@cuphoria js实现思路： 定义一个用来存储表达式的全局变量expr和一个是否清空的全局变量clear 点击value为表达式组成部分的按钮，将value加入到表达式expr中 若按钮是ac ，ce则完成相应功能 若按钮是等号，调用表达式计算函数，并将结果返回到expr中，将cl...
在网页上进行四则运算
m0_49258443的博客
08-04 560
效果图如上，输入所要计算的数，点击计算式子的结果显示 下面展示一些 内联代码片。 //body里的代码 <input type="text" id="inp1"> <select name="" id="sel"> <option value="+">+</option> <option value="-">-</option> <option value="*">*.
使用j2ee实现网页四则运算
最新发布
05-20
以下是一个简单的使用 JSP 和 Servlet 实现网页四则运算的示例： 1. 首先创建一个名为 "index.jsp" 的 JSP 文件，用于显示网页表单和接收用户输入： ```jsp ; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值