仿LISP运算

前言：本专栏将持续更新华为OD机试题目，并进行详细的分析与解答，包含完整的代码实现，希望可以帮助到正在努力的你。关于OD机试流程、面经、面试指导等，如有任何疑问，欢迎联系我，wechat：steven_moda；email：nansun0903@163.com；备注：CSDN。

---

题目描述

LISP语言唯一的语法就是括号要配对。

形如 (OP P1 P2 …)，括号内元素由单个空格分割。

其中第一个元素OP为操作符，后续元素均为其参数，参数个数取决于操作符类型

注意：参数 P1, P2 也有可能是另外一个嵌套的 (OP P1 P2 …)

当前OP类型为add/sub/mul/div(全小写)，分别代表整数的加减乘除法。

简单起见，所以OP参数个数为2

举例

• 输入：(mul 3 -7)输出：-21

• 输入：(add 1 2) 输出：3

• 输入：(sub (mul 2 4) (div 9 3)) 输出 ：5

• 输入：(div 1 0) 输出：error

输入描述

合法字符串，字符串长度不超过512，用例保证了无语法错误。

输出描述

输出计算结果或者“error”

示例1

输入
(div 12 (sub 45 45))
输出
error

示例2

输入
(add 1 (div -7 3))
输出
-2

python_56">代码：python

python">import sys


def function():
    expression = input()
    num_stack = []
    operation_stack = []
    mark = 0
    param_one = 0
    param_two = 0

    for i in range(len(expression)):
        ch = expression[i]
        if ch == "(":
            operation_stack.append(expression[i+1: i+4])
            i += 4
            mark = i + 1
        elif ch == ")":
            if mark < i:
                num_stack.append(int(expression[mark: i]))
                i += 1
                mark = i + 1
            param_two = num_stack.pop()
            param_one = num_stack.pop()
            num_stack, operation_stack = calc(num_stack, operation_stack, param_one, param_two)
        else:
            if ch == " ":
                if mark < i:
                    num_stack.append(int(expression[mark: i]))
                    mark = i + 1

    while len(operation_stack) != 0:
        param_two = num_stack.pop()
        param_one = num_stack.pop()
        num_stack, operation_stack = calc(num_stack, operation_stack, param_one, param_two)

    print(num_stack[0])


def calc(num_stack, operation_stack, param_one, param_two):
    op = operation_stack.pop()
    if op == "add":
        num_stack.append(param_one + param_two)
    elif op == "sub":
        num_stack.append(param_one - param_two)
    elif op == "mul":
        num_stack.append(param_one * param_two)
    else:
        if param_two == 0:
            print("error")
            sys.exit()
        else:
            num_stack.append(param_one // param_two)

    return num_stack, operation_stack


if __name__ == '__main__':
    function()

java_120">代码：java

java">import java.util.Scanner;
import java.util.Stack;

public class Main01 {

    static Stack<Integer> num_stack = new Stack<>();   // 数字栈
    static Stack<String> opera_stack = new Stack<>();  // 操作符栈

    // 计算表达式(param_1 op param_2)的值
    public static void calc(int param_1, int param_2) {
        String op = opera_stack.pop();
        if (op.equals("add")) {
            num_stack.push(param_1 + param_2);
        } else if (op.equals("sub")) {
            num_stack.push(param_1 - param_2);
        } else if (op.equals("mul")) {
            num_stack.push(param_1 * param_2);
        } else {
            if (param_2 == 0) {
                System.out.println("error");
                System.exit(0);
            } else {
                int res = param_1 / param_2;
                if (param_1 % param_2 != 0) {
                    if (res < 0) {
                        res -= 1;
                    } else {
                        res += 1;
                    }
                }
                num_stack.push(res);
            }
        }
    }

    public static int solution_01() {
        // 处理输入
        Scanner sc = new Scanner(System.in);
        String exp = sc.nextLine();

        int mark = 0;
        int param_1 = 0;    // 参数1
        int param_2 = 0;    // 参数2

        for (int i=0; i<exp.length(); i++) {
            String ch = exp.charAt(i) + "";
            if (ch.equals("(")) {
                opera_stack.push(exp.substring(i + 1, i + 4));
                i += 4;
                mark = i + 1;
            } else if (ch.equals(")")) {
                if (mark < i) {
                    num_stack.push(Integer.parseInt(exp.substring(mark, i)));
                    i += 1;
                    mark = i + 1;
                }
                param_2 = num_stack.pop();
                param_1 = num_stack.pop();
                calc(param_1, param_2);
            } else {
                if (ch.equals(" ")) {
                    if (mark < i) {
                        num_stack.push(Integer.parseInt(exp.substring(mark, i)));
                        mark = i + 1;
                    }
                }
            }
        }

        while (opera_stack.size()!= 0) {
            param_2 = num_stack.pop();
            param_1 = num_stack.pop();
            calc(param_1, param_2);
        }

        return num_stack.get(0);
    }

    public static void main(String[] args) {
        int ans = solution_01();
        System.out.println(ans);
    }
}

代码：c++

#include <iostream>
#include <stack>
#include <string>

using namespace std;

// 数字栈
stack<int> num_stack;

// 操作符栈
stack<string> opera_stack;

// 计算表达式(param_1 op param_2)的值
void calc(int param_1, int param_2) {
    string op = opera_stack.top();
    opera_stack.pop();
    if (op == "add") {
        num_stack.push(param_1 + param_2);
    } else if (op == "sub") {
        num_stack.push(param_1 - param_2);
    } else if (op == "mul") {
        num_stack.push(param_1 * param_2);
    } else {
        if (param_2 == 0) {
            cout << "error" << endl;
            exit(0);
        } else {
            int res = param_1 / param_2;
            if (param_1 % param_2 != 0) {
                if (res < 0) {
                    res -= 1;
                } else {
                    res += 1;
                }
            }
            num_stack.push(res);
        }
    }
}

int solution_01() {
    // 处理输入
    string exp;
    getline(cin, exp);

    int mark = 0;
    int param_1 = 0; // 参数1
    int param_2 = 0; // 参数2

    for (int i = 0; i < exp.length(); i++) {
        string ch = exp.substr(i, 1);
        if (ch == "(") {
            opera_stack.push(exp.substr(i + 1, 3));
            i += 4;
            mark = i + 1;
        } else if (ch == ")") {
            if (mark < i) {
                num_stack.push(stoi(exp.substr(mark, i - mark)));
                i += 1;
                mark = i + 1;
            }
            param_2 = num_stack.top();
            num_stack.pop();
            param_1 = num_stack.top();
            num_stack.pop();
            calc(param_1, param_2);
        } else {
            if (ch == " ") {
                if (mark < i) {
                    num_stack.push(stoi(exp.substr(mark, i - mark)));
                    mark = i + 1;
                }
            }
        }
    }

    while (!opera_stack.empty()) {
        param_2 = num_stack.top();
        num_stack.pop();
        param_1 = num_stack.top();
        num_stack.pop();
        calc(param_1, param_2);
    }

    return num_stack.top();
}

int main() {
    int ans = solution_01();
    cout << ans << endl;
    return 0;
}

js_305">代码：js

待更新…