自動生成小學四則運算題目

Github項目地址：https://github.com/yyffish/ArithmeticGenerators

結對項目組成員：18軟4庾藝鋒（3118005117）、18軟4王澤鑫（3118005107）

 項目相關要求

• • 使用 -n 參數控制生成題目的個數
  • 使用 -r 參數控制題目中數值（自然數、真分數和真分數分母）的范圍
  • 生成的題目中計算過程不能產生負數，也就是說算術表達式中如果存在形如e1− e2的子表達式，那么e1≥ e2
  • 生成的題目中如果存在形如e1÷ e2的子表達式，那么其結果應是真分數
  • 每道題目中出現的運算符個數不超過3個
  • 程序一次運行生成的題目不能重復，即任何兩道題目不能通過有限次交換+和×左右的算術表達式變換為同一道題目
  • 在生成題目的同時，計算出所有題目的答案，並存入執行程序的當前目錄下的Answers.txt文件
  • 程序應能支持一萬道題目的生成
  • 程序支持對給定的題目文件和答案文件，判定答案中的對錯並進行數量統計

---

困難及解決方法

使用 -n 參數控制生成題目的個數，使用 -r 參數控制題目中數值（自然數、真分數和真分數分母）的范圍

• • 用戶在前端輸入題目數量和數值范圍
  • 提交表單到servlet進行處理
  • 返回生成的算式到前端

生成的題目中計算過程不能產生負數，也就是說算術表達式中如果存在形如e1− e2的子表達式，那么e1≥ e2

• • 在進行減法運算時，若e1<e2，返回-1
  • 在添加到List前進行判斷，若算式結果為負數，則不添加到List中

生成的題目中如果存在形如e1÷ e2的子表達式，那么其結果應是真分數

• • 在進行除法運算時，若e1>e2，返回-1
  • 在添加到List前進行判斷，若算式結果為負數，則不添加到List中

每道題目中出現的運算符個數不超過3個

• • 由此可以得知運算符數量為1~3個
  • 參數為2~4個
  • 用隨機數判斷運算符數量和參數數量

程序一次運行生成的題目不能重復，即任何兩道題目不能通過有限次交換+和×左右的算術表達式變換為同一道題目

• • 用判重函數判斷表達式列表中是否有重復項

在生成題目的同時，計算出所有題目的答案，並存入執行程序的當前目錄下的Answers.txt文件

• • 將含有括號的表達式轉為逆波蘭表達式
  • 將逆波蘭表達式入棧計算結果
  • 在添加到List前判重和判負
  • 將答案List通過IO流寫入到txt文件中

程序應能支持一萬道題目的生成

• • 生成1w到題目測試沒問題

程序支持對給定的題目文件和答案文件，判定答案中的對錯並進行數量統計

• • 用戶可以點擊檢查答案
  • 默認檢查桌面的Answers.txt和Exercises.txt
  • 對比答案並生成餅狀圖

---

 項目結構

---

 關鍵代碼or設計說明

通過IO流寫入到txt文件中

package com.AG.dao;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class FileUtils {

    /**
     * 創建一個txt文件
     * 
     * @param filePath 文件路徑
     * @return 創建成功返回true，已存在返回false
     */
    public boolean creatFile(String filePath) {
        boolean flag = false;
        File file = new File(filePath);
        if (file.exists()) {
            try {
                file.createNewFile();
            } catch (IOException e) {
                // TODO: handle exception
                e.printStackTrace();
            }
            flag = true;
        }
        return flag;
    }

    /**
     * 讀取題目文件或答案文件 都是一行一行讀取
     * 
     * @param filePath 文件路徑
     * @return 返回題目或答案List
     */
    public List<String> readTxtFile(String filePath) {
        List<String> list = new ArrayList<String>();
        String thisLine = null;
        File file = new File(filePath);
        if (file.exists() && file.isFile()) {
            try {
                BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
                while ((thisLine = bufferedReader.readLine()) != null) {
                    list.add(thisLine);
                }
                bufferedReader.close();
            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }
        }
        return list;
    }

    /**
     * 讀txt文件
     * 
     * @param list
     * @param filePath
     * @return
     */
    public boolean writeTxtFile(List<String> list, String filePath) {
        boolean flag = false;
        File file = new File(filePath);
        try {
            if (!file.exists()) {
                file.createNewFile();
            }
            BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
            for (String string : list) {
                bufferedWriter.write(string);
                bufferedWriter.newLine();
            }
            bufferedWriter.close();
        } catch (IOException e) {
            // TODO: handle exception
            e.printStackTrace();
        }
        flag = true;
        return flag;
    }

}

 通過逆波蘭表達式計算結果

• 如有表達式 1 2 3 + +
• 1 2 3 依次入棧
• 遇到 + 號，2 3 出棧 進行加法運算 結果為 5
• 5入棧 
• 遇到 + 號， 5 1出棧 再進行加法運算 結果為 6
• 棧空 結果為6

    /**
     * 通過逆波蘭表達式計算結果
     *
     * @param 表達式
     * @return Stringl類型的計算結果
     */
    private String calcRevPolishNotation(String express) {
        Stack<String> stack = new Stack<>();
        String[] expressArr = express.split(" ");
        for (int i = 0; i < expressArr.length; i++) {
            if (expressArr[i].matches("[0-9]+/[0-9]+")) {
                stack.push(expressArr[i]);
                // + - * / 運算符的處理
            } else if (expressArr[i].matches("[\\+\\-\\*\\÷]")) {
                String k1 = stack.pop();
                String k2 = stack.pop();
                // 計算結果
                String res = calcValue(k1, k2, expressArr[i]);
                stack.push(res);
            }

        }
        return stack.pop();
    }

將中綴表達式轉換為后綴表達式（逆波蘭表達式）

• 就是通過棧來講公式轉為逆波蘭表達式 如 1 + ( 2 + 3 ) => 1 2 3 + +
• 數字直接入棧
• 如果是運算符 則將棧中的兩個數字出棧進行運算
• 若是括號 我還沒理解

    /**
     * 將中綴表達式轉換為后綴表達式（逆波蘭表達式）
     *
     * @param express
     * @return
     */
    private String transfer(String express) {
        Stack<String> stack = new Stack<>();
        List<String> list = new ArrayList<>();
        String[] expressArr = express.split(" ");
        for (int i = 0; i < expressArr.length; i++) {
            if (expressArr[i].matches("[0-9]+/[0-9]+")) {
                list.add(expressArr[i]);
            } else if (expressArr[i].matches("[\\+\\-\\*\\÷]")) {
                // 如果stack為空
                if (stack.isEmpty()) {
                    stack.push(expressArr[i]);
                    continue;
                }
                // 不為空

                // 上一個元素不為（，且當前運算符優先級小於上一個元素則，將比這個運算符優先級大的元素全部加入到隊列中
                while (!stack.isEmpty() && !stack.lastElement().equals("(")
                        && !comparePriority(expressArr[i], stack.lastElement())) {
                    list.add(stack.pop());
                }
                stack.push(expressArr[i]);
            } else if ("(".equals(expressArr[i])) {
                // 遇到左小括號無條件加入
                stack.push(expressArr[i]);
            } else if (")".equals(expressArr[i])) {
                // 遇到右小括號，則尋找上一堆小括號，然后把中間的值全部放入隊列中
                while (!("(").equals(stack.lastElement())) {
                    list.add(stack.pop());
                }
                // 上述循環停止，這棧頂元素必為"("
                stack.pop();
            }
        }
        // 將棧中剩余元素加入到隊列中
        while (!stack.isEmpty()) {
            list.add(stack.pop());
        }
        StringBuffer stringBuffer = new StringBuffer();
        // 變成字符串
        for (String s : list) {
            stringBuffer.append(s + " ");
        }
        return stringBuffer.toString();
    }

輾轉相除法求公約數

    /**
     * 輾轉相除法求公約數
     *
     * @param numerator   分子
     * @param denominator 分母
     * @return 最大公約數
     */
    public Integer gcd(Integer numerator, Integer denominator) {
        int temp;
        while (denominator > 0) {
            temp = numerator % denominator;
            numerator = denominator;
            denominator = temp;
        }
        return numerator;
    }

比較兩條表示式是否相同

• 通過Set的不可重復來校驗參數列表ParameterList和運算符列表OperatorList是否重復
• 因為想不出可以區別兩個表達式的算法，我們就折衷了一下，只要判斷兩個表達式的操作數還有運算符完全相同，則判定兩個表達式相同。
• 這種判斷方式是有問題的，會把一些不是相同的表達式誤判為相同，黔驢技窮之下，顧不了這么多了，能滿足需求就行了，以后有新的想法再進行優化。

    /**
     * 比較express表達式是否存在於examList表達式列表中
     *
     * @param examList 表達式列表
     * @param express  表達式
     * @return 結果 存在返回true 不存在返回false
     */
    public Boolean isExistList(List<Expression> examList, Expression express) {
        int len = examList.size();
        for (int i = 0; i < len; i++) {
            if (isSame(express, examList.get(i)))
                return true;
        }
        return false;
    }

    /**
     * 比較兩條表示式是否相同
     * 
     * @param express1 表達式1
     * @param express2 表達式2
     * @return 相同返回true，否則返回false
     */
    private Boolean isSame(Expression express1, Expression express2) {
        // 運算符數目不相等，直接返回
        if (express1.getOperatorList().size() != express2.getOperatorList().size())
            return false;
        Set<Map<Integer, Integer>> parameterSet = new HashSet<Map<Integer, Integer>>();
        Set<String> operatorSet = new HashSet<String>();
        List<Map<Integer, Integer>> parameterList = express1.getParameterList();// 獲取表達式1的參數列表
        List<String> operatorList = express1.getOperatorList();// 獲取表達式1的操作符列表
        int len = operatorList.size();
        // 將參數和操作符列表分別加進Set
        for (int i = 0; i < len; i++) {
            operatorSet.add(operatorList.get(i));
            parameterSet.add(parameterList.get(i));
        }
        parameterSet.add(parameterList.get(len));
        parameterList = express2.getParameterList();// 獲取表達式2的參數列表
        operatorList = express2.getOperatorList();// 獲取表達式2的操作符列表
        for (int i = 0; i < len; i++) {
            if (!operatorSet.contains(operatorList.get(i)) || !parameterSet.contains(parameterList.get(i))) {
                return false;
            }
        }
        if (!parameterSet.contains(parameterList.get(len)))
            return false;
        return true;
    }

---

 運行測試

向服務器發送請求 http://localhost:8080/ArithmeticGenerators/tableForm.jsp

用戶輸入題目數量和最大值，提交form表達，發送exam請求

 

 

 生成從1~10的題目

 

 隨意修改幾個答案后進行答案校驗

---

 PSP

因為項目用時較長，以下時間都是預估的

PSP2.1	Personal Software Process Stages	預估耗時（分鍾）	實際耗時（分鍾）
Planning	計划	90	90
· Estimate	· 估計這個任務需要多少時間	90	90
Development	開發	2140	2140
· Analysis	· 需求分析 (包括學習新技術)	30	30
· Design Spec	· 生成設計文檔	60	60
· Design Review	· 設計復審 (和同事審核設計文檔)	20	20
· Coding Standard	· 代碼規范 (為目前的開發制定合適的規范)	30	30
· Design	· 具體設計	120	120
· Coding	· 具體編碼	2000	2000
· Code Review	· 代碼復審	30	30
· Test	· 測試（自我測試，修改代碼，提交修改）	50	50
Reporting	報告	110	110
· Test Report	· 測試報告	60	60
· Size Measurement	· 計算工作量	20	20
· Postmortem & Process Improvement Plan	· 事后總結, 並提出過程改進計划	30	30
	合計	2540	2540

---

項目總結

• 作為結對項目，最重要的是合作。我認為這次不足的就是隊友之間的相互配合了。雖然有疫情的原因，不能夠面對面交流，經常出現隊友不能理解我的思路而不能編寫出合適的代碼。在這方面還是需要多項有經驗的同學請教。
• 數據結構定義比較混亂，應該少使用Map和List，應盡量定義為數組
• 本題的唯一算法就是逆波蘭表達式的轉換，盡管研究了很久，但還是看不懂，只能copy后稍微修改一下
• 因為數據結構定義比較混亂，可拓展性有待考量。