软件工程结对作业02

import java.util.Scanner;
class Fraction//分数
{
    public int numerator;//分子
    public int denominator;//分母
    public void creatFraction()
    {
        //--生成值并化简--
        boolean bool=false;
        while(bool==false)
        {
            int up=(int)(1+Math.random()*10);
            int down=(int)(1+Math.random()*10);
            if(down<=up)
            {
                continue;
            }
            for(int i=2;;i++)
            {
                if(up%i==0&&down%i==0)
                {
                    up/=i;
                    down/=i;
                    i-=1;
                }
                if(i>up||i>down)
                {
                    break;
                }
            }
            if(down==1)
            {
                continue;
            }
            else
            {
                numerator=up;
                denominator=down;
                bool=true;
            }
        }
        //--生成值并化简--
    }
    public String strFraction()
    {
        String ud=new String();
        ud="("+numerator+"/"+denominator+")";
        return ud;
    }
    public int getNumerator()
    {
        return numerator;
    }
    public int getDenominator()
    {
        return denominator;
    }
}

class Integer//整数
{
    public int integer;
    public int downinteger=1;
    public void creatInteger()
    {
        integer=(int)(1+Math.random()*100);
    }
    public String strInteger()
    {
        String g;
        g=integer+"";
        return g;
    }

    public int getInteger()
    {
        int a=integer;
        return a;
    }
    public int getDownInteger()
    {
        int b=downinteger;
        return b;
    }
}

class Operator//符号
{
    public String operator;
    public int inoperator;
    public void creatOperator()
    {
        inoperator=(int)(1+Math.random()*4);
        switch(inoperator)
        {
        case 1:{operator="+";break;}
        case 2:{operator="-";break;}
        case 3:{operator="*";break;}
        case 4:{operator="/";break;}
        default:{System.out.println("运行出错，结束");break;}
        }
    }
    public String getOperator()
    {
        String g=operator;
        return g;
    }
    public int getInOperator()
    {
        int g=inoperator;
        return g;
    }
}

public class Operations4
{
    //-----------化简区----------------
    static int upSimple(int sup,int sdown)//化简分子
    {
        boolean bool=false;
        while(bool==false)
        {
            for(int i=2;;i++)
            {
                if(sup%i==0&&sdown%i==0)
                {
                    sup/=i;
                    sdown/=i;
                    i-=1;
                }
                if(i>sup||i>sdown)
                {
                    break;
                }
            }
            bool=true;
        }
        return sup;
    }
    static int downSimple(int sup,int sdown)//化简分母
    {
        boolean bool=false;
        while(bool==false)
        {
            for(int i=2;;i++)
            {
                if(sup%i==0&&sdown%i==0)
                {
                    sup/=i;
                    sdown/=i;
                    i-=1;
                }
                if(i>sup||i>sdown)
                {
                    break;
                }
            }
            bool=true;
        }
        return sdown;
    }
    //--------计算区---------------
    static int getUp(int up1,int down1,int up2,int down2,int fu)//获取计算后的分子
    {
        int up=1,down=1;
        switch(fu)
        {
        case 1:
        {
            up=up1*down2+up2*down1;
            break;
        }
        case 2:
        {
            up=up1*down2-up2*down1;
            break;
        }
        case 3:
        {
            up=up1*up2;
            break;
        }
        case 4:
        {
            up=up1*down2;
            break;
        }
        default:
        {
            System.out.println("运行错误，结束");
            break;
        }
        }
        return up;
    }

        static int getDown(int up1,int down1,int up2,int down2,int fu)//获取计算后的分母
        {
            int up=1,down=1;
            switch(fu)
            {
            case 1:
            {
                down=down1*down2;
                break;
            }
            case 2:
            {
                down=down1*down2;
                break;
            }
            case 3:
            {
                down=down1*down2;
                break;
            }
            case 4:
            {
                down=down1*up2;
                break;
            }
            default:
            {
                System.out.println("运行错误，结束");
                break;
            }
            }
            return down;
        }
        //------判断------
        static int nCont(int nup,int ndown,int nfu)
        {
            int n=1;//达到要求
            if((nfu==2&&nup<ndown)||(nfu==4&&nup>ndown))
            {
                n=2;//未达要求
            }
            return n;
        }

    //--------运算区---------------
    public static void main(String args[])
    {
        System.out.print("请输入需要的题数：");
        Scanner shuzi=new Scanner(System.in);
        int SIZE=shuzi.nextInt();
        String Ends[]=new String[SIZE];

        for(int j=0;j<SIZE;j++)
        {
        String strOP=null;
        //-----------确定数字---------
        int number=(int)(2+Math.random()*3);//随机数字个数：2~4个
        //舍弃数组[0]的位置，以下都从数组[1]开始
        Integer zheng[]=new Integer[number+1];
        Fraction fen[]=new Fraction[number+1];
        Operator fuhao[]=new Operator[number];

        int Array[][]=new int[number+1][2];
        String strArray[]=new String[number+1];

        int inBrray[]=new int[number];
        String strBrray[]=new String[number];

        int aup=1,adown=1;
        boolean bl=false;
        while(bl==false)
        {
            for(int i=1;i<=number;i++)//确定数字在数组中
            {
                int panduan=(int)(1+Math.random()*2);//随机分配整数或分数。1--整数，2--分数
                //数字划入Array数组
                if(panduan==1)
                {
                    zheng[i]=new Integer();
                    zheng[i].creatInteger();
                    Array[i][0]=zheng[i].getInteger();
                    Array[i][1]=zheng[i].getDownInteger();
                    strArray[i]=zheng[i].strInteger();
                }
                if(panduan==2)
                {
                    fen[i]=new Fraction();
                    fen[i].creatFraction();
                    Array[i][0]=fen[i].getNumerator();
                    Array[i][1]=fen[i].getDenominator();
                    strArray[i]=fen[i].strFraction();
                }
                //符号划入Barry数组
                if(i==number){break;}
                fuhao[i]=new Operator();
                fuhao[i].creatOperator();
                inBrray[i]=fuhao[i].getInOperator();
                strBrray[i]=fuhao[i].getOperator();
            }
            //---------进行运算----------
            if(number==2)//两个数字
            {
                int a1,a2;
                a1=getUp(Array[1][0],Array[1][1],Array[2][0],Array[2][1],inBrray[1]);
                a2=getDown(Array[1][0],Array[1][1],Array[2][0],Array[2][1],inBrray[1]);

                int nC=nCont(a1,a2,inBrray[1]);
                if(nC==2)
                {continue;}

                aup=upSimple(a1,a2);
                adown=downSimple(a1,a2);

            }
            if(number==3)
            {
                if(inBrray[1]<=2&&inBrray[2]>2)
                {
                    int b1,b2;
                    b1=getUp(Array[2][0],Array[2][1],Array[3][0],Array[3][1],inBrray[2]);
                    b2=getDown(Array[2][0],Array[2][1],Array[3][0],Array[3][1],inBrray[2]);

                    int nC2=nCont(b1,b2,inBrray[2]);
                    if(nC2==2)
                    {continue;}
                    //---------
                    int a1,a2;
                    a1=getUp(Array[1][0],Array[1][1],b1,b2,inBrray[1]);
                    a2=getDown(Array[1][0],Array[1][1],b1,b2,inBrray[1]);

                    int nC1=nCont(a1,a2,inBrray[1]);
                    if(nC1==2)
                    {continue;}
                    //---------

                    aup=upSimple(a1,a2);
                    adown=downSimple(a1,a2);
                }
                else
                {
                    int a1,a2;
                    a1=getUp(Array[1][0],Array[1][1],Array[2][0],Array[2][1],inBrray[1]);
                    a2=getDown(Array[1][0],Array[1][1],Array[2][0],Array[2][1],inBrray[1]);

                    int nC1=nCont(a1,a2,inBrray[1]);
                    if(nC1==2)
                    {continue;}
                    //---------
                    int b1,b2;
                    b1=getUp(a1,a2,Array[3][0],Array[3][1],inBrray[2]);
                    b2=getDown(a1,a2,Array[3][0],Array[3][1],inBrray[2]);

                    int nC2=nCont(a1,a2,inBrray[2]);
                    if(nC2==2)
                    {continue;}
                    //----------

                    aup=upSimple(b1,b2);
                    adown=downSimple(b1,b2);
                }
            }

            if(number==4)
            {
                if(inBrray[1]>2)
                {
                    int a1,a2;
                    a1=getUp(Array[1][0],Array[1][1],Array[2][0],Array[2][1],inBrray[1]);
                    a2=getDown(Array[1][0],Array[1][1],Array[2][0],Array[2][1],inBrray[1]);

                    int nC1=nCont(a1,a2,inBrray[1]);
                    if(nC1==2)
                    {continue;}

                    if(inBrray[2]<=2&&inBrray[3]>2)
                    {
                        int c1,c2;
                        c1=getUp(Array[3][0],Array[3][1],Array[4][0],Array[4][1],inBrray[3]);
                        c2=getDown(Array[3][0],Array[3][1],Array[4][0],Array[4][1],inBrray[3]);

                        int nC3=nCont(c1,c2,inBrray[3]);
                        if(nC3==2)
                        {continue;}
                        //---------
                        int b1,b2;
                        b1=getUp(a1,a2,c1,c2,inBrray[2]);
                        b2=getDown(a1,a2,c1,c2,inBrray[2]);

                        int nC2=nCont(b1,b2,inBrray[1]);
                        if(nC2==2)
                        {continue;}
                        //---------

                        aup=upSimple(b1,b2);
                        adown=downSimple(b1,b2);
                    }
                    else
                    {
                        int b1,b2;
                        b1=getUp(a1,a2,Array[3][0],Array[3][1],inBrray[2]);
                        b2=getDown(a1,a2,Array[3][0],Array[3][1],inBrray[2]);

                        int nC2=nCont(b1,b2,inBrray[2]);
                        if(nC2==2)
                        {continue;}
                        //---------
                        int c1,c2;
                        c1=getUp(b1,b2,Array[4][0],Array[4][1],inBrray[3]);
                        c2=getDown(b1,b2,Array[4][0],Array[4][1],inBrray[3]);

                        int nC3=nCont(c1,c2,inBrray[3]);
                        if(nC3==2)
                        {continue;}
                        //----------

                        aup=upSimple(c1,c2);
                        adown=downSimple(c1,c2);
                    }
                }
                else
                {
                    if(inBrray[2]>2&&inBrray[3]<=2)
                    {
                        int b1,b2;
                        b1=getUp(Array[2][0],Array[2][1],Array[3][0],Array[3][1],inBrray[2]);
                        b2=getDown(Array[2][0],Array[2][1],Array[3][0],Array[3][1],inBrray[2]);

                        int nC2=nCont(b1,b2,inBrray[2]);
                        if(nC2==2)
                        {continue;}
                        //---------
                        int a1,a2;
                        a1=getUp(Array[1][0],Array[1][1],b1,b2,inBrray[1]);
                        a2=getDown(Array[1][0],Array[1][1],b1,b2,inBrray[1]);

                        int nC1=nCont(a1,a2,inBrray[1]);
                        if(nC1==2)
                        {continue;}
                        //----------
                        int c1,c2;
                        c1=getUp(a1,a2,Array[4][0],Array[4][1],inBrray[3]);
                        c2=getDown(a1,a2,Array[4][0],Array[4][1],inBrray[3]);

                        int nC3=nCont(c1,c2,inBrray[3]);
                        if(nC3==2)
                        {continue;}
                        //----------

                        aup=upSimple(c1,c2);
                        adown=downSimple(c1,c2);
                    }
                    else if(inBrray[2]>2&&inBrray[3]>2)
                    {
                        int b1,b2;
                        b1=getUp(Array[2][0],Array[2][1],Array[3][0],Array[3][1],inBrray[2]);
                        b2=getDown(Array[2][0],Array[2][1],Array[3][0],Array[3][1],inBrray[2]);

                        int nC2=nCont(b1,b2,inBrray[2]);
                        if(nC2==2)
                        {continue;}
                        //---------
                        int c1,c2;
                        c1=getUp(b1,b2,Array[4][0],Array[4][1],inBrray[3]);
                        c2=getDown(b1,b2,Array[4][0],Array[4][1],inBrray[3]);

                        int nC3=nCont(c1,c2,inBrray[3]);
                        if(nC3==2)
                        {continue;}
                        //----------
                        int a1,a2;
                        a1=getUp(Array[1][0],Array[1][1],c1,c2,inBrray[1]);
                        a2=getDown(Array[1][0],Array[1][1],c1,c2,inBrray[1]);

                        int nC1=nCont(a1,a2,inBrray[1]);
                        if(nC1==2)
                        {continue;}
                        //----------

                        aup=upSimple(a1,a2);
                        adown=downSimple(a1,a2);
                    }
                    else if(inBrray[2]<=2&&inBrray[3]>2)
                    {
                        int c1,c2;
                        c1=getUp(Array[3][0],Array[3][1],Array[4][0],Array[4][1],inBrray[3]);
                        c2=getDown(Array[3][0],Array[3][1],Array[4][0],Array[4][1],inBrray[3]);

                        int nC3=nCont(c1,c2,inBrray[3]);
                        if(nC3==2)
                        {continue;}
                        //---------
                        int a1,a2;
                        a1=getUp(Array[1][0],Array[1][1],Array[2][0],Array[2][1],inBrray[1]);
                        a2=getDown(Array[1][0],Array[1][1],Array[2][0],Array[2][1],inBrray[1]);

                        int nC1=nCont(a1,a2,inBrray[1]);
                        if(nC1==2)
                        {continue;}
                        //----------
                        int b1,b2;
                        b1=getUp(a1,a2,c1,c2,inBrray[2]);
                        b2=getDown(a1,a2,c1,c2,inBrray[2]);

                        int nC2=nCont(b1,b2,inBrray[2]);
                        if(nC2==2)
                        {continue;}
                        //----------

                        aup=upSimple(b1,b2);
                        adown=downSimple(b1,b2);
                    }
                    else
                    {
                        int a1,a2;
                        a1=getUp(Array[1][0],Array[1][1],Array[2][0],Array[2][1],inBrray[1]);
                        a2=getDown(Array[1][0],Array[1][1],Array[2][0],Array[2][1],inBrray[1]);

                        int nC1=nCont(a1,a2,inBrray[1]);
                        if(nC1==2)
                        {continue;}
                        //---------
                        int b1,b2;
                        b1=getUp(a1,a2,Array[3][0],Array[3][1],inBrray[2]);
                        b2=getDown(a1,a2,Array[3][0],Array[3][1],inBrray[2]);

                        int nC2=nCont(b1,b2,inBrray[2]);
                        if(nC2==2)
                        {continue;}
                        //----------
                        int c1,c2;
                        c1=getUp(b1,b2,Array[4][0],Array[4][1],inBrray[3]);
                        c2=getDown(b1,b2,Array[4][0],Array[4][1],inBrray[3]);

                        int nC3=nCont(c1,c2,inBrray[3]);
                        if(nC3==2)
                        {continue;}
                        //----------

                        aup=upSimple(c1,c2);
                        adown=downSimple(c1,c2);
                    }
                }
            }
            if(adown==1)
            {
                strOP=aup+"";
            }
            else
            {
                strOP=aup+"/"+adown;
            }

            bl=true;
        }

        String back="";
        for(int i=1;i<=number;i++)
        {
            back+=strArray[i];
            if(i==number){break;}
            back+=strBrray[i];
        }
        System.out.print(back+"=");

        String shuchu=strOP;

        Ends[j]=shuchu;
        //-------判定重复--------
        int chuqu=1;
        for(int q=0;q<j;q++)
        {
            if(Ends[j]==Ends[q])
            {
                chuqu=2;
            }
        }
        if(chuqu==2)
        {
            j--;
            continue;
        }
        //--------
        Scanner sca=new Scanner(System.in);
        String shuru=sca.next();
        if(shuchu.equals(shuru))
        {
            System.out.println("正确");
        }
        else
        {
            System.out.println("错误，正确答案为："+shuchu);
        }
    }
    }

}

时间： 2024-10-13 01:55:17

软件工程结对作业02的相关文章

软件工程结对作业02（借鉴版）

软件工程结对作业02(借鉴版) 在编写程序的时候因为不会将Java程序嵌入进jsp中所以借鉴了一个学姐的程序,下面是学姐的程序.但在对学姐程序就行修改时发现了一些问题: 在Newjsp中能调用html中的题目个数的参数 在Myjsp中不能调用html中的题目个数的参数 其中这个参数timugeshu,是我自己后来添加的,用来改变题目个数的,与Java程序无关,只在jsp文件中作用 源程序: NewFeil.html <!DOCTYPE html> <html> <head&g

软件工程结对作业02（原创版）

一.设计思路 1.在HTML文件中写题目选择项 2.输入一个数控制题目个数 3.输入一个数控制取值范围(小于100) 4.输入一个数控制参数个数 5.选择是否有乘除法数 6.在有乘除法时,选择是否有余法 7.选择是否有括号 8.点击提交按钮,通过一个链接进入jsp文件,并且用户在HTML输入的参数传到jsp 页面 9.调用java函数,输出题目 10.点击开始答题之后,进入下一个jsp页面,用户答题并显示用户答题情况 二.源代码: HTML文件 <!DOCTYPE html PUBLIC "

软件工程结对作业 四则运算界面设计

软件工程结对作业 四则运算界面设计 康鑫  PB16060203 娄雨禛  PB16060356 一.项目分析 二.进度规划与完成情况 三.主要函数 四.简单的数据测试 五.编程困惑与心得 原文地址:https://www.cnblogs.com/RainLou/p/8735480.html

软件工程个人作业02（四则运算）

四则运算作业02 import javax.swing.JOptionPane; import java.util.Random; import java.util.Scanner; public class Arithmetic { public static void main(String[] args) { // TODO 自动生成的方法存根 int c;//选择 int c1,c4,c5,c6,c7,c8; int a,b,d1;//二位数运算 int c2,c3; int e=0;/

软件工程概论作业02

这周,我们上了软件工程概论第三节课,终于体会到的程序员的不易,作业一次比一次难,老师提出的要求越来越多,就像未来的客户一样,要求永远无止境. 这次还在上次的要求上提出了新的要求,要求可选择整数还是分数,可指定范围,不可重复. 可怜的二柱子同学,老师又对他的自动出题系统提出了新的要求: 可以控制下列参数: 是否有乘除法: 是否有括号(最多可以支持十个数参与计算): 数值范围: 加减有无负数: 除法有无余数! 日期 开始时间 结束时间 中断时间 净时间 活动 备注 C U 3/10 14:00 16

软件工程结队作业02

设计思想:    使用jsp实现java代码与网页的连接,利用数组实现数据的传输.Session对象页面的跳转功能. 源代码: 运行结果截图: 编程总结: 对jsp和session的使用不熟悉,不知道如何将java代码插入到网页程序中,所以参考了网上代码进行编写. 周活动总结表 姓名:杜若憧                            日期 2016/4/8 听课 编写代码 阅读课本 准备考试 日总计 周日 周一 50 50 周二 100 60 160 周三 22 22 周四 30 3

软件工程结对作业01

一.题目: 结对项目开发-四则运算四 把程序变成一个网页程序,用户通过设定参数,就可以得到各种题目,并可实现在线答题并评判. 注:这是一个两人结对开发的项目,开发人员:曾凯    刘雨鑫 二.程序设计思想: (1)功能分析: 1.这是一个可以在线答题的web版四则运算程序,用户可以通过设点一些参数来生成题目,然后回答这些题目,提交后程序检查回答的正确性,然后将题目的回答情况通过页面显示的方式反馈给用户. 2.由于参数设置导致交互不太方便,用户需要考虑参数如何搭配,由此实现按照年级答题,用户只需要

软件工程个人作业02（四则运算2）

题目要求: 是否有乘除法:  是否有括号(最多可以支持十个数参与计算):  数值范围:  加减有无负数:  除法有无余数!    四则运算2的设计思想:因为题目要求可以选择是否有除法,是否有括号,加减有无负数,除法有无余数.所以这里考虑用if~~else语句来进行选择.目前程序无法完成生成题目是否有括号的要求.    源程序代码: import java.util.Random; import java.util.Scanner; public class sizeyunsuan2 { /*是否

软件工程结对作业实验报告

题目简介: 设计一个名为MyPoint的类,表示一个带x坐标和y坐标的点.该类包括:? 两个带get方法的数据域x和y,分别表示它们的坐标.? 一个创建点(0,0)的无参构造方法.? 一个创建特定坐标点的构造方法.? 两个数据域x和y各自的get方法.? 一个名为distance的方法,返回MyPoint类型的两个点之间的距离.? 一个名为distance的方法,返回指定x和y坐标的两个点之间的距离. 二.结对分工及过程 : 结对:张萍萍,程志张萍萍:程序的分析和程序的测试及测试代码的编写程志: