码迷,mamicode.com
首页 > 其他好文 > 详细

结对开发—四则运算

时间:2020-06-11 16:30:31      阅读:42      评论:0      收藏:0      [点我收藏+]

标签:==   计算   compare   mat   scale   随机   ash   出现   set   

Cal.java:

package caculator_core;

 

import java.util.HashSet;

import java.util.Random;

import java.util.Scanner;

 

public class Calc {

      

       public static void main(String[] args) {

              System.out.println("-------输入0选择默认配置,输入1选择自定义配置-------");

              Scanner scanner = new Scanner(System.in);

              CalCore calCore = new CalCore();

              int number = scanner.nextInt();

              switch (number) {

              case 0:

                     calCore =new CalCore();

                     break;

              case 1:

                     System.out.println("-------请输入运算符总数------");

                     int numberTotal = scanner.nextInt();

                     System.out.println("-------请输入运算式个数------");

                     int formulaTotal = scanner.nextInt();

                     System.out.println("-------请输入最大运算数字------");

                     int numberRange = scanner.nextInt();

                     System.out.println("-------请输入运算结果最大值------");

                     int maxResult = scanner.nextInt();

                     System.out.println("-------是否包含乘除法------");

                     boolean includeMulAndDiv = false;

                     if(scanner.next().equals("是")) {

                            includeMulAndDiv = true;

                     }else {

                            includeMulAndDiv = false;

                     }

                     System.out.println("-------是否包含负数------");

                     boolean includeNegNum = false;

                     if(scanner.next().equals("是")) {

                            includeNegNum = true;

                     }else {

                            includeNegNum = false;

                     }

                     calCore = new CalCore(numberTotal,formulaTotal,numberRange,maxResult,includeMulAndDiv,includeNegNum);

              default:

                     break;

              }

             

              HashSet<String> formulas = calCore.generateFormulas();

              double [] arr = calCore.generateAnswers(formulas);

              System.out.println(calCore.outputFormulas(formulas));

              System.out.println(calCore.outputAnswers(arr));

       }

}

CalCore.java:

package caculator_core;

 

import java.io.File;

import java.io.FileWriter;

import java.math.BigDecimal;

import java.math.RoundingMode;

import java.util.HashSet;

import java.util.Random;

import java.util.Stack;

 

 

public class CalCore {

      

       //运算符总数

       private int numberTotal;

       //运算式个数

       private int formulaTotal;

       //数字范围

       private int numberRange;

       //运算结果最大值

       private int maxResult;

       //是否包含乘除法

       private boolean includeMulAndDiv;

       //是否包含负数

       private boolean includeNegNum;

       public CalCore() {

              this.numberTotal = 2;

              this.formulaTotal = 10;

              this.numberRange = 100;

              this.maxResult = 100;

              this.includeMulAndDiv =false;

              this.includeNegNum = false;

       }

       public CalCore(int numberTotal,int formulaTotal,int numberRange,int maxResult,boolean includeMulAndDiv,boolean includeNegNum) {

              this.numberTotal = numberTotal;

              this.formulaTotal = formulaTotal;

              this.numberRange = numberRange;

              this.maxResult = maxResult;

              this.includeMulAndDiv = includeMulAndDiv;

              this.includeNegNum = includeNegNum;

       }

       //生成随机数

       public double getRandomNumber() {

              Random random = new Random();

               

              if(this.includeNegNum) {

                     double d = (random.nextInt(this.numberRange)+1)*(random.nextDouble()>0.5?1.0:-1.0)*(random.nextDouble());

                     BigDecimal bg = new BigDecimal(d).setScale(2, RoundingMode.UP);

                     return bg.doubleValue();

              }else {

                     double d =(random.nextInt(this.numberRange)+1)*(random.nextDouble());

                     BigDecimal bg = new BigDecimal(d).setScale(2, RoundingMode.UP);

                     return bg.doubleValue();

              }

       }

       //生成随机运算符

       public String getRandomOperator() {

              Random random = new Random();

              String [] opreations = {"+","-","*","/"};

              return opreations[random.nextInt((this.includeMulAndDiv == true)?4:2)];

       }

       //生成算式

       public String generateFormula() {

              String formula ="";

              for(int i=0;i<this.numberTotal;i++) {

                     if(i>=this.numberTotal-1) {

                            formula += isNegNum(this.getRandomNumber());

                            continue;

                     }

                     formula += isNegNum(this.getRandomNumber())+" "+this.getRandomOperator() +" ";

              }

              return formula;

       }

       //如果负数就加括号

       private String isNegNum(double randomNumber) {

              if(randomNumber<0) {

                     return "("+randomNumber +")";

              }

              return ""+randomNumber;

       }

       //生成算式集合

       public HashSet<String> generateFormulas(){

              HashSet<String> set = new HashSet<String>();

              while(set.size()<=this.formulaTotal) {

                     String formula = this.generateFormula();

                     if(this.maxResult>= getAnswer(formula)) {

                            set.add(formula);

                     }

              }

              return set;

       }

       //生成答案

       public double[] generateAnswers(HashSet<String> set) {

              double [] arr = new double[set.size()];

              int i=0;

              for(String str:set) {

                     arr[i++] = getAnswer(str);

              }

              return arr;

       }

       //打印算式

       public String outputFormulas(HashSet<String> set) {

              File file = new File("result.txt");

              try {

                     FileWriter fw = new FileWriter(file);

                     for(String str:set) {

                            System.out.println(str);

                            fw.write(str+"\n");

                     }

                     fw.close();

              } catch (Exception e) {

                     System.out.println("Error"+e.getMessage());

                     System.exit(0);

              }

              return file.getAbsolutePath();

       }

       //打印答案

       public String outputAnswers(double[]arr) {

              File file = new File("answer.txt");

              try {

                     FileWriter fw = new FileWriter(file);

                     for(int i=0;i<arr.length;i++) {

                            fw.write(arr[i]+"\n");

                     }

                     fw.close();

              } catch (Exception e) {

                     System.out.println("Error"+e.getMessage());

                     System.exit(0);

              }

              return file.getAbsolutePath();

       }

       public  Double getAnswer(String formula) {

              int length=0;

              String [] formulaArr = formula.split(" ");

              String operators = "+-*/";

              Stack<Double> opNumbers = new Stack<Double>();

              Stack<String> opOperators = new Stack<String>();

              opOperators.add("#");//字符栈存个#,防止栈空

              while(length<formulaArr.length) {

                     String op = formulaArr[length++];

                     //如果是运算符,判断优先级

                     //indexof方法,判断字符串第一次出现的位置,找不到为-1

                     if(operators.indexOf(op) >-1) {

                            String sign = opOperators.peek();//顶部出栈

                            int priority = compare(op,sign);//比较优先级

                            if(priority>=0) {//如果要入栈的运算符优先级高或相等,出栈两个数字,和之前的运算符计算后数字和字符分别入栈

                                   opNumbers.add(compute(opOperators,opNumbers));

                                   opOperators.add(op);

                            }else {//入栈运算符优先级低,直接入栈

                                   opOperators.add(op);

                                  

                            }

                            continue;

                     }

                     //若是数字,则入栈

                     opNumbers.add(Double.parseDouble(op.replace("(", "").replace(")", "")));//将括号忽略掉

              }

              while (opOperators.peek()!="#") {

                     opNumbers.add(compute(opOperators, opNumbers));

              }

              return opNumbers.pop();

 

       }

 

       private  Double compute(Stack<String> opOperators, Stack<Double> opNumbers) {

              double num2 = opNumbers.pop();

              double num1 = opNumbers.pop();

              String _op = opOperators.pop();

              double result =0.0;

              switch(_op) {

              case "+":

                     result=num1+num2;

                     break;

              case "-":

                     result =num1-num2;

                     break;

              case "*":

                     result =num1*num2;

                     break;

              case "/":

                     result =num1/num2;

                     break;

              }

              BigDecimal bg = new BigDecimal(result).setScale(2, RoundingMode.UP);

              result = bg.doubleValue();

              return result;

       }

 

       private  int compare(String operator1, String operator2) {

              int res=0;

              switch(operator1) {

              case "+":

              case "-":

                     if(operator2.equals("+")||operator2.equals("-")||operator2.equals("*")||operator2.equals("/")) {

                            res=1;

                     }else {

                            res=-1;

                     }

                     break;

              case "*":

              case "/":

                     if(operator2.equals("*")||operator2.equals("/")) {

                            res=1;

                     }else {

                            res=-1;

                     }

                     break;   

              }

              return res;

       }

}

结对开发—四则运算

标签:==   计算   compare   mat   scale   随机   ash   出现   set   

原文地址:https://www.cnblogs.com/wyppaa/p/13093671.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!