Complicated Expression

2016 网易校招的一道题

写了一年多的lua, C++ 都生锈了，拿出来操练一下

 

在lisp语言中，表达式都用前缀法表示，例如，1 + 2 在lisp中使用(+ 1 2)来表示，其中，表达式的括号是必需的。Bob 想实现一种类 lisp 的脚本语言，这个语言中的表达式是这样定义的：

1、每个表达式的形式都是 ( operator arg_1 arg_2 ... )，即由左括号，运算符，运算数，和右括号组成。

2、运算符包括三种，分别是'+', '-', '*'。

3、运算符如果可以接受一个运算数，就称为一元运算符，如果可以接受两个运算数，就称为二元运算符，如果可以接受三个及以上运算数，就称为多元运算符。

+ 可以是一元，二元，乃至多元运算符。

(+ 9) 表示正整数9；

(+ 1 2) 代表 1 + 2；

(+ 1 2 3 4) 代表 1, 2, 3, 4 的连加和。

- 可以是一元或者二元运算符。

(- 9) 表示整数-9；

(- 5 4) 代表 5 - 4。

* 可以是二元运算符或者多元运算符。

(* 2 3) 代表 2 * 3；

(* 1 2 3 4) 代表 1 * 2 * 3 * 4。

4、运算数可以是一个正整数，或者0，还可以是另外一个表达式，例如

(+ (* 2, 3) 1) 也是一个合法的表达式，代表了 2 * 3 + 1

5、运算符与运算数之间，运算数与运算数相互之间都以空格进行分隔。在不产生歧义的情况下，空格也可以省略。例如，

(+ 2 3) 和 ( +2 3) 都被认为是合法的输入，且有相同的意义，代表 2 + 3。(+ 23)也是一个合法的输入，但其代表的是正整数23。

输入
输入由多行组成，第一行包含一个正整数T(T <= 5000)。代表共包含T组测试数据。

接下来会有T行输入。每一行包含一个表达式。这个表达式可能是一个合法的表达式，也可能是不合法的表达式。

每行数据所包含的字符数，不超过1000000。

输入数据中的数字全部是十进制正整数或者0，而且正整数的值不会大于65535。

输入中的表达式只包含三种不同类型的错误，除此之外的情况，都不必考虑。

第一类错误，括号不匹配，例如

(+ (* 2 3) 1)) 多了一个右括号;

+ 2 3 缺少括号等。

第二类错误，运算符缺失，例如

(2 3) 没有运算符。

第三类错误，运算符与数字不匹配，例如

(- 1 2 3)，由于 - 只能接受最多两个算数，所以这也是一个不合法的表达式。

输出
对于合法的表达式，请输出表达式的值，对于不合法的表达式，请输出“invalid expression”。

可以假设最后的结果不超过32位整数的表示范围，但不保证在某些情况下，计算的中间值全部不超过32位整数的表示范围。

样例输入
5
(+ 1 (* 2 3)))
(2 3)
(- 3 2 1)
(+ (+ 1 2) (* 2 3) (- 2 1))
(- 2)
样例输出
invalid expression
invalid expression
invalid expression
10
-2

 

 

 这题就是对栈的使用，学过数据结构的应该都会。只是时间长短而已，不得不承认工作久了写这种东西明显不如学生时代了。

 

源代码：

 

#include <iostream>
//#include <string>
#include <stack>
#include <stdio.h>
#include <string.h>

using namespace std;

typedef std::stack<std::string> strStack;
typedef std::stack<double> valueStack;


inline int parseStr(const char*& str, strStack &tempStack)
{
    const char* begin = str;
    const char* p = str;
    while (*p)
    {
        char buf[50];
        if (*p == '(' || *p == '+' || *p == '-' || *p == '*')
        {
            buf[0] = *p;
            buf[1] = 0;
            tempStack.push(buf);
            if (p == begin)
                ++begin;
        }
        else if (*p == ' ')
        {
            if (p == begin)
                ++begin;
            else
            {
                int size = p - begin;
                strncpy(buf, begin, size);
                buf[size] = 0;
                tempStack.push(buf);
                begin = p + 1;
            }
        }
        else if (*p == ')')
        {
            if (p != begin)
            {
                int size = p - begin;
                strncpy(buf, begin, size);
                buf[size] = 0;
                tempStack.push(buf);
                begin = p + 1;
            }
            ++p;
            break;
        }
        else
        {
            // 可以做一些非法字符检查, 这题貌似不需要
        }
        ++p;
    }
    str = p;
    return 0;
}


inline int calAdd(strStack& stack, double&result)
{
    if (stack.size() < 1)
        return -1;

    double r = 0;
    while (!stack.empty())
    {
        std::string str = stack.top();
        stack.pop();
        double val;
        sscanf(str.c_str(), "%lf", &val);
        r += val;
    }
    result = r;
    return 0;
}

inline int calSub(strStack& stack, double&result)
{
    if (stack.size() < 1 || stack.size() > 2)
        return -1;

    std::string str = stack.top();
    stack.pop();
    double val1;
    sscanf(str.c_str(), "%lf", &val1);
    if (stack.size() == 0)
    {
        result = -val1;
        return 0;
    }

    str = stack.top();
    stack.pop();
    double val2;
    sscanf(str.c_str(), "%lf", &val2);
    result = val1 - val2;

    return 0;
}

inline int calMul(strStack& stack, double& result)
{
    if (stack.size() < 1)
        return -1;

    double r = 1;
    while ( !stack.empty())
    {
        std::string str = stack.top();
        stack.pop();
        double val;
        sscanf(str.c_str(), "%lf", &val);
        r *= val;
    }
    result = r;
    return 0;
}


// 成功返回0
int calSubOprator(strStack& stack, double &result)
{
    int r = 0;
    double val = 0;
    std::string operaterStr = stack.top();
    stack.pop();
    if (operaterStr == "+")
    {
        r = calAdd(stack, val);
    }
    else if (operaterStr == "-")
    {
        r = calSub(stack, val);
    }
    else if (operaterStr == "*")
    {
        r = calMul(stack, val);
    }
    else
        return -1;

    if (r == -1)
        return -1;

    result = val;
    return 0;
}

inline int calcStr(strStack &tempStack, valueStack& resultStack)
{
    strStack temp;
    while (true)
    {
        if (tempStack.empty())
            return -1;

        std::string str = tempStack.top();
        if (str == "#")
        {
            double val = resultStack.top();
            resultStack.pop();
            tempStack.pop();
            char buf[50];
            sprintf(buf, "%d", int(val));
            temp.push(buf);
        }
        else if (str == "(")
        {
            tempStack.pop();
            break;
        }
        else
        {
            temp.push(tempStack.top());
            tempStack.pop();
        }
    }

    double val;
    if (calSubOprator(temp, val) == -1)
        return -1;

    resultStack.push(val);
    return 0;
}


int calc(const char* str, double &resultVal)
{
    if (str == NULL || *str == 0)
        return -1;

    const char* p = str;
    strStack tempStr;
    valueStack tempVal;

    while (true)
    {
        int r = 0;
        r = parseStr(p, tempStr);
        if (r == -1)
            return -1;

        r = calcStr(tempStr, tempVal);
        if (r == -1)
            return -1;

        if (*p == 0)
        {
            if (tempStr.empty())
            {
                resultVal = tempVal.top();
                tempVal.pop();
            }
            else
                return -1;
            break;
        }
        else
        {
            // 临时结果入栈
            tempStr.push("#");
        }
    }

    return 0;
}


int main()
{

    const char*arr[] = {
        "(+ 1 (* 2 3)))",
        "(2 3)",
        "(- 3 2 1)",
        "(+ (+ 1 2) (* 2 3) (- 2 1))",
        "(- 2)"
    };


    for (int i = 0; i < 5; ++i)
    {
        const char* buf = arr[i];
        double result = 0;
        if (calc(buf, result) == 0)
        {
            cout << result << endl;
        }
        else
        {
            cout << "invalid expression" << endl;
        }

    }

    return 0;
}