4月1号打卡

2021.4.1 笨阶乘

题目描述

通常，正整数 n 的阶乘是所有小于或等于 n 的正整数的乘积。例如，factorial(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1。

相反，我们设计了一个笨阶乘 clumsy：在整数的递减序列中，我们以一个固定顺序的操作符序列来依次替换原有的乘法操作符：乘法(*)，除法(/)，加法(+)和减法(-)。

例如，clumsy(10) = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1。然而，这些运算仍然使用通常的算术运算顺序：我们在任何加、减步骤之前执行所有的乘法和除法步骤，并且按从左到右处理乘法和除法步骤。

另外，我们使用的除法是地板除法（floor division），所以 10 * 9 / 8 等于 11。这保证结果是一个整数。

实现上面定义的笨函数：给定一个整数 N，它返回 N 的笨阶乘。

示例 1：

输入：4
输出：7
解释：7 = 4 * 3 / 2 + 1
示例 2：

输入：10
输出：12
解释：12 = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1

推导通项公式

对于地板除法（floor division）来说，除了3 x 2 / 1和4 x 3 / 2，其余的 (n + 2) x (n + 1) / n 都等于 n + 3，对于笨阶乘 除了开头的第一部分的乘除运算 (n + 2) x (n + 1) / n 会被中间的 + 运算约掉，举个例子 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1,其中 + 7 - 6 x 5 / 4约掉，其实只需要考虑最后一次 x 与 / 后面的运算,但需要注意的是如果是 4 3 2 或者 3 2 1 做乘除的话会有不同

由此，除了当 n 为 1 2 3 4 时的特殊情况,可以推出，当 n % 4 为 0 时，最终结果为 n + 1；为 1 或 2 时，最终结果为 n + 2；为 3 时，最终结果为 n - 1。

代码如下：

public int clumsy(int n) {
	if(n == 1) return 1;
	if(n == 2) return 2;
	if(n == 3) return 6;
	if(n == 4) return 7;
	if(n % 4 == 0) return n + 1;
	if(n % 4 == 3) return n - 1;
	return n + 2;
    }  

波兰表达式解法

思路是用字符串保存完整表达式，再利用波兰表达式计算值，这里我用的是逆波兰表达式的解法。

代码如下：

public class PolandNotation {
    public static void main(String[] args) {
        PolandNotation p = new PolandNotation();
        System.out.println(p.clumsy(10));
//
    }

    public int clumsy(int n){
        String s = "";
        int count = 0;
        for(int i = n;i >= 1;i--){
            if(i == 1)
                 s = s + "1";
            else {
                if(count % 4 == 0) s = s + i + "*";
                if(count % 4 == 1) s = s + i + "/";
                if(count % 4 == 2) s = s + i + "+";
                if(count % 4 == 3) s = s + i + "-";
            }
            count++;
        }
        System.out.println(s);
        return calculate(toInfix(s));
    }

    //计算后缀表达式
    public int calculate(ArrayList<String> arr){
        Stack<Integer> s1 = new Stack<>();
        for(String s : arr){
            if(s.matches("\\d+")){
                s1.push(Integer.parseInt(s));
            }else{
                switch (s){
                    case "+":
                        s1.push(s1.pop() + s1.pop());
                        break;
                    case "-":
                        s1.push(-1 *(s1.pop() - s1.pop()));
                        break;
                    case "*":
                        s1.push(s1.pop() * s1.pop());
                        break;
                    case "/":
                        int num1 = s1.pop();
                        int num2 = s1.pop();
                        s1.push(num2 / num1);
                        break;
                }
            }
        }
        return s1.pop();
    }

    //将中缀表达式字符串转化为数组
    public ArrayList<String> toArr(String str){
        str = str.trim();
        ArrayList<String> arr = new ArrayList<>();
        for (int i = 0; i < str.length();) {
            if(str.charAt(i) < 48 || str.charAt(i) > 57){ //如果是字符就直接添加
                if(str.charAt(i) != ' ')
                    arr.add(str.charAt(i) + "");
                i++;
            }
            if(str.charAt(i) >= 48 && str.charAt(i) <= 57){
                StringBuilder s = new StringBuilder();
                while(i < str.length() && str.charAt(i) >= 48 && str.charAt(i) <= 57 ){ //遇到数字的话拼接起来
                    s.append(str.charAt(i));
                    i++;
                }
                arr.add(s.toString());
            }
        }
        return arr;
    }

    //将中缀表达式转换为字符串表达式
    public ArrayList<String> toInfix(String str){
        ArrayList<String> arr = toArr(str);
        Stack<String> s1 = new Stack<>();
        ArrayList<String> s2 = new ArrayList<>();
        for(String s : arr){
            if(s.matches("\\d+")){ //如果是数字直接入数字“栈”
                s2.add(s);
            }else if(isOperator(s)){ //如果是运算符

                if (!s1.empty() && !s1.peek().equals("(") && (getPriority(s) <= getPriority(s1.peek()))) {
                    while (!s1.empty() && getPriority(s) <= getPriority(s1.peek())) {
                        s2.add(s1.pop());//如果当前运算符优先级比栈低，则将栈顶符号移至留一个”栈“
                    }
                }
                //如果符号栈为空或者栈顶元素，或者当前运算符优先级高于栈顶优先级，入栈
                s1.push(s);
            }else if(isBraces(s)){
                if(s.equals("("))
                    s1.push(s);
                else{
                    while(!s1.peek().equals("(")){
                        s2.add(s1.pop());
                    }
                    s1.pop();
                }
            }
        }
        while(!s1.empty()){
            s2.add(s1.pop());
        }
        return s2;
    }

    //判断是不是运算符
    public boolean isOperator(String s){
        return s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/");
    }

    //判断是不是括号
    public boolean isBraces(String s){
        return s.equals("(") || s.equals(")");
    }

    //获取运算符的优先级
    public int getPriority(String s){
        switch (s){
            case "+":
            case "-":
                return 1;
            case "*":
            case "/":
                return 2;
            default:
                return -1;
        }
    }
}