现代软件工程 第一章 【概论】练习与讨论 徐怡琳（1,5）

1.随机生成10个整数分数混合四则运算并计算结果   java程序

　　首先感谢 http://justsee.iteye.com/blog/1125174 这篇博客的博主，我实现的四则运算参考了该博主的算法，在博主算法的基础上实现了分数的四则运算，以及整数分数的混合运算。

　　其次感谢 http://www.cnblogs.com/maximumminimum/p/4319219.html 这篇博客的博主，实现了随机生成10个四则运算。在此基础上将生成运算式存入特色test.tst文件，并将计算结果存入answer.txt文件。

　　运行程序后会允许答题者输入答案，若正确提示正确，若错误，提示错误，并给出正确答案，接下来提示是否进入下一题。

　　本文所实现的四则运算所用的开发工具是eclipse+jdk1.8，运用栈的思想对四则运算式求值。

　　具体代码

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
import java.util.Stack;

public class TestOperate {

    /*
     * @param numerator 操作数分子栈
     * @param denominator 操作数分母栈
     * @param ChaStack 操作符栈
     */
    Stack<Integer> numerator = new Stack<Integer>();//分子
    Stack<Integer> denominator = new Stack<Integer>();//分母
    Stack<Character> ChaStack = new Stack<Character>();    
    
    public boolean IsNumber(String temp) {
        return temp.matches("[0-9]");
    }
    
    public String caculate(StringBuffer string2) {
        
        String temp,result;//用来存放读取的字符
        StringBuffer tempnum = new StringBuffer();//记录当前数值
        StringBuffer string = new StringBuffer().append(string2);
        
        while(string.length()!=0)
        {
            temp = string.substring(0, 1);
            string.delete(0, 1);
            if(!IsNumber(temp))
            {
                //将得到的数送入运算数栈中
                if(!("").equals(tempnum.toString()))//("").equals(string)在string为null的时候返回false 
                {
                    int num = Integer.parseInt(tempnum.toString());
                    numerator.push(num);
                    denominator.push(1);
                    tempnum.delete(0, tempnum.length());
                }
                //若运算符栈非空且temp的优先级高于栈顶元素优先级
                while(!ChaStack.empty()&&!Compare(temp.charAt(0)))
                {
                    int x2 = numerator.pop().intValue();
                    int y2 = denominator.pop().intValue();
                    int x1 = numerator.pop().intValue();
                    int y1 = denominator.pop().intValue();
                
                    int maxcom,numresult,denresult;//maxcom最大公约数,numresult分数计算结果，denresult分母计算结果
                    int mincom = Minfunc(y1,y2);//最小公倍数
                    x1 = mincom/y1*x1;
                    x2 = mincom/y2*x2;
                    y1 = mincom;
                    y2 = mincom;
                    char opt = ChaStack.pop();
                    switch(opt)
                    {
                    case '+':
                        {
                            numresult = x1+x2;
                            denresult = mincom;
                            maxcom = Maxfunc(numresult,denresult);
                            numresult = numresult/maxcom;
                            denresult = denresult/maxcom;
                            numerator.push(numresult);
                            denominator.push(denresult);
                            break;
                        }
                    case '-':
                        {
                            numresult = x1-x2;
                            denresult = mincom;
                            maxcom = Maxfunc(numresult,denresult);
                            numresult = numresult/maxcom;
                            denresult = denresult/maxcom;
                            numerator.push(numresult);
                            denominator.push(denresult);
                            break;
                        }
                    case '*':
                        {
                            numresult = x1*x2;
                            denresult = y1*y2;
                            maxcom = Maxfunc(numresult,denresult);
                            numresult = numresult/maxcom;
                            denresult = denresult/maxcom;
                            numerator.push(numresult);
                            denominator.push(denresult);
                            break;
                        }
                    case '/': 
                        {
                            numresult = x1*y2;
                            denresult = y1*x2;
                            maxcom = Maxfunc(numresult,denresult);
                            numresult = numresult/maxcom;
                            denresult = denresult/maxcom;
                            numerator.push(numresult);
                            denominator.push(denresult);
                            break;
                        }
                    }
                }
                if(temp.charAt(0)!='#')
                {
                    ChaStack.push(new Character(temp.charAt(0)));
                    if(ChaStack.peek()==')') 
                    {
                        ChaStack.pop();
                        ChaStack.pop();
                    }
                }
            }else
            tempnum = tempnum.append(temp);
        }
        int x = numerator.pop();
        int y = denominator.pop();
        int a;
        if(x%y == 0)
        {
            a = x/y;
            result = String.valueOf(a);
        }
        else  result = String.valueOf(x) + '/' + String.valueOf(y);
        return result;
    }
    private int Maxfunc(int a, int b) {//分子分母最大公约数
        // TODO Auto-generated method stub
        while(b != 0) 
        {
            int temp = a%b;
            a = b;
            b = temp;
        }
        return a;
    }

    private int Minfunc(int a, int b) {//分母的最小公倍数，通分
        // TODO Auto-generated method stub
        return a * b / Maxfunc(a, b);
    }

    public boolean Compare(char opt) {//opt高于栈顶操作符等级返回真
        if(ChaStack.empty()) return true;
        char tag = (char)ChaStack.peek();
        if(tag=='(') return true;
        switch(opt)
        {
        case '#':return false;
        case '(':return true;
        case ')':return false;
        case '+':return false;
        case '-':return false;
        case '*':
            if(tag=='+'||tag=='-')
                return true;
            else return false;
        case '/':
            if(tag=='+'||tag=='-')
                return true;
            else return false;
        }
        return true;
    }
    
     String Divide()//分数的生成
     {
         int i=(int)(Math.random()*10);
         int j=(int)(Math.random()*10);
         if(i>=j)
         {
             int temp=i;
             i=j;
             j=temp;
         }
         return("("+i+"/"+j+")");
    }
    
    public static void main(String[] args) {
            
        TestOperate operate = new TestOperate();
        File tesfile = new File("F:/CacTest/test.txt");
        File ansfile = new File("F:/CacTest/answer.txt");
        try 
        {   
            FileWriter fw5 = new FileWriter(tesfile);
            BufferedWriter bw1 = new BufferedWriter(fw5);
            bw1.write("");
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        try 
        {   
            FileWriter fw = new FileWriter(ansfile);
            BufferedWriter bw = new BufferedWriter(fw);
            bw.write("");
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        String x,y;
        int k;
        for(int n=0;n<10;n++)
        {
            String ats = null;
            x=operate.Divide();
            y=operate.Divide();
            int i=(int)(Math.random()*100);
            int j=(int)(Math.random()*100);
            switch((int)(Math.random()*4))
            {
            case 0:
                k=(int)(Math.random()*3);
                if(k==0)
                    ats = i+"+"+j;
                else if(k==1)
                    ats = x+"+"+j;
                else if(k==2)
                    ats = y+"+"+x;
                break;
            case 1:
                k=(int)(Math.random()*3);
                if(i<j)
                {
                    int temp=i;
                    i=j;
                    j=temp;
                }
                if(k==0)
                    ats = i+"-"+j;
                else if(k==1)
                    ats = j+"-"+x;
                else if(k==2)
                    ats = x+"-"+y;
                break;
            case 2:
                k=(int)(Math.random()*3);
                if(k==0)
                    ats = i+"*"+j;
                else if(k==1)
                    ats = x+"*"+j;
                else if(k==2)
                    ats = x+"*"+y;
                break;
            case 3:
                while(j==0)
                    j= (int)(Math.random()*100);
                ats = i+"/"+j;
                break;
            }
            try{
                FileOutputStream out = new FileOutputStream(tesfile,true);
                DataOutputStream ds = new DataOutputStream(out);
                ats += "="+"\r\n";
                int b=ats.length();
                ds.write(ats.getBytes(),0,b); 
                ds.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        
        String str = null;
        try{
            BufferedReader br = new BufferedReader(new FileReader("F:/CacTest/test.txt"));
            while((str = br.readLine())!=null){
                StringBuffer string = new StringBuffer().append(str);
                int len = string.length();
                string.delete(len-1, len);
                string.append('#');
                String t = operate.caculate(string);

                try{
                    FileOutputStream out1 = new FileOutputStream(ansfile,true);
                    DataOutputStream ds1 = new DataOutputStream(out1);
                    t += "\r\n";
                    int b=t.length();
                    ds1.write(t.getBytes(),0,b); 
                    ds1.close();
                }catch(Exception e){
                    e.printStackTrace();
                }
                
            }
            br.close();
        }catch(FileNotFoundException e2){
            e2.printStackTrace();
        }catch(IOException e3){
            e3.printStackTrace();
        }
        try{
            BufferedReader br = new BufferedReader(new FileReader("F:/CacTest/test.txt"));
            while((str = br.readLine())!=null){
                StringBuffer string = new StringBuffer().append(str);
                int len = string.length();
                int flag;
                string.delete(len-1, len);
                string.append('#');
                String t = operate.caculate(string);
                System.out.println(str);
                System.out.println("请输入答案：");
                Scanner sc = new Scanner(System.in);
                String StuResult = null;
                StuResult = sc.nextLine();
                if(t.equals(StuResult))
                {
                    System.out.println("恭喜你答对了！");
                    System.out.println("是否进行下一题，是输入1，否输入2。");
                    flag = sc.nextInt();
                    if(flag == 2) break;
                }
                else
                {
                    System.out.println("答错啦，请再接再厉，正确答案为：" + t);
　　　　　　　　　　　 System.out.println("是否进行下一题，是输入1，否输入2。");
                    flag = sc.nextInt();
                    if(flag == 2) break;
                }
            }
            br.close();
        }catch(FileNotFoundException e2){
            e2.printStackTrace();
        }catch(IOException e3){
            e3.printStackTrace();
        }    
    }
}

 

 

运行结果

 

四则运算思路：整数的四则运算很简单，用当前得到的运算符与ChaStack栈顶运算符比较优先级：（A表示当前得到的运算符，B表示ChaStack栈顶运算符）

　　   　　　　若A优先级高于B，则将A放入栈顶；

　　  　　　　 若A优先级等于B或A优先级小于B，则pop出B，相应pop出两个运算数进行运算，将运算结果push进操作数栈；

　　   　　　　各个优先级  '(' > '*' = '/' > '+' = '-' > ')' > '#'

　　　以上为整数四则运算的思路，将分数加入四则运算其实很简单，将操作数栈变为分子栈和分母栈，每读入一个操作数将其存放在分子栈中，自动将其分母设为1并压入分母栈，然后对每次的加减乘除都进行分数形式的运算，最后只需要将运算结果进行处理，即可输出想对应的结果。(2016218051徐怡琳)

 

5.软件工程和计算机科学的区别

　　软件工程与计算机科学与技术的区别，二者首先都属于工科型专业，一般学校这两个专业是相辅相成的。首先从名字上可以看出一些，计算机科学与技术专业里面有科学二字，它可以称之为科学，也可以是技术，是介于科学与工程之间的定义。而软件工程名字上只是单单的工程类。从教学计划上看，计算机科与技术专业的课程上除了与软件工程学一样的高级程序设计、数据结构、计算机网络、操作系统、计算机组成原理外，还学电工基础、数字电路、模拟电路、数字信号处理等软件工程没有的课。相比于软件工程，计算机科学与技术专业好像更加偏“硬件”。软件工程专业的学费上在大三的时候很多学校会增加，这时候软件工程专业的会有相关的实践，偏向于软件开发。找工作上，计算机科学与技术如果不喜欢软件还可以找一些硬件的的工作，也基本能应付得来。而软件工程若不是跨专业找工作，大多都是从事软件开发相关的专业。(2016218051徐怡琳)

转载于:https://www.cnblogs.com/wxly/p/5859984.html