我的第2次做業：熟悉使用工具

時間 2019-11-12

標籤我的熟悉使用工具简体版

原文原文鏈接

初始化及克隆倉庫，建立項目

初始化並克隆倉庫:git

40184@Rongz MINGW32 ~
$ cd e:

40184@Rongz MINGW32 /e
$ cd RongGit/

40184@Rongz MINGW32 /e/RongGit
$ git init
Initialized empty Git repository in E:/RongGit/.git/

40184@Rongz MINGW32 /e/RongGit (master)
$ git clone https://github.com/Cherish599/AchaoCalculator.git
Cloning into 'AchaoCalculator'...
remote: Enumerating objects: 6, done.
remote: Counting objects: 100% (6/6), done.
remote: Compressing objects: 100% (4/4), done.
remote: Total 6 (delta 0), reused 4 (delta 0), pack-reused 0
Unpacking objects: 100% (6/6), done.

建立項目:github

代碼編寫

工具類 Result：

用途封裝代碼執行結果c#

/// <summary>
/// 前綴表達式字符串
/// </summary>
internal StringBuilder infixFormula;

/// <summary>
/// 後綴表達式隊列
/// </summary>
internal Queue<string> formulaQueue;

/// <summary>
/// 計算結果
/// </summary>
internal int result;

中綴表達式式生成：

解決思路：數組

問題化簡：經過觀察咱們知道，每個表達式都有三部分組成——乘除法表達式部分、加減法表達式部分、和鏈接兩者的加減號部分。如1+2+3 * 4/2，就是1+2和 3 * 4/2及+組成。因此咱們大致思路就是建立兩個分別生成乘除法表達式和加減法表達式的函數，而後用加減法將他們組合起來。dom

multipleFormulaGenerator(int count)函數ide

給定一個乘除法表達式所含操做數的個數，生成一個隨機的乘除法表達式，並以隊列的形式返回函數

好比:count=3，輸出多是1 * 2 * 3工具

count=4，輸出多是1 * 2 * 3 / 2post

解決被除數和除數整除的問題思路
1. 先生成一個數 num ，將它放入隊列
  1. 生成一個符號（* 或 /）
    1. 若是是 * ：新生成一個數 num2，並與以前 num 相乘，用 num 記錄相乘的結果
    2. 若是是 / ：尋找一個 num 的因式做爲除數
2. 輸出隊列
解決尋找一個數全部因式的思路（chooseRandomFactor(int num)實現）
1. i 從 1 遍歷到根號 num
2. 若是 num % i==0
3. 將 i 和 num/i 存入一個數組（存入的兩個數就是num的兩個因式）
4. 隨機返回數組中的一個因式，就獲得了 num 的一個隨機的因式

/// <summary>
/// 給定一個乘除法表達式所含操做數的個數，生成一個隨機的乘除法表達式，並以隊列的形式返回
/// </summary>
/// <param name="count"> 符號數個數 </param>
/// <returns> 乘除法表達式隊列 </returns>
public static Queue<string> multipleFormulaGenerator(int count)
{
    Queue<string> queue = new Queue<string>();
    int num = random.Next(maxNum) + 1;
    queue.Enqueue(num.ToString());
    while (--count > 0)
    {
        string option = op[2 + random.Next(2)];
        if (string.ReferenceEquals(option, "/"))
        {
            int factor = chooseRandomFactor(num);
            queue.Enqueue(option);
            queue.Enqueue(factor.ToString());
            num /= factor;
        }
        else
        {
            int num2 = random2.Next(maxNum) + 1;
            queue.Enqueue(option);
            queue.Enqueue(num2.ToString());
            num *= num2;
        }
    }
    return queue;
}

/// <summary>
/// 從一個數的全部因式中隨機選擇一個返回
/// </summary>
/// <param name="num"> 數 </param>
/// <returns> num 的一個因式 </returns>
private static int chooseRandomFactor(int num)
{
    int[] arr = new int[num + 1];
    int size = 0;
    for (int i = 1; i <= Math.Sqrt(num); i++)
    {
        if (num % i == 0)
        {
            arr[size++] = i;
            arr[size++] = num / i;
        }
    }
    int r = random2.Next(size);
    return arr[r];
}

additionAndSubtractionFormulaGenerator(int count)函數

給定一個加減法表達式所含操做數的個數，生成一個隨機的加減法表達式，並以隊列的形式返回

count 含義如 multipleFormulaGenerator() 的 count

思路簡單，看代碼

/// <summary>
/// 給定一個加減法表達式所含操做數的個數，生成一個隨機的加減法表達式，並以隊列的形式返回
/// </summary>
/// <param name="count"> 符號數個數 </param>
/// <returns> 加減法表達式隊列 </returns>
public static Queue<string> additionAndSubtractionFormulaGenerator(int count)
{
    Queue<string> queue = new Queue<string>();
    int num = random.Next(maxNum) + 1;
    queue.Enqueue(num.ToString());
    while (--count > 0)
    {
        string option = op[random.Next(2)];
        queue.Enqueue(option);
        queue.Enqueue((random.Next(maxNum) + 1).ToString());
    }
    return queue;
}

formulaMaker()函數

隨機生成多個乘除法表達式和加減法表達式，並將他們用 + 或 - 號拼接

/// <summary>
/// 表達式生成器
/// </summary>
/// <returns> 中綴表達式隊列 </returns>
public static Result formulaMaker()
{
    Queue<string> queue = new Queue<string>();
    StringBuilder sb = new StringBuilder();
    int maxNumCount2 = maxNumCount;
    while (maxNumCount2-- > 0)
    {
        string option = op[random.Next(2)];
        int nextBoolean = random.Next(0,1);

        if (nextBoolean==0)
        {
            Queue<string> queue1 = multipleFormulaGenerator(random.Next(3) + 1);
            mergeQueue(queue, queue1);
        }
        else
        {
            mergeQueue(queue, additionAndSubtractionFormulaGenerator(random2.Next(3) + 1));
        }
        if (maxNumCount2 != 0)
        {
            queue.Enqueue(op[random.Next(2)]);
        }
    }
    foreach (string s in queue)
    {
        sb.Append(s);
    }
    return new Result(sb, queue);
}

changeToPostfix(Queue queue)函數

將formulaMaker()生成的中綴表達式，轉化爲後綴表達式（4+4/2 * 3-5 * 2 --> 442/3 * +52 * - ）

若是是操做數直接輸出到操做數隊列
若是是操做符
1. 操做符棧爲空直接輸出到操做符棧
2. 若是不爲空，循環判斷若是操做符棧頂的符號優先級大於等於當前符號，則將操做符棧的符號輸出，而後再將操做數入棧。不然將操做數壓棧
將操做符棧的全部元素輸出

/// <summary>
/// 中綴表達式轉後綴表達
/// </summary>
/// <param name="queue"> 中綴表達式隊列 </param>
/// <returns> 後綴表達式堆棧 </returns>
public static Queue<string> changeToPostfix(Queue<string> queue)
{
    Queue<string> queue2 = new Queue<string>(); // 保存操做數
    Stack<string> stack2 = new Stack<string>(); // 保存操做符
    while (queue.Count > 0)
    {
        string symbol = queue.Dequeue();
        if (precedence(symbol) > 0)
        { //檢查symbol是不是一個操做數
            while (stack2.Count > 0 && precedence(stack2.Peek()) >= precedence(symbol))
            {
                queue2.Enqueue(stack2.Pop());
            }
            stack2.Push(symbol);
        }
        else
        { //symbol 不是一個操做數
            queue2.Enqueue(symbol);
        }
    }
    while (stack2.Count > 0)
    {
        queue2.Enqueue(stack2.Pop());
    }
    return queue2;
}

calculate(Queue stack)

將 changeToPostfix()生成的後綴表達式進行計算求值

若是不是操做符直接輸出到操做數棧
若是是操做符，將操做數棧棧頂的兩個操做數彈出作運算，存入操做數棧
3.最後將操做數棧頂的的元素彈出

/// <summary>
/// 計算函數
/// 用於計算後綴表達式的值
/// </summary>
/// <param name="queue"> 後綴表達式堆棧 </param>
/// <returns> 計算結果 </returns>
public static int calculate(Queue<string> queue)
{
    Stack<string> stack1 = new Stack<string>(); // 保存操做數
    Stack<string> stack2 = new Stack<string>(); // 保存操做符
    foreach (string symbol in stack)
    {
        if (!symbol.Equals("+") && !symbol.Equals("-") && !symbol.Equals("/") && !symbol.Equals("*"))
        {
            stack1.Push(symbol);
        }
        else
        {
            int a = int.Parse(stack1.Pop()), b = int.Parse(stack1.Pop());
            switch (symbol)
            {
                case "+":
                    stack1.Push((a + b).ToString());
                    break;
                case "-":
                    stack1.Push((b - a).ToString());
                    break;
                case "*":
                    stack1.Push((a * b).ToString());
                    break;
                default:
                    stack1.Push((b / a).ToString());
                    break;
            }
        }
    }
    return int.Parse(stack1.Pop());
}

輸出到文件

/// <summary>
/// 將題目和答案打印到文件
/// 默認目錄 E:\\
/// </summary>
public static void printToFile()
{
    int i = 1000, k = 1;
    string pathProblem = "E:\\Problem.txt", pathAnswer = "E:\\Answer.txt";
    FileStream f1 = new FileStream(pathProblem, FileMode.Create, FileAccess.ReadWrite);
    FileStream f2 = new FileStream(pathAnswer, FileMode.Create, FileAccess.ReadWrite);
    StreamWriter sw1 = new StreamWriter(f1);
    StreamWriter sw2 = new StreamWriter(f2);
    while (i-- > 0)
    {
        Result result = formulaMaker();
        Queue<string> queue = changeToPostfix(result.formulaQueue);
        int res = calculate(queue);
        result.result = res;

        sw1.Write(k + "." + result.infixFormula + "=\r\n");
        sw2.Write(k++ + "." + result.getResult() + "\r\n");
    }
    sw1.Close();
    sw2.Close();
}

單元測試

建立測試項目：

添加引用：

運行測試：和結果相符

效能工具

修改主函數：

public static void Main(string[] args)
{
    for (int i = 0; i < 10000000; i++) {
        Result result = formulaMaker();
        Queue<string> postfixQueue = changeToPostfix(result.FormulaQueue);
        int res = calculate(postfixQueue);
        Console.WriteLine("formula:" + result.infixFormula);
        Console.WriteLine("result:" + res);
    }
}

效能分析報告：

建立詳細的報告：

提交代碼

40184@Rongz MINGW32 /e/RongGit (master)
$ git add AchaoCalculator
warning: adding embedded git repository: AchaoCalculator
hint: You've added another git repository inside your current repository.
hint: Clones of the outer repository will not contain the contents of
hint: the embedded repository and will not know how to obtain it.
hint: If you meant to add a submodule, use:
hint:
hint:   git submodule add <url> AchaoCalculator
hint:
hint: If you added this path by mistake, you can remove it from the
hint: index with:
hint:
hint:   git rm --cached AchaoCalculator
hint:
hint: See "git help submodule" for more information.

40184@Rongz MINGW32 /e/RongGit (master)
$ git commit -m "release version"
[master (root-commit) 31ec8d9] release version
 1 file changed, 1 insertion(+)
 create mode 160000 AchaoCalculator

建立本身的存儲庫（略）

這時候執行上面兩條語句，git會提示403，也就是無權限訪問

由於git不知道你是誰，因此要給git一個公鑰，本身留個私鑰，具體配置看下面博客：

https://www.cnblogs.com/wmr95/p/7852832.html

以後提交就沒有問題了：

40184@Rongz MINGW32 /e/RongGit/AchaoCalculator (master)
$ git push -u origin master
Counting objects: 17, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (14/14), done.
Writing objects: 100% (17/17), 6.70 KiB | 190.00 KiB/s, done.
Total 17 (delta 1), reused 0 (delta 0)
remote: Resolving deltas: 100% (1/1), done.
To github.com:Zrz458/ZrzCalculator.git
 * [new branch]      master -> master
Branch master set up to track remote branch master from origin.