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

时间  2019-11-12
标签 我的 熟悉 使用 工具 繁體版
原文   原文链接

Gayhub 项目地址html

初始化及克隆仓库，建立项目

初始化并克隆仓库: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

  1. multipleFormulaGenerator(int count)函数ide

    给定一个乘除法表达式所含操做数的个数，生成一个随机的乘除法表达式，并以队列的形式返回函数

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

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

    1. 解决被除数和除数整除的问题思路
      1. 先生成一个数 num ，将它放入队列
        1. 生成一个符号（* 或 /）
          1. 若是是 * ：新生成一个数 num2，并与以前 num 相乘 ，用 num 记录相乘的结果
          2. 若是是 / ：寻找一个 num 的因式做为除数
      2. 输出队列
    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];
}

  2. 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;
}

  3. 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);
}

  4. changeToPostfix(Queue queue)函数

    将formulaMaker()生成的中缀表达式，转化为后缀表达式（4+4/2 * 3-5 * 2 --> 442/3 * +52 * - ）

    1. 若是是操做数直接输出到操做数队列
    2. 若是是操做符
      1. 操做符栈为空直接输出到操做符栈
      2. 若是不为空，循环判断若是 操做符栈顶的符号优先级大于等于当前符号，则将操做符栈的符号输出，而后再将操做数入栈。不然将操做数压栈
    3. 将操做符栈的全部元素输出
    /// <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;
}

  5. calculate(Queue stack)

    将 changeToPostfix()生成的后缀表达式进行计算求值

    1. 若是不是操做符直接输出到操做数栈
    2. 若是是操做符，将操做数栈栈顶的两个操做数弹出作运算，存入操做数栈
      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.

总结

思路比代码重要，思路不对累死狗，思路对了很简单

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程